package com.sukamo.membership.service;

import java.util.List;
import java.util.Date;
import java.util.logging.Logger;
import javax.persistence.EntityManager;
import javax.persistence.EntityTransaction;
import com.sukamo.membership.common.AppContext;
import com.sukamo.membership.common.EmailUtil;
import com.sukamo.membership.common.SearchQuery;
import com.sukamo.membership.dto.SearchRequestVo;
import com.sukamo.membership.common.MembershipException;
import com.sukamo.membership.common.Util;
import com.sukamo.membership.dto.MemberListVo;
import com.sukamo.membership.persistence.entity.Member;
import com.sukamo.membership.persistence.dao.MemberDao;
import com.sukamo.membership.dto.MembershipListVo;
import com.sukamo.membership.persistence.entity.Membership;
import com.sukamo.membership.persistence.dao.MembershipDao;

/**
* Service methods for Membership
*/
public class MembershipService {

    private final static Logger log = Logger.getLogger(MembershipService.class.getName());

    private MemberDao memberDao = null;
    private MembershipDao membershipDao = null;

    private EntityManager entityManager = null; 

    public MembershipService() {
        entityManager = AppContext.getEntityManagerFactory().createEntityManager();
    }

    public MembershipService(EntityManager entityManager) {
        this.entityManager = entityManager;
    }  

    public MemberDao getMemberDao() {
        if (memberDao == null) {
            memberDao = new MemberDao(entityManager);
        }
        return memberDao;
    }

    public MembershipDao getMembershipDao() {
        if (membershipDao == null) {
            membershipDao = new MembershipDao(entityManager);
        }
        return membershipDao;
    }

    public List<Member> getAllMembers() throws MembershipException {
        try {
            return getMemberDao().findAll();
        } catch (Exception e) {
            throw new MembershipException(e);
        }
    }

    public MemberListVo getMembers(int pageNumber, final int itemsPerPage) throws MembershipException {
        try {
            MemberListVo list = new MemberListVo();
            List<Member> elist = getMemberDao().findAll(pageNumber, itemsPerPage);
            for (Member e : elist) {
                list.addMember(e);
            }
            list.setTotalCount(getMemberDao().count());
            return list;
        } catch (Exception e) {
            throw new MembershipException(e);
        }
    }

    public MemberListVo searchMembers(int pageNumber, final int itemsPerPage, List<SearchRequestVo>  userCriteria) throws MembershipException {
        try {
            MemberListVo list = new MemberListVo();
            SearchQuery searchQuery = Util.buildJpaSearchQuery("Member", userCriteria);
            List<Member> searchResults = getMemberDao().search(pageNumber, itemsPerPage, searchQuery.getQuery(), searchQuery.getParameters());
            for (Member patient : searchResults) {
                list.addMember(patient);
            }
            list.setTotalCount(Long.valueOf(getMemberDao().searchCount(searchQuery.getQuery(), searchQuery.getParameters())));
            return list;
        } catch (Exception e) {
            throw new MembershipException(e);
        }
    }

    public Member getMember(Long memberId) throws MembershipException {
        try {
            return getMemberDao().find(memberId);
        } catch (Exception e) {
            throw new MembershipException(e);
        }
    }

    public void deleteMember(Long memberId) throws MembershipException {
        EntityTransaction transaction = entityManager.getTransaction();
        try {
            transaction.begin();
            if (getMemberDao().find(memberId) == null) {
                throw new MembershipException("Member does not exist in the database");
            }
            getMemberDao().remove(getMemberDao().find(memberId));
            transaction.commit();
        } catch (Exception e) {
            transaction.rollback();
            throw new MembershipException(e);
        }
    }

    public Member saveMember(Member member) throws MembershipException {
        if (member == null) {
            throw new MembershipException("Member is null");
        }
        if (!member.getValidationErrors().isEmpty()) {
            throw new MembershipException(member.getValidationErrors());
        }
        EntityTransaction transaction = entityManager.getTransaction();
        try {
            transaction.begin();
            getMemberDao().save(member);
            transaction.commit();
            return member; 
        } catch (Exception e) {
            transaction.rollback();
            throw new MembershipException(e);
        }
    }

    public Member getMemberByEmailId(String emailId) throws MembershipException {
        try {
            return getMemberDao().findByEmailId(emailId);
        } catch (Exception e) {
            throw new MembershipException(e);
        }
    }

    public List<Membership> getAllMemberships() throws MembershipException {
        try {
            return getMembershipDao().findAll();
        } catch (Exception e) {
            throw new MembershipException(e);
        }
    }

    public MembershipListVo getMemberships(int pageNumber, final int itemsPerPage) throws MembershipException {
        try {
            MembershipListVo list = new MembershipListVo();
            List<Membership> elist = getMembershipDao().findAll(pageNumber, itemsPerPage);
            for (Membership e : elist) {
                list.addMembership(e);
            }
            list.setTotalCount(getMembershipDao().count());
            return list;
        } catch (Exception e) {
            throw new MembershipException(e);
        }
    }

    public Membership getMembership(Long membershipId) throws MembershipException {
        try {
            return getMembershipDao().find(membershipId);
        } catch (Exception e) {
            throw new MembershipException(e);
        }
    }

    public void deleteMembership(Long membershipId) throws MembershipException {
        EntityTransaction transaction = entityManager.getTransaction();
        try {
            transaction.begin();
            if (getMembershipDao().find(membershipId) == null) {
                throw new MembershipException("Membership does not exist in the database");
            }
            getMembershipDao().remove(getMembershipDao().find(membershipId));
            transaction.commit();
        } catch (Exception e) {
            transaction.rollback();
            throw new MembershipException(e);
        }
    }

    public Membership saveMembership(Membership membership) throws MembershipException {
        if (membership == null) {
            throw new MembershipException("Membership is null");
        }
        if (!membership.getValidationErrors().isEmpty()) {
            throw new MembershipException(membership.getValidationErrors());
        }
        EntityTransaction transaction = entityManager.getTransaction();
        try {
            transaction.begin();
            getMembershipDao().save(membership);
            transaction.commit();
            return membership; 
        } catch (Exception e) {
            transaction.rollback();
            throw new MembershipException(e);
        }
    }
}