/*
    * Copyright 2007 The International Moth Class Association (IMCA)
    *
    * Licensed under the Apache 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.apache.org/licenses/LICENSE-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 net.sf.imca.services;
  
  import java.util.Arrays;
  import java.util.Collection;
  import java.util.Date;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Vector;
  
  import javax.mail.MessagingException;
  
  import net.sf.imca.model.AssociationComparator;
  import net.sf.imca.model.CommitteeMemberComparator;
  import net.sf.imca.model.MembershipTypeBO;
  import net.sf.imca.model.PersonBO;
  import net.sf.imca.model.AssociationBO;
  import net.sf.imca.model.entities.AssociationDAO;
  import net.sf.imca.model.entities.AssociationEntity;
  import net.sf.imca.model.entities.CommitteeMemberDAO;
  import net.sf.imca.model.entities.CommitteeMemberEntity;
  import net.sf.imca.model.entities.FeeEntity;
  import net.sf.imca.model.entities.MembershipDAO;
  import net.sf.imca.model.entities.MembershipEntity;
  import net.sf.imca.model.entities.MembershipTypeEntity;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  /**
   * Service IMCA Committee member use cases.
   *
   * @author dougculnane
   */
  public class CommitteeService extends Service {
  
      /**
       * Apache Commons Logger specific to this class.
       */
      private Log log = LogFactory.getLog(CommitteeService.class);
  
      /**
       * Get the Persons membership list on the current date.
       *
       * @param person The person for the membership filter.
       * @return A Membership Entity Array.
       */
      public MembershipEntity[] getMembershipList(PersonBO person) {
          return getMembershipList(person, new Date());
      }
   
      /**
       * Get the Persons membership list on the reference date.
       *
       * @param person The person for the membership filter.
       * @param refDate The data for the membership list.
       * @return A Membership Entity Array.
       */
      public MembershipEntity[] getMembershipList(PersonBO person, Date refDate) {
      
          this.startTransaction();
          MembershipEntity[] memberArray = getFilteredMembershipList(person, true, refDate);
          try {
              this.endTransaction();
          } catch (Exception ex) {
              log.error(ex);
              return null;
          }
          return memberArray;
              
      }
  
      public AssociationBO[] getCommitteeMemberships(PersonBO person) {
          this.startTransaction();
          AssociationBO[] associations = person.getCommitteeMemberships(em);
          try {
              this.endTransaction();
          } catch (Exception ex) {
              log.error(ex);
              return null;
          }
          return associations;
      }
  
      public AssociationBO[] getOficialIMCACommitteeMemberships(PersonBO person) {
         this.startTransaction();
         AssociationBO[] associations = person.getOficialIMCACommitteeMemberships(em);
         try {
             this.endTransaction();
         } catch (Exception ex) {
             log.error(ex);
             return null;
         }
         return associations;
     }
 
     public AssociationBO[] getAllAssociations() {
         this.startTransaction();
         AssociationDAO dao = new AssociationDAO();
         List<AssociationEntity> list = dao.getAllAssociations(em);
         
         AssociationBO[] associations = new AssociationBO[list.size()];
         
         for (int i=0; i < associations.length;i++ ){
             associations[i] = new AssociationBO(list.get(i));
         }
         try {
             this.endTransaction();
         } catch (Exception ex) {
             log.error(ex);
             return null;
         }
         return associations;
     }
     
     
     public AssociationBO getAssociation(String countryCode, String area) {
         this.startTransaction();
         AssociationBO ass = new AssociationBO(em, countryCode, area);
         try {
             this.endTransaction();
         } catch (Exception ex) {
             log.error(ex);
         }
         return ass;
     }
     
     
     
     public AssociationBO[] getAssociations(boolean official) {
         this.startTransaction();
         AssociationDAO dao = new AssociationDAO();
         List<AssociationEntity> list = dao.getAssociations(em, official);
         
         AssociationBO[] array = new  AssociationBO[list.size()];
         for (int i=0; i < array.length; i++) {
             array[i] = new AssociationBO(list.get(i));
         }
         
         Arrays.sort(array, new AssociationComparator());
         
         return array;
     }
     
     public CommitteeMemberEntity[] getImcaWorldAssociationCommittee() {
         return getAssociationCommittee(AssociationBO.IMCA_WORLD_COUNTRY_CODE, "");
     }
     
     public CommitteeMemberEntity[] getAssociationCommittee(String landCode, String area) {
         this.startTransaction();
        
         CommitteeMemberDAO dao = new CommitteeMemberDAO();
         List<CommitteeMemberEntity> list = dao.getAssociationsComitteeInCountry(
                 em, landCode, area);
         
         CommitteeMemberEntity[] committee = new CommitteeMemberEntity[list.size()];
         
         for (int i=0; i < committee.length; i++ ){
             committee[i] = list.get(i);
             committee[i].getPerson().getAddress();
         }
         
         try {
             this.endTransaction();
         } catch (Exception ex) {
             log.error(ex);
         }
         
         Arrays.sort(committee, new CommitteeMemberComparator());
        
         return committee;
     }
 
     public boolean getOnImcaCommittee(PersonBO person) {
 
         if (person == null || person.getEntity() == null) {
             return false;
         }
         if (getOficialIMCACommitteeMemberships(person).length > 0 ){
             return true;
         }
         return false;
     }
 
     public void saveNewMembershipType(long associationId, String membershipType,
             String currencyCode, double fee, Date startDate, Date endDate) {
         
         this.startTransaction();
          
         AssociationEntity associationEntity = 
             em.find(AssociationEntity.class, associationId);
         
         FeeEntity feeEntity = new FeeEntity();
         feeEntity.setAmount(fee);
         feeEntity.setCurrency(currencyCode);
         
         
         MembershipTypeEntity memType = new MembershipTypeEntity();
         memType.setCurrentFee(feeEntity);
         memType.setAssociation(associationEntity);
         memType.setValidFrom(startDate);
         memType.setValidTo(endDate);
         memType.setName(membershipType);
         
         em.persist(feeEntity);
         em.persist(memType);
         em.persist(associationEntity);
         try {
             this.endTransaction();
         } catch (Exception ex) {
             log.error(ex);
         }
     }
 
     public MembershipEntity[] getMembershipRequestList(PersonBO person) {
         
         this.startTransaction();
         MembershipEntity[] memberArray = getFilteredMembershipList(person, false);
         try {
             this.endTransaction();
         } catch (Exception ex) {
             log.error(ex);
             return null;
         }
         return memberArray;
         
     }
 
     /**
      * List the members in the Associations the Persons is a Committee member 
      * off.
      *
      * @param person that is a Committee member.
      * @param paidFilter Filer for paid value.
      * @return A Membership Entity Array.
      */
     private MembershipEntity[] getFilteredMembershipList(PersonBO person, boolean paidFilter) {
         
         AssociationBO[] associations = person.getCommitteeMemberships(em);
         Vector<MembershipEntity> members = new Vector<MembershipEntity>();
         
         for (int i=0; i < associations.length; i++) {
             Collection<MembershipEntity> mems = associations[i].getEntity().getMembers();
             Iterator<MembershipEntity> iter = mems.iterator();
             while(iter.hasNext()) {
                 MembershipEntity membershipEntity = iter.next();
                 if (paidFilter == membershipEntity.getPaid()) {
                     members.add(membershipEntity);
                 }
             }
             
         }
 
         MembershipEntity[] memberArray = new MembershipEntity[members.size()];
         for (int i=0; i < memberArray.length; i++) {
             memberArray[i] = members.get(i);
         }
         return memberArray;
     }
 
     /**
      * List the members in the Associations the Persons is a Committee member 
      * off for the reference date.
      *
      * @param person that is a Committee member.
      * @param paidFilter Filer for paid value.
      * @return A Membership Entity Array.
      */
     private MembershipEntity[] getFilteredMembershipList(PersonBO person,
             boolean paidFilter, Date refDate) {
 
         AssociationBO[] associations = person.getCommitteeMemberships(em);
         Vector<MembershipEntity> members = new Vector<MembershipEntity>();
 
         for (int i=0; i < associations.length; i++) {
             Collection<MembershipEntity> mems = associations[i].getEntity().getMembers();
             Iterator<MembershipEntity> iter = mems.iterator();
             while(iter.hasNext()) {
                 MembershipEntity membershipEntity = iter.next();
                 if (paidFilter == membershipEntity.getPaid() && 
                         dateinRange(membershipEntity.getType().getValidFrom(), 
                                     membershipEntity.getType().getValidTo(), refDate)){ 
                     members.add(membershipEntity);
                 }
             }
         }
 
         MembershipEntity[] memberArray = new MembershipEntity[members.size()];
         for (int i=0; i < memberArray.length; i++) {
             memberArray[i] = members.get(i);
         }
 
         return memberArray;
     }
 
     /**
      * Is the date in the range.
      *
      * @param from Date range start.
      * @param to Date range end.
      * @param ref Reference date.
      * @return true if in range.
      */
     private boolean dateinRange(Date from, Date to, Date ref) {
         if (ref.equals(from)) {
             return true;
         } else if (ref.equals(to)) {
             return true;
         } else {
             return from.before(ref) && to.after(ref);
         }
     }
 
     /**
      * Delete the Membership entity with the id.
      *
      * @param id of membership entity.
      * @return true if success.
      */
     public boolean deleteMembershipEntity(long id) {
         this.startTransaction();
         MembershipEntity memberEntity = em.find(MembershipEntity.class, id);
         log.info("Deleting Membership Entity: " + memberEntity);
         memberEntity.getType().getAssociation().getMembers().remove(memberEntity);
         em.persist(memberEntity.getType().getAssociation());
         em.remove(memberEntity);
         try {
             this.endTransaction();
         } catch (Exception ex) {
             log.error(ex);
             return false;
         }
         return true;
     }
 
     /**
      * Delete the Membership Type entity with the id.
      *
      * @param id of membership Type entity.
      * @return true if success.
      */
     public boolean deleteMembershipTypeEntity(long id) {
         this.startTransaction();
         MembershipTypeEntity memberTypeEntity = em.find(MembershipTypeEntity.class, id);
         log.info("Deleting Membership Type Entity: " + memberTypeEntity);
         em.remove(memberTypeEntity);
         try {
             this.endTransaction();
         } catch (Exception ex) {
             log.error(ex);
             return false;
         }
         return true;
     }
 
     /**
      * Set the paid flag to true for the Membership entity with the id.
      *
      * @param id of membership entity.
      * @return true if success.
      */
     public boolean confirmPaidMembershipEntity(long id) {
         this.startTransaction();
         MembershipEntity memberEntity = em.find(MembershipEntity.class, id);
         log.info("Confirm Paid Membership Entity: " + memberEntity);
         memberEntity.setPaid(true);
         memberEntity.setNote(memberEntity.getNote() + "Confirmed Paid " + 
                 new Date() + ".  \n");
         em.persist(memberEntity);
         
         PersonBO person = new PersonBO(em, memberEntity.getPerson().getId());
         try {
             person.sendMembershipConfirmationMail(em, memberEntity.getType());
         } catch (MessagingException e) {
             log.error("Error sending confirmation email. " + e.getMessage(), e);
         }
         try {
             this.endTransaction();
         } catch (Exception ex) {
             log.error(ex);
             return false;
         }
         return true;
     }
 
     public AssociationBO getAssociation(long associationId) {
         this.startTransaction();
         
         AssociationBO association = 
             new AssociationBO(em.find(AssociationEntity.class, associationId));
         try {
             this.endTransaction();
         } catch (Exception ex) {
             log.error(ex);
             return null;
         }
         return association;
     }
 
     public void saveAssociationData(AssociationEntity entity) {
         this.startTransaction();
         em.find(AssociationEntity.class, entity.getId());
     }
 
     /**
      * 
      * @param associationId
      * @param paymentExplanation
      * @param url
      * @return true if success.
      */
     public boolean saveAssociationData(long associationId,
             String paymentExplanation, String url) {
 
         this.startTransaction();
         AssociationEntity entity = em.find(AssociationEntity.class, associationId);
         entity.setPaymentExplanation(paymentExplanation);
         entity.setUrl(url);
         em.persist(entity);
         try {
             this.endTransaction();
         } catch (Exception ex) {
             log.error(ex);
             return false;
         }
         return true;
     }
 
     public MembershipTypeBO getMembershipType(long membershipTypeId) {
         this.startTransaction();
         
         MembershipTypeBO membershipType = 
             new MembershipTypeBO(em.find(MembershipTypeEntity.class, membershipTypeId));
         try {
             this.endTransaction();
         } catch (Exception ex) {
             log.error(ex);
             return null;
         }
         return membershipType;
     }
 
     public MembershipTypeBO[] getEditableMembershipTypes(PersonBO person) {
         
         AssociationBO[] assosiations = this.getOficialIMCACommitteeMemberships(person);
         Vector<MembershipTypeEntity> memTypes = new Vector<MembershipTypeEntity>();
 
         this.startTransaction();
         for (int i=0; i < assosiations.length; i++) {
             List<MembershipTypeEntity> list = assosiations[i].getJoinableMembershipTypes(em);
             Iterator<MembershipTypeEntity> iterator = list.iterator();
             while (iterator.hasNext()){
                 memTypes.add(iterator.next());
             }
         }
         try {
             this.endTransaction();
         } catch (Exception ex) {
             log.error(ex);
             return null;
         }
 
         MembershipTypeBO[] returnArray = new MembershipTypeBO[memTypes.size()];
         for (int i=0; i < memTypes.size(); i++) {
             returnArray[i] = new MembershipTypeBO(memTypes.get(i));
         }
         return returnArray;
     }
 
     /**
      * Save the MembershipType with the following parameters.
      *
      * @param membershipTypeId
      * @param membershipType
      * @param currencyCode
      * @param fee
      * @param startDate
      * @param endDate
      * @return true if success.
      */
     public boolean saveMembershipType(long membershipTypeId, String membershipType,
             String currencyCode, double fee, Date startDate, Date endDate) {
 
         this.startTransaction();
 
         FeeEntity feeEntity = new FeeEntity();
         feeEntity.setAmount(fee);
         feeEntity.setCurrency(currencyCode);
 
         MembershipTypeEntity memType = em.find(MembershipTypeEntity.class, membershipTypeId);
         memType.setCurrentFee(feeEntity);
         memType.setValidFrom(startDate);
         memType.setValidTo(endDate);
         memType.setName(membershipType);
 
         em.persist(feeEntity);
         em.persist(memType);
         try {
             this.endTransaction();
         } catch (Exception ex) {
             log.error(ex);
             return false;
         }
         return true;
     }
 
     public boolean getHasLinkedMemberships(long membershipTypeId) {
 
         MembershipTypeBO membershipType = getMembershipType(membershipTypeId);
         this.startTransaction();
 
         MembershipDAO dao = new MembershipDAO();
         boolean hasLinkedMemberships = 
             dao.getHasLinkedMemberships(em, membershipType.getEntity());
         try {
             this.endTransaction();
         } catch (Exception ex) {
             log.error(ex);
             return false;
         }
         return hasLinkedMemberships;
     }
 
     public boolean addMember(long membershipTypeId, String email) {
         
         MembershipTypeBO membershipType = getMembershipType(membershipTypeId);
         this.startTransaction();
         PersonBO person = new PersonBO(em, email);
         boolean success = false;
         if (person.getEntity() != null && membershipType.getEntity() != null) {
             MembershipEntity memEnt = new MembershipEntity();
             memEnt.setPerson(person.getEntity());
             memEnt.setFee(membershipType.getEntity().getCurrentFee());
             memEnt.setType(membershipType.getEntity());
             memEnt.setPaid(true);
             memEnt.setNote("Added member:" + (new Date()).toString());
             membershipType.getEntity().getAssociation().getMembers().add(memEnt);
             
             AssociationEntity association = em.find(AssociationEntity.class, membershipType.getEntity().getAssociation().getId());
             association.getMembers().add(memEnt);
             
             em.persist(memEnt);
             em.persist(association);
             
             success = true;
         }
         try {
             this.endTransaction();
         } catch (Exception ex) {
             log.error(ex);
             return false;
         }
         return success;
     }
 }