/**
    * Copyright 2010 The Kuali Foundation Licensed under the
    * Educational Community License, Version 2.0 (the "License"); you may
    * not use this file except in compliance with the License. You may
    * obtain a copy of the License at
    *
    * http://www.osedu.org/licenses/ECL-2.0
    *
    * Unless required by applicable law or agreed to in writing,
   * software distributed under the License is distributed on an "AS IS"
   * BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
   * or implied. See the License for the specific language governing
   * permissions and limitations under the License.
   */
  
  package org.kuali.student.common.assembly.util;
  
  import java.util.ArrayList;
  import java.util.List;
  
  import org.apache.log4j.Logger;
  import org.kuali.student.common.assembly.data.AssemblyException;
  import org.kuali.student.common.assembly.data.LookupMetadata;
  import org.kuali.student.common.assembly.data.LookupParamMetadata;
  import org.kuali.student.common.assembly.data.Metadata.WriteAccess;
  import org.kuali.student.common.search.dto.SearchParam;
  import org.kuali.student.common.search.dto.SearchRequest;
  import org.kuali.student.common.search.dto.SearchResult;
  import org.kuali.student.common.search.dto.SearchResultCell;
  import org.kuali.student.common.search.dto.SearchResultRow;
  import org.kuali.student.common.search.service.SearchDispatcher;
  
  /**
   * Builds and issues SearchRequests parameterized with the information from LookupMetadata and the provided ID
   * 
   * @author Kuali Student Team
   *
   */
  public class IdTranslator {
      
      private static final String ENUMERATION = "enumeration";
  	private List<SearchParam> additionalParams = new ArrayList<SearchParam>();
      private SearchDispatcher searchDispatcher;
      
      final Logger LOG = Logger.getLogger(IdTranslator.class);
  
      public IdTranslator(SearchDispatcher searchDispatcher) throws AssemblyException {
      	this.searchDispatcher = searchDispatcher;
      }
      
  	private SearchRequest buildSearchRequestById(LookupMetadata lookupMetadata, String searchId) {
      	SearchRequest sr = new SearchRequest();
      	sr.setNeededTotalResults(false);
      	
      	sr.setSearchKey(lookupMetadata.getSearchTypeId());
      	sr.setSortColumn(lookupMetadata.getResultSortKey());
  
  
      	List<SearchParam> searchParams = new ArrayList<SearchParam>();
      	if (lookupMetadata.getSearchParamIdKey() != null) {
      		//FIXME: workaround until orch dict can handle multi part keys on initiallookup defs
      		if (lookupMetadata.getSearchParamIdKey().contains(ENUMERATION)) {
      			for (LookupParamMetadata p : lookupMetadata.getParams()) {
      				if (p.getWriteAccess() != null && p.getWriteAccess().equals(WriteAccess.NEVER) && p.getDefaultValueString() != null) {
      					SearchParam param = createParam(p.getKey(), p.getDefaultValueString());
      					searchParams.add(param);   							    
      				}
      				else if (p.getWriteAccess() == null || !p.getWriteAccess().equals(WriteAccess.NEVER)){
      					SearchParam param = createParam(p.getKey(), searchId);
      					searchParams.add(param);   								
      				}
      			}
      		}
      		else {
      			SearchParam param = createParam(lookupMetadata.getSearchParamIdKey(), searchId);
      			searchParams.add(param);	
      		}
  
      		sr.setParams(searchParams); 		
      	}	
      	else {
      		LOG.warn("Unable to build search request for " + lookupMetadata.getSearchTypeId() + " translation for id " + searchId);
      		
      	}
  
      	
      	sr.getParams().addAll(additionalParams);
  
          return sr;
      }
      
      private SearchParam createParam(String key, String value) {
      	SearchParam param = new SearchParam();
      	
      	if(key == null) {
  			param.setKey("");
  		} else {
  			param.setKey(key);
  		}
 
     	if(value == null) {
 			param.setValue("");
 		} else {
 			param.setValue(value);
 		}
     	
     	return param;
     }
     
     public IdTranslation getTranslation(LookupMetadata lookupMetadata, String id) throws AssemblyException {
         SearchRequest searchRequest = buildSearchRequestById(lookupMetadata, id);
         SearchResult searchResults = null;
 		
 		searchResults = searchDispatcher.dispatchSearch(searchRequest);
 			
 		
         IdTranslation result = null; 
         if(searchResults != null && searchResults.getRows().size() > 0){
         	result = new IdTranslation();
         	result.setId(id);
         	
         	SearchResultRow r = searchResults.getRows().get(0);
             for(SearchResultCell c: r.getCells()){
                 if(c.getKey().equals(lookupMetadata.getResultDisplayKey())){
                     result.addAttribute(c.getKey(), c.getValue());
                     result.setDisplay(c.getValue());
                 } else {
                     result.addAttribute(c.getKey(), c.getValue());
                 }
             }
         }
         return result;
         
     }
 
     public String getTranslationForAtp(String value) {
         SearchRequest searchRequest = new SearchRequest();
         searchRequest.setSearchKey("atp.search.advancedAtpSearch");
         ArrayList<SearchParam> searchParams = new ArrayList<SearchParam>();
         SearchParam searchParam = new SearchParam();
         searchParam.setKey("atp.advancedAtpSearchParam.atpId");
         searchParam.setValue(value);
         searchParams.add(searchParam);
         searchRequest.setParams(searchParams);
         SearchResult searchResult = searchDispatcher.dispatchSearch(searchRequest);
         if(searchResult!= null){
             for (SearchResultRow resultRow : searchResult.getRows()) {
                 for (SearchResultCell searchResultCell : resultRow.getCells()) {
                     if(searchResultCell.getKey().equals("atp.resultColumn.atpDescrPlain")){
                         return searchResultCell.getValue();
                     }
                 }
             }
         }
         return null;
     }
 }