package org.kuali.rice.kim.impl.responsibility;

 import org.apache.commons.lang.StringUtils;

 import org.apache.commons.logging.Log;

 import org.apache.commons.logging.LogFactory;

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

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

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

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

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

 import org.kuali.rice.core.api.exception.RiceIllegalArgumentException;

 import org.kuali.rice.core.api.exception.RiceIllegalStateException;

 import org.kuali.rice.core.api.mo.common.Attributes;

 import org.kuali.rice.core.api.resourceloader.GlobalResourceLoader;

 import org.kuali.rice.core.util.AttributeSet;

 import org.kuali.rice.kim.impl.common.attribute.AttributeTransform;

 import org.kuali.rice.kim.api.common.delegate.Delegate;

 import org.kuali.rice.kim.api.common.template.Template;

 import org.kuali.rice.kim.api.common.template.TemplateQueryResults;

 import org.kuali.rice.kim.api.responsibility.Responsibility;

 import org.kuali.rice.kim.api.responsibility.ResponsibilityAction;

 import org.kuali.rice.kim.api.responsibility.ResponsibilityQueryResults;

 import org.kuali.rice.kim.api.responsibility.ResponsibilityService;

 import org.kuali.rice.kim.api.role.Role;

 import org.kuali.rice.kim.api.role.RoleResponsibilityAction;

 import org.kuali.rice.kim.api.type.KimType;

 import org.kuali.rice.kim.api.type.KimTypeInfoService;

 import org.kuali.rice.kim.bo.role.dto.DelegateInfo;

 import org.kuali.rice.kim.bo.role.dto.RoleMembershipInfo;

 import org.kuali.rice.kim.impl.common.attribute.KimAttributeDataBo;

 import org.kuali.rice.kim.impl.role.RoleResponsibilityActionBo;

 import org.kuali.rice.kim.impl.role.RoleResponsibilityBo;

 import org.kuali.rice.kim.service.RoleService;

 import org.kuali.rice.kim.util.KIMPropertyConstants;

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

 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 static org.kuali.rice.core.api.criteria.PredicateFactory.*;

 public class ResponsibilityServiceImpl implements ResponsibilityService {

     private static final Integer DEFAULT_PRIORITY_NUMBER = Integer.valueOf(1);

     private static final Log LOG = LogFactory.getLog(ResponsibilityServiceImpl.class);

     private BusinessObjectService businessObjectService;

     private CriteriaLookupService criteriaLookupService;

     private KimResponsibilityTypeService defaultResponsibilityTypeService;

     private KimTypeInfoService kimTypeInfoService;

     private RoleService roleService;

     @Override

     public void createResponsibility(final Responsibility responsibility) throws RiceIllegalArgumentException, RiceIllegalStateException {

         if (responsibility == null) {

             throw new RiceIllegalArgumentException("responsibility is null");

         }

         if (StringUtils.isNotBlank(responsibility.getId()) && getResponsibility(responsibility.getId()) != null) {

             throw new RiceIllegalStateException("the responsibility to create already exists: " + responsibility);

         }

         List<ResponsibilityAttributeBo> attrBos = KimAttributeDataBo.createFrom(ResponsibilityAttributeBo.class, responsibility.getAttributes(), responsibility.getTemplate().getKimTypeId());

         ResponsibilityBo bo = ResponsibilityBo.from(responsibility);

         bo.setAttributeDetails(attrBos);

         businessObjectService.save(bo);

     }

     @Override

     public void updateResponsibility(final Responsibility responsibility) throws RiceIllegalArgumentException, RiceIllegalStateException {

         if (responsibility == null) {

             throw new RiceIllegalArgumentException("responsibility is null");

         }

         if (StringUtils.isBlank(responsibility.getId()) || getResponsibility(responsibility.getId()) == null) {

             throw new RiceIllegalStateException("the responsibility does not exist: " + responsibility);

         }

         List<ResponsibilityAttributeBo> attrBos = KimAttributeDataBo.createFrom(ResponsibilityAttributeBo.class, responsibility.getAttributes(), responsibility.getTemplate().getKimTypeId());

         ResponsibilityBo bo = ResponsibilityBo.from(responsibility);

         bo.getAttributeDetails().addAll(attrBos);

         businessObjectService.save(bo);

     }

     @Override

     public Responsibility getResponsibility(final String id) {

         if (id == null) {

             throw new RiceIllegalArgumentException("id is null");

         }

         return ResponsibilityBo.to(businessObjectService.findBySinglePrimaryKey(ResponsibilityBo.class, id));

     }

     @Override

     public List<Responsibility> findRespsByNamespaceCodeAndName(final String namespaceCode, final String name) {

         if (namespaceCode == null) {

             throw new RiceIllegalArgumentException("namespaceCode is null");

         }

         if (name == null) {

             throw new RiceIllegalArgumentException("name is null");

         }

         final Map<String, String> crit = new HashMap<String, String>();

         crit.put("namespaceCode", namespaceCode);

         crit.put("name", name);

         crit.put("active", "Y");

         final Collection<ResponsibilityBo> bos = businessObjectService.findMatching(ResponsibilityBo.class, Collections.unmodifiableMap(crit));

         final List<Responsibility> ims = new ArrayList<Responsibility>();

         if (bos != null) {

             for (ResponsibilityBo bo : bos) {

                 if (bo != null) {

                     ims.add(ResponsibilityBo.to(bo));

                 }

             }

         }

         return Collections.unmodifiableList(ims);

     }

     @Override

     public Template getResponsibilityTemplate(final String id) {

         if (id == null) {

             throw new RiceIllegalArgumentException("id is null");

         }

         return ResponsibilityTemplateBo.to(businessObjectService.findBySinglePrimaryKey(ResponsibilityTemplateBo.class, id));

     }

     @Override

     public List<Template> findRespTemplatesByNamespaceCodeAndName(final String namespaceCode, final String name) {

         if (namespaceCode == null) {

             throw new RiceIllegalArgumentException("namespaceCode is null");

         }

         if (name == null) {

             throw new RiceIllegalArgumentException("name is null");

         }

         final Map<String, String> crit = new HashMap<String, String>();

         crit.put("namespaceCode", namespaceCode);

         crit.put("name", name);

         crit.put("active", "Y");

         final Collection<ResponsibilityTemplateBo> bos = businessObjectService.findMatching(ResponsibilityTemplateBo.class, Collections.unmodifiableMap(crit));

         final List<Template> ims = new ArrayList<Template>();

         if (bos != null) {

             for (ResponsibilityTemplateBo bo : bos) {

                 if (bo != null) {

                     ims.add(ResponsibilityTemplateBo.to(bo));

                 }

             }

         }

         return Collections.unmodifiableList(ims);

     }

     @Override

     public boolean hasResponsibility(final String principalId, final String namespaceCode, final String respName, final Attributes qualification, final Attributes responsibilityDetails) {

         // get all the responsibility objects whose name match that requested

         final List<Responsibility> responsibilities = findRespsByNamespaceCodeAndName(namespaceCode, respName);

         return hasResp(principalId, namespaceCode, responsibilities, qualification, responsibilityDetails);

     }

     @Override

     public boolean hasResponsibilityByTemplateName(final String principalId, final String namespaceCode, final String respTemplateName, final Attributes qualification, final Attributes responsibilityDetails) {

         // get all the responsibility objects whose name match that requested

         final List<Responsibility> responsibilities = findRespsByNamespaceCodeAndTemplateName(namespaceCode, respTemplateName);

         return hasResp(principalId, namespaceCode, responsibilities, qualification, responsibilityDetails);

     }

     private boolean hasResp(final String principalId, final String namespaceCode, final List<Responsibility> responsibilities, final Attributes qualification, final Attributes responsibilityDetails) {

         // now, filter the full list by the detail passed

         final List<String> ids = new ArrayList<String>();

         for (Responsibility r : getMatchingResponsibilities(responsibilities, responsibilityDetails)) {

             ids.add(r.getId());

         }

         final List<String> roleIds = getRoleIdsForResponsibilities(ids, qualification);

         return roleService.principalHasRole(principalId, roleIds, new AttributeSet(qualification.toMap()));

     }

     @Override

     public List<ResponsibilityAction> getResponsibilityActions(final String namespaceCode, final String responsibilityName, final Attributes qualification, final Attributes responsibilityDetails) {

         // get all the responsibility objects whose name match that requested

         List<Responsibility> responsibilities = findRespsByNamespaceCodeAndName(namespaceCode, responsibilityName);

         return getRespActions(namespaceCode, responsibilities, qualification, responsibilityDetails);

     }

     @Override

     public List<ResponsibilityAction> getResponsibilityActionsByTemplateName(final String namespaceCode, final String respTemplateName, final Attributes qualification, final Attributes responsibilityDetails) {

         // get all the responsibility objects whose name match that requested

         List<Responsibility> responsibilities = findRespsByNamespaceCodeAndTemplateName(namespaceCode, respTemplateName);

         return getRespActions(namespaceCode, responsibilities, qualification, responsibilityDetails);

     }

     private List<ResponsibilityAction> getRespActions(final String namespaceCode, final List<Responsibility> responsibilities, final Attributes qualification, final Attributes responsibilityDetails) {

         // now, filter the full list by the detail passed

         List<Responsibility> applicableResponsibilities = getMatchingResponsibilities(responsibilities, responsibilityDetails);

         List<ResponsibilityAction> results = new ArrayList<ResponsibilityAction>();

         for (Responsibility r : applicableResponsibilities) {

             List<String> roleIds = getRoleIdsForResponsibility(r.getId(), qualification);

             results.addAll(getActionsForResponsibilityRoles(r, roleIds, qualification));

         }

         return results;

     }

     private List<ResponsibilityAction> getActionsForResponsibilityRoles(Responsibility responsibility, List<String> roleIds, Attributes qualification) {

         List<ResponsibilityAction> results = new ArrayList<ResponsibilityAction>();

         Collection<RoleMembershipInfo> roleMembers = roleService.getRoleMembers(roleIds, new AttributeSet(qualification.toMap()));

         for (RoleMembershipInfo rm : roleMembers) {

             // only add them to the list if the member ID has been populated

             if (StringUtils.isNotBlank(rm.getMemberId())) {

                 final ResponsibilityAction.Builder rai = ResponsibilityAction.Builder.create();

                 rai.setMemberRoleId(rm.getEmbeddedRoleId());

                 rai.setRoleId(rm.getRoleId());

                 rai.setQualifier(Attributes.fromMap(rm.getQualifier()));

                 final List<Delegate.Builder> bs = new ArrayList<Delegate.Builder>();

                 for (DelegateInfo d : rm.getDelegates()) {

                     Delegate.Builder newD = Delegate.Builder.create(d.getDelegationId(), d.getDelegationTypeCode(), d.getMemberId(), d.getMemberTypeCode(), d.getRoleMemberId(), d.getQualifier());

                     bs.add(newD);

                 }

                 rai.setDelegates(bs);

                 rai.setResponsibilityId(responsibility.getId());

                 rai.setResponsibilityName(responsibility.getName());

                 rai.setResponsibilityNamespaceCode(responsibility.getNamespaceCode());

                 if (rm.getMemberTypeCode().equals(Role.PRINCIPAL_MEMBER_TYPE)) {

                     rai.setPrincipalId(rm.getMemberId());

                 } else {

                     rai.setGroupId(rm.getMemberId());

                 }

                 // get associated resp resolution objects

                 RoleResponsibilityAction action = getResponsibilityAction(rm.getRoleId(), responsibility.getId(), rm.getRoleMemberId());

                 if (action == null) {

                     LOG.error("Unable to get responsibility action record for role/responsibility/roleMember: "

                             + rm.getRoleId() + "/" + responsibility.getId() + "/" + rm.getRoleMemberId());

                     LOG.error("Skipping this role member in getActionsForResponsibilityRoles()");

                     continue;

                 }

                 // add the data to the ResponsibilityActionInfo objects

                 rai.setActionTypeCode(action.getActionTypeCode());

                 rai.setActionPolicyCode(action.getActionPolicyCode());

                 rai.setPriorityNumber(action.getPriorityNumber() == null ? DEFAULT_PRIORITY_NUMBER : action.getPriorityNumber());

                 rai.setForceAction(action.isForceAction());

                 rai.setParallelRoutingGroupingCode((rm.getRoleSortingCode() == null) ? "" : rm.getRoleSortingCode());

                 rai.setRoleResponsibilityActionId(action.getId());

                 results.add(rai.build());

             }

         }

         return results;

     }

     private RoleResponsibilityAction getResponsibilityAction(String roleId, String responsibilityId, String roleMemberId) {

         final Predicate p =

                 or(

                         and(

                                 equal("roleResponsibility.responsibilityId", responsibilityId),

                                 equal("roleResponsibility.roleId", roleId),

                                 equal("roleResponsibility.active", "Y"),

                                 or(

                                         equal(KIMPropertyConstants.RoleMember.ROLE_MEMBER_ID, roleMemberId),

                                         equal(KIMPropertyConstants.RoleMember.ROLE_MEMBER_ID, "*")

                                 )

                         ),

                         and(

                                 equal("roleResponsibilityId", "*"),

                                 equal(KIMPropertyConstants.RoleMember.ROLE_MEMBER_ID, roleMemberId)

                         )

                 );

         final QueryByCriteria.Builder builder = QueryByCriteria.Builder.create();

         builder.setPredicates(p);

         final GenericQueryResults<RoleResponsibilityActionBo> results = criteriaLookupService.lookup(RoleResponsibilityActionBo.class, builder.build());

         final List<RoleResponsibilityActionBo> bos = results.getResults();

         //seems a little dubious that we are just returning the first result...

         return !bos.isEmpty() ? RoleResponsibilityActionBo.to(bos.get(0)) : null;

     }

     @Override

     public List<String> getRoleIdsForResponsibility(String id, Attributes qualification) {

         if (StringUtils.isBlank(id)) {

             throw new RiceIllegalArgumentException("id is blank");

         }

         if (qualification == null) {

             throw new RiceIllegalArgumentException("qualification is null");

         }

         final List<String> roleIds = getRoleIdsForPredicate(and(equal("responsibilityId", id), equal("active", "Y")));

         //TODO filter with qualifiers

         return roleIds;

     }

     @Override

     public ResponsibilityQueryResults findResponsibilities(final QueryByCriteria queryByCriteria) {

         if (queryByCriteria == null) {

             throw new RiceIllegalArgumentException("queryByCriteria is null");

         }

         LookupCustomizer.Builder<ResponsibilityBo> lc = LookupCustomizer.Builder.create();

         lc.setPredicateTransform(AttributeTransform.getInstance());

         GenericQueryResults<ResponsibilityBo> results = criteriaLookupService.lookup(ResponsibilityBo.class, queryByCriteria, lc.build());

         ResponsibilityQueryResults.Builder builder = ResponsibilityQueryResults.Builder.create();

         builder.setMoreResultsAvailable(results.isMoreResultsAvailable());

         builder.setTotalRowCount(results.getTotalRowCount());

         final List<Responsibility.Builder> ims = new ArrayList<Responsibility.Builder>();

         for (ResponsibilityBo bo : results.getResults()) {

             ims.add(Responsibility.Builder.create(bo));

         }

         builder.setResults(ims);

         return builder.build();

     }

     @Override

     public TemplateQueryResults findResponsibilityTemplates(final QueryByCriteria queryByCriteria) {

         if (queryByCriteria == null) {

             throw new RiceIllegalArgumentException("queryByCriteria is null");

         }

         GenericQueryResults<ResponsibilityTemplateBo> results = criteriaLookupService.lookup(ResponsibilityTemplateBo.class, queryByCriteria);

         TemplateQueryResults.Builder builder = TemplateQueryResults.Builder.create();

         builder.setMoreResultsAvailable(results.isMoreResultsAvailable());

         builder.setTotalRowCount(results.getTotalRowCount());

         final List<Template.Builder> ims = new ArrayList<Template.Builder>();

         for (ResponsibilityTemplateBo bo : results.getResults()) {

             ims.add(Template.Builder.create(bo));

         }

         builder.setResults(ims);

         return builder.build();

     }

     /**

      * Compare each of the passed in responsibilities with the given responsibilityDetails.  Those that

      * match are added to the result list.

      */

     private List<Responsibility> getMatchingResponsibilities(List<Responsibility> responsibilities, Attributes responsibilityDetails) {

         // if no details passed, assume that all match

         if (responsibilityDetails == null || responsibilityDetails.isEmpty()) {

             return responsibilities;

         }

         final List<Responsibility> applicableResponsibilities = new ArrayList<Responsibility>();

         // otherwise, attempt to match the permission details

         // build a map of the template IDs to the type services

         Map<String, KimResponsibilityTypeService> responsibilityTypeServices = getResponsibilityTypeServicesByTemplateId(responsibilities);

         // build a map of permissions by template ID

         Map<String, List<Responsibility>> responsibilityMap = groupResponsibilitiesByTemplate(responsibilities);

         // loop over the different templates, matching all of the same template against the type

         // service at once

         for (Map.Entry<String, List<Responsibility>> respEntry : responsibilityMap.entrySet()) {

             KimResponsibilityTypeService responsibilityTypeService = responsibilityTypeServices.get(respEntry.getKey());

             List<Responsibility> responsibilityInfos = respEntry.getValue();

             if (responsibilityTypeService == null) {

                 responsibilityTypeService = defaultResponsibilityTypeService;

             }

             applicableResponsibilities.addAll(responsibilityTypeService.getMatchingResponsibilities(new AttributeSet(responsibilityDetails.toMap()), responsibilityInfos));

         }

         return applicableResponsibilities;

     }

     private Map<String, KimResponsibilityTypeService> getResponsibilityTypeServicesByTemplateId(Collection<Responsibility> responsibilities) {

         Map<String, KimResponsibilityTypeService> responsibilityTypeServices = new HashMap<String, KimResponsibilityTypeService>(responsibilities.size());

         for (Responsibility responsibility : responsibilities) {

             final Template t = responsibility.getTemplate();

             final KimType type = kimTypeInfoService.getKimType(t.getKimTypeId());

             final String serviceName = type.getServiceName();

             if (serviceName != null) {

                 KimResponsibilityTypeService responsibiltyTypeService = GlobalResourceLoader.getService(serviceName);

                 if (responsibiltyTypeService != null) {

                     responsibilityTypeServices.put(responsibility.getTemplate().getId(), responsibiltyTypeService);

                 } else {

                     responsibilityTypeServices.put(responsibility.getTemplate().getId(), defaultResponsibilityTypeService);

                 }

             }

         }

         return responsibilityTypeServices;

     }

     private Map<String, List<Responsibility>> groupResponsibilitiesByTemplate(Collection<Responsibility> responsibilities) {

         final Map<String, List<Responsibility>> results = new HashMap<String, List<Responsibility>>();

         for (Responsibility responsibility : responsibilities) {

             List<Responsibility> responsibilityInfos = results.get(responsibility.getTemplate().getId());

             if (responsibilityInfos == null) {

                 responsibilityInfos = new ArrayList<Responsibility>();

                 results.put(responsibility.getTemplate().getId(), responsibilityInfos);

             }

             responsibilityInfos.add(responsibility);

         }

         return results;

     }

     private List<String> getRoleIdsForResponsibilities(Collection<String> ids, Attributes qualification) {

         final List<String> roleIds = getRoleIdsForPredicate(and(in("responsibilityId", ids.toArray()), equal("active", "Y")));

         //TODO filter with qualifiers

         return roleIds;

     }

     private List<String> getRoleIdsForPredicate(Predicate p) {

         final QueryByCriteria.Builder builder = QueryByCriteria.Builder.create();

         builder.setPredicates(p);

         final GenericQueryResults<RoleResponsibilityBo> qr = criteriaLookupService.lookup(RoleResponsibilityBo.class, builder.build());

         final List<String> roleIds = new ArrayList<String>();

         for (RoleResponsibilityBo bo : qr.getResults()) {

             roleIds.add(bo.getRoleId());

         }

         return roleIds;

     }

     private List<Responsibility> findRespsByNamespaceCodeAndTemplateName(final String namespaceCode, final String templateName) {

         if (namespaceCode == null) {

             throw new RiceIllegalArgumentException("namespaceCode is null");

         }

         if (templateName == null) {

             throw new RiceIllegalArgumentException("name is null");

         }

         final Map<String, String> crit = new HashMap<String, String>();

         crit.put("namespaceCode", namespaceCode);

         crit.put("name", templateName);

         crit.put("active", "Y");

         final Collection<ResponsibilityBo> bos = businessObjectService.findMatching(ResponsibilityBo.class, Collections.unmodifiableMap(crit));

         final List<Responsibility> ims = new ArrayList<Responsibility>();

         if (bos != null) {

             for (ResponsibilityBo bo : bos) {

                 if (bo != null) {

                     ims.add(ResponsibilityBo.to(bo));

                 }

             }

         }

         return Collections.unmodifiableList(ims);

     }

     public void setBusinessObjectService(BusinessObjectService businessObjectService) {

         this.businessObjectService = businessObjectService;

     }

     public void setCriteriaLookupService(final CriteriaLookupService criteriaLookupService) {

         this.criteriaLookupService = criteriaLookupService;

     }

     public void setDefaultResponsibilityTypeService(final KimResponsibilityTypeService defaultResponsibilityTypeService) {

         this.defaultResponsibilityTypeService = defaultResponsibilityTypeService;

     }

     public void setKimTypeInfoService(final KimTypeInfoService kimTypeInfoService) {

         this.kimTypeInfoService = kimTypeInfoService;

     }

     public void setRoleService(final RoleService roleService) {

         this.roleService = roleService;

     }

 }