package org.kuali.rice.krms.impl.repository;

 import java.util.ArrayList;

 import java.util.Collection;

 import java.util.Collections;

 import java.util.HashMap;

 import java.util.List;

 import java.util.Map;

 import org.apache.commons.lang.StringUtils;

 import org.kuali.rice.core.api.criteria.CriteriaLookupService;

 import org.kuali.rice.core.api.criteria.GenericQueryResults;

 import org.kuali.rice.core.api.criteria.Predicate;

 import org.kuali.rice.core.api.criteria.QueryByCriteria;

 import org.kuali.rice.krad.service.BusinessObjectService;

 import org.kuali.rice.krad.service.KRADServiceLocator;

 import org.kuali.rice.krms.api.repository.RuleRepositoryService;

 import org.kuali.rice.krms.api.repository.agenda.AgendaTreeDefinition;

 import org.kuali.rice.krms.api.repository.agenda.AgendaTreeRuleEntry;

 import org.kuali.rice.krms.api.repository.agenda.AgendaTreeSubAgendaEntry;

 import org.kuali.rice.krms.api.repository.context.ContextDefinition;

 import org.kuali.rice.krms.api.repository.context.ContextSelectionCriteria;

 import org.kuali.rice.krms.api.repository.rule.RuleDefinition;

 import org.kuali.rice.krms.impl.util.KRMSPropertyConstants;

 import static org.kuali.rice.core.api.criteria.PredicateFactory.*;

 /**

  *

  */

 public class RuleRepositoryServiceImpl implements RuleRepositoryService {

     protected BusinessObjectService businessObjectService;

     private CriteriaLookupService criteriaLookupService;

         /**

          * This overridden method ...

          * 

          * @see org.kuali.rice.krms.api.repository.RuleRepositoryService#selectContext(org.kuali.rice.krms.api.repository.context.ContextSelectionCriteria)

          */

     @Override

     public ContextDefinition selectContext(

                     ContextSelectionCriteria contextSelectionCriteria) {

             if (contextSelectionCriteria == null){

                     throw new IllegalArgumentException("selection criteria is null");

             }

             if (StringUtils.isBlank(contextSelectionCriteria.getNamespaceCode())){

                     throw new IllegalArgumentException("selection criteria namespace code is null or blank");

             }

             QueryByCriteria queryCriteria = buildQuery(contextSelectionCriteria);

         GenericQueryResults<ContextBo> results = criteriaLookupService.lookup(ContextBo.class, queryCriteria);

             List<ContextBo> resultBos = results.getResults();

             //assuming 1 ?

             ContextDefinition result = null;

             if (resultBos != null) {

                     if (resultBos.size() == 1) {

                             ContextBo bo = resultBos.iterator().next();

                             return ContextBo.to(bo);

                     }

                     else throw new IllegalArgumentException("ambiguous qualifiers");

             }

             return result;

     }

         @Override

         public AgendaTreeDefinition getAgendaTree(String agendaId) {

                 if (StringUtils.isBlank(agendaId)){

                     throw new IllegalArgumentException("agenda id is null or blank");

             }

                 // Get agenda items from db, then build up agenda tree structure

                 AgendaBo agendaBo = getBusinessObjectService().findBySinglePrimaryKey(AgendaBo.class, agendaId);

                 String agendaItemId = agendaBo.getFirstItemId();

                 // walk thru the agenda items, building an agenda tree definition Builder along the way

                 AgendaTreeDefinition.Builder myBuilder = AgendaTreeDefinition.Builder.create();

                 myBuilder.setAgendaId( agendaId );

                 myBuilder = walkAgendaItemTree(agendaItemId, myBuilder);

                 // build the agenda tree and return it

                 return myBuilder.build();

         }

         @Override

         public List<AgendaTreeDefinition> getAgendaTrees(List<String> agendaIds) {

                 List<AgendaTreeDefinition> agendaTrees = new ArrayList<AgendaTreeDefinition>();

                 for (String agendaId : agendaIds){

                         agendaTrees.add( getAgendaTree(agendaId) );

                 }

         return Collections.unmodifiableList(agendaTrees);                

         }

         @Override

         public RuleDefinition getRule(String ruleId) {

                 if (StringUtils.isBlank(ruleId)){

                         return null;                        

                 }

                 RuleBo bo = getBusinessObjectService().findBySinglePrimaryKey(RuleBo.class, ruleId);

                 return RuleBo.to(bo);

         }

         @Override

         public List<RuleDefinition> getRules(List<String> ruleIds) {

                 Map<String,String> fieldValues = new HashMap<String,String>();

                 for (String ruleId : ruleIds){

                         fieldValues.put("id", ruleId);

                 }

                 Collection<RuleBo> bos = getBusinessObjectService().findMatching(RuleBo.class, fieldValues);

                 ArrayList<RuleDefinition> rules = new ArrayList<RuleDefinition>();

         for (RuleBo bo : bos) {

             RuleDefinition rule = RuleBo.to(bo);

             rules.add(rule);

         }

         return Collections.unmodifiableList(rules);

         }

         /**

          * Recursive method to create AgendaTreeDefinition builder

          *         

          *  

          */

         private AgendaTreeDefinition.Builder walkAgendaItemTree(String agendaItemId, AgendaTreeDefinition.Builder builder){

                 //TODO: prevent circular, endless looping

                 if (StringUtils.isBlank(agendaItemId)){

                         return null;

                 }

                 // Get AgendaItem Business Object from database

                 // NOTE: if we read agendaItem one at a time from db.   Could consider linking in OJB and getting all at once

                 AgendaItemBo agendaItemBo = getBusinessObjectService().findBySinglePrimaryKey(AgendaItemBo.class, agendaItemId);

                 // If Rule  

                 // TODO: validate that only either rule or subagenda, not both

                 if (!StringUtils.isBlank( agendaItemBo.getRuleId() )){

                         // setup new rule entry builder

                         AgendaTreeRuleEntry.Builder ruleEntryBuilder = AgendaTreeRuleEntry.Builder

                                         .create(agendaItemBo.getId(), agendaItemBo.getRuleId());

                         ruleEntryBuilder.setRuleId( agendaItemBo.getRuleId() );

                         ruleEntryBuilder.setAgendaItemId( agendaItemBo.getId() );

                         if (agendaItemBo.getWhenTrueId() != null){

                                 // Go follow the true branch, creating AgendaTreeDefinintion Builder for the

                                 // true branch level

                                 AgendaTreeDefinition.Builder myBuilder = AgendaTreeDefinition.Builder.create();

                                 myBuilder.setAgendaId( agendaItemBo.getAgendaId() );

                                 ruleEntryBuilder.setIfTrue( walkAgendaItemTree(agendaItemBo.getWhenTrueId(),myBuilder));

                         }

                         if (agendaItemBo.getWhenFalseId() != null){

                                 // Go follow the false branch, creating AgendaTreeDefinintion Builder 

                                 AgendaTreeDefinition.Builder myBuilder = AgendaTreeDefinition.Builder.create();

                                 myBuilder.setAgendaId( agendaItemBo.getAgendaId() );

                                 ruleEntryBuilder.setIfFalse( walkAgendaItemTree(agendaItemBo.getWhenFalseId(), myBuilder));

                         }

                         // Build the Rule Entry and add it to the AgendaTreeDefinition builder

                         builder.addRuleEntry( ruleEntryBuilder.build() );

                 }

                 // if SubAgenda and a sub agenda tree entry

                 if (!StringUtils.isBlank(agendaItemBo.getSubAgendaId())) {

                         AgendaTreeSubAgendaEntry.Builder subAgendaEntryBuilder = 

                                 AgendaTreeSubAgendaEntry.Builder.create(agendaItemBo.getId(), agendaItemBo.getSubAgendaId());

                         builder.addSubAgendaEntry( subAgendaEntryBuilder.build() );

                         }

                 // if this agenda item has an "After Id", follow that branch

                 if (!StringUtils.isBlank( agendaItemBo.getAlwaysId() )){

                         builder = walkAgendaItemTree( agendaItemBo.getAlwaysId(), builder);

                 }

                 return builder;

         }

         /**

          * 

          * This method converts a {@link ContextSelectionCriteria} object into a

          * {@link QueryByCriteria} object with the proper predicates for AttributeBo properties.

          * 

          * @param selectionCriteria

          * @return 

          */

         private QueryByCriteria buildQuery( ContextSelectionCriteria selectionCriteria ){

                 Predicate p;

                 QueryByCriteria.Builder qBuilder = QueryByCriteria.Builder.create();

             List<Predicate> pList = new ArrayList<Predicate>();

             if (selectionCriteria.getNamespaceCode() != null){

                     p = equal(KRMSPropertyConstants.Context.NAMESPACE, selectionCriteria.getNamespaceCode());

                     pList.add(p);

             }

             if (selectionCriteria.getName() != null){

                     p = equal(KRMSPropertyConstants.Context.NAME, selectionCriteria.getName());

                     pList.add(p);

             }

             if (selectionCriteria.getContextQualifiers() != null){

                     for (Map.Entry<String, String> entry : selectionCriteria.getContextQualifiers().entrySet()){

                             p = and(equal(KRMSPropertyConstants.Context.ATTRIBUTE_BOS

                                             + "." + KRMSPropertyConstants.BaseAttribute.ATTRIBUTE_DEFINITION

                                             + "." + KRMSPropertyConstants.KrmsAttributeDefinition.NAME, entry.getKey()),

                                     equal(KRMSPropertyConstants.Context.ATTRIBUTE_BOS

                                             + "." + KRMSPropertyConstants.BaseAttribute.VALUE, entry.getValue()));

                             pList.add(p);

                     }

             }

              Predicate[] preds = new Predicate[pList.size()];

              pList.toArray(preds);

             qBuilder.setPredicates(and(preds)); 

                 return qBuilder.build();

         }

         /**

      * Sets the businessObjectService property.

      *

      * @param businessObjectService The businessObjectService to set.

      */

     public void setBusinessObjectService(final BusinessObjectService businessObjectService) {

         this.businessObjectService = businessObjectService;

     }

     protected BusinessObjectService getBusinessObjectService() {

                 if ( businessObjectService == null ) {

                         businessObjectService = KRADServiceLocator.getBusinessObjectService();

                 }

                 return businessObjectService;

         }

     /**

      * Sets the criteriaLookupService attribute value.

      *

      * @param criteriaLookupService The criteriaLookupService to set.

      */

     public void setCriteriaLookupService(final CriteriaLookupService criteriaLookupService) {

         this.criteriaLookupService = criteriaLookupService;

     }

 }