/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package com.bestray.healthcareemr.ServiceImpl;

import com.bestray.healthcarecommonutil.dao.AllergiesMasterDao;
import com.bestray.healthcarecommonutil.dao.DiagnosisMasterDao;
import com.bestray.healthcarecommonutil.dao.MedicationMasterDao;
import com.bestray.healthcarecommonutil.exception.DataAccessException;
import com.bestray.healthcarecommonutil.exception.HealthCareException;
import com.bestray.healthcarecommonutil.exception.ProcessingException;
import com.bestray.healthcarecommonutil.service.OrderResultService;
import com.bestray.healthcarecommonutil.service.OrderSpecimenCollectionService;
import com.bestray.healthcarecommonutil.vo.TAllergiesMaster;
import com.bestray.healthcarecommonutil.vo.TAppointment;
import com.bestray.healthcarecommonutil.vo.TDiagnosisMaster;
import com.bestray.healthcarecommonutil.vo.TEncounterAllergy;
import com.bestray.healthcarecommonutil.vo.TEncounterDiagnosis;
import com.bestray.healthcarecommonutil.vo.TEncounterHistoryVisit;
import com.bestray.healthcarecommonutil.vo.TEncounterMedication;
import com.bestray.healthcarecommonutil.vo.TEncounterProcedure;
import com.bestray.healthcarecommonutil.vo.TEncounterVitalSign;
import com.bestray.healthcarecommonutil.vo.TMedicationMaster;
import com.bestray.healthcarecommonutil.vo.TPatEncOrderResults;
import com.bestray.healthcarecommonutil.vo.TPatient;
import com.bestray.healthcarecommonutil.vo.TPatientEncounter;
import com.bestray.healthcarecommonutil.vo.TProcedureMaster;
import com.bestray.healthcareemr.Dao.PatientEncounterAllergyDao;
import com.bestray.healthcareemr.Dao.PatientEncounterDao;
import com.bestray.healthcareemr.Dao.PatientEncounterDiagnosisDao;
import com.bestray.healthcareemr.Dao.PatientEncounterMedicationDao;
import com.bestray.healthcareemr.Dao.PatientEncounterProcedureDao;
import com.bestray.healthcareemr.Dao.PatientEncounterVisitHistoryDao;
import com.bestray.healthcareemr.Dao.PatientEncounterVitalSignsDao;
import com.bestray.healthcarecommonutil.dao.ProcedureMasterDao;
import com.bestray.healthcarecommonutil.service.RecentPatientService;
import com.bestray.healthcareemr.Service.PatientEncounterService;
import com.bestray.healthcarecommonutil.util.Initcap;
import com.bestray.healthcarecommonutil.util.PatientClone;
import com.bestray.healthcarecommonutil.vo.TDepartmentMaster;
import com.bestray.healthcarecommonutil.vo.TDoctorInformation;
import com.bestray.healthcarecommonutil.vo.TRecentPatient;
import com.bestray.healthcareemr.Dao.AppointmentDao;
import com.bestray.healthcareemr.Dao.XrayImageDao;
import com.bestray.healthcareemr.Vo.XrayImage;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.JTable;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.hibernate3.HibernateOptimisticLockingFailureException;
import org.springframework.stereotype.Service;

// TODO: Auto-generated Javadoc
/**
 * The Class PatientEncounterServiceImpl.
 *
 * @author user3
 */
@Service
public class PatientEncounterServiceImpl implements PatientEncounterService{
    
    /** The out patient dao. */
    @Autowired
    private PatientEncounterDao patientEncounterDao;
    
    /** The allergies master dao. */
    @Autowired
    private AllergiesMasterDao allergiesMasterDao;
    
    /** The medication master dao. */
    @Autowired
    private MedicationMasterDao medicationMasterDao;
    
    /** The procedure master dao. */
    @Autowired
    private ProcedureMasterDao procedureMasterDao;
    
    @Autowired
    private DiagnosisMasterDao diagnosisMasterDao;
    
    @Autowired
    private AppointmentDao appointmentDao;
    
    @Autowired
    private RecentPatientService recentPatientService;
    
    /** The allergy. */
    private TAllergiesMaster allergy;
    
    /** The medication. */
    private TMedicationMaster medication;
    
    /** The procedure. */
    private TProcedureMaster procedure;
    
    private TDiagnosisMaster diagnosis;
    
    /** The enc. */
    private TPatientEncounter enc;
    
    /** The encounter allergy. */
    private TEncounterAllergy encounterAllergy;
    
    /** The encounter medication. */
    private TEncounterMedication encounterMedication;
    
    /** The encounter procedure. */
    private TEncounterProcedure encounterProcedure;
    
    private TEncounterDiagnosis encounterDiagnosis;
    
    /** The sdf. */
    private SimpleDateFormat sdf;
    
    @Autowired
    private PatientEncounterAllergyDao patientEncounterAllergyDao;
    
    @Autowired
    private PatientEncounterDiagnosisDao patientEncounterDiagnosisDao;
    
    @Autowired
    private PatientEncounterMedicationDao patientEncounterMedicationDao;
    
    @Autowired
    private PatientEncounterProcedureDao patientEncounterProcedureDao;
    
    @Autowired
    private PatientEncounterVitalSignsDao patientEncounterVitalSignsDao;
    
    @Autowired
    private XrayImageDao xrayImageDao;
    
    @Autowired
    private PatientEncounterVisitHistoryDao patientEncounterVisitHistoryDao;
    
    @Autowired
    private OrderResultService orderResultService;
    
    @Autowired
    private OrderSpecimenCollectionService orderSpecimenCollectionService;

    public PatientEncounterServiceImpl() {
        allergy = new TAllergiesMaster();
        medication = new TMedicationMaster();
        procedure = new TProcedureMaster();
        enc = new TPatientEncounter();
        diagnosis = new TDiagnosisMaster();
        sdf = new SimpleDateFormat("dd-MM-YYYY");
    }
    
    /**
     * Instantiates a new out patient service impl.
     *
     * @param outPatientDao the out patient dao
     * @param allergiesMasterDao the allergies master dao
     * @param medicationMasterDao the medication master dao
     * @param procedureMasterDao the procedure master dao
     */
    /*public PatientEncounterServiceImpl(PatientEncounterDao patientEncounterDao,AllergiesMasterDao allergiesMasterDao,
            MedicationMasterDao medicationMasterDao,ProcedureMasterDao procedureMasterDao, 
            DiagnosisMasterDao diagnosisMasterDao,
            PatientEncounterAllergyDao patientEncounterAllergyDao, PatientEncounterDiagnosisDao patientEncounterDiagnosisDao,
            PatientEncounterMedicationDao patientEncounterMedicationDao,PatientEncounterProcedureDao patientEncounterProcedureDao,
            PatientEncounterVitalSignsDao patientEncounterVitalSignsDao, PatientEncounterVisitHistoryDao patientEncounterVisitHistoryDao, OrderResultService orderResultService, 
            OrderSpecimenCollectionService orderSpecimenCollectionService) {
        this.patientEncounterDao=patientEncounterDao;
        this.allergiesMasterDao=allergiesMasterDao; 
        this.medicationMasterDao =medicationMasterDao;
        this.procedureMasterDao=procedureMasterDao;
        this.diagnosisMasterDao=diagnosisMasterDao;
        this.patientEncounterAllergyDao=patientEncounterAllergyDao;
        this.patientEncounterDiagnosisDao=patientEncounterDiagnosisDao;
        this.patientEncounterMedicationDao=patientEncounterMedicationDao;
        this.patientEncounterProcedureDao=patientEncounterProcedureDao;
        this.patientEncounterVitalSignsDao=patientEncounterVitalSignsDao;
        this.patientEncounterVisitHistoryDao=patientEncounterVisitHistoryDao;
        this.orderResultService = orderResultService;
        this.orderSpecimenCollectionService = orderSpecimenCollectionService;
        allergy = new TAllergiesMaster();
        medication = new TMedicationMaster();
        procedure = new TProcedureMaster();
        enc = new TPatientEncounter();
        diagnosis = new TDiagnosisMaster();
        sdf = new SimpleDateFormat("dd-MM-YYYY");
    }*/


    /* (non-Javadoc)
     * @see com.bestray.healthcareemr.Service.PatientEncounterService#saveEncounter(com.bestray.healthcareemr.Vo.TPatientEncounter, javax.swing.JTable, javax.swing.JTable, javax.swing.JTable, com.bestray.healthcareemr.Vo.TEncounterVitalSign, com.bestray.healthcareemr.Vo.TEncounterHistoryVisit)
     */
    @Override
    public TPatientEncounter saveEncounter(TPatientEncounter encounter, JTable allergy_table, JTable medication_table,JTable diagnosis_table,JTable procedure_table,TEncounterVitalSign vitalsign,TEncounterHistoryVisit visitHistory,List<Long> removeprocids, List<Long> removediaglist, List<Long> removeallergylist) throws ProcessingException,HibernateOptimisticLockingFailureException,IllegalArgumentException {
        Date d = new Date();
        try {
            encounterAllergy = new TEncounterAllergy();
            encounterMedication = new TEncounterMedication();
            encounterProcedure = new TEncounterProcedure();
            encounterDiagnosis = new TEncounterDiagnosis();
            enc = patientEncounterDao.savePatientEncounterInfo(encounter);
            TRecentPatient recPatient = PatientClone.getPatient(encounter.getPatient());
            recentPatientService.saveRecentPatient(recPatient);
            
            if(removeallergylist.size()>0){
             for(Long ids:removeallergylist){
                patientEncounterAllergyDao.deleteEncounterAllergies(ids);
             }
           }
            for(int i=0;i<allergy_table.getRowCount();i++){
                String allergyname = allergy_table.getValueAt(i, 0).toString();
                TAllergiesMaster allergies = allergiesMasterDao.getAllergy(allergyname);
                if(allergies!=null){
                    allergy = allergies;
                }else{
                    allergy.setAllergiesName(Initcap.toInitCap(allergyname));
                    allergy.setCreatedDate(d);
                    allergy.setAllergiesStatus("ACTIVE");
                    allergiesMasterDao.saveAllergiesMaster(allergy);
                    allergy = allergiesMasterDao.getAllergy(allergyname);
                }
                Object reaction = allergy_table.getValueAt(i, 1);
                Object severity = allergy_table.getValueAt(i, 2);
                Object comments = allergy_table.getValueAt(i, 3);
                if(allergy_table.getValueAt(i, 4)!=null){
                    //encounterAllergy.setId(Long.valueOf(allergy_table.getValueAt(i, 4).toString()));
                    encounterAllergy = patientEncounterAllergyDao.getEncAllergyById(Long.valueOf(allergy_table.getValueAt(i, 4).toString()));
                }else{
                    encounterAllergy.setId(null);
                }
                encounterAllergy.setAllergy(allergy);
                encounterAllergy.setEncounter(enc);
                if(severity!=null){
                    encounterAllergy.setSeverity(String.valueOf(severity));
                }else{
                    encounterAllergy.setSeverity(null);
                }
                if(reaction!=null){
                    encounterAllergy.setReaction(String.valueOf(reaction));
                }else{
                    encounterAllergy.setReaction(null);
                }
                if(comments!=null){
                    encounterAllergy.setComments(String.valueOf(comments));
                }else{
                    encounterAllergy.setComments(null);
                }
                patientEncounterAllergyDao.saveAllergyEncounter(encounterAllergy);
            }
           for(int i=0;i<medication_table.getRowCount();i++){
               String id = medication_table.getValueAt(i, 0).toString();
               String medicationname = medication_table.getValueAt(i, 1).toString();
               TMedicationMaster medications = medicationMasterDao.getMedication(medicationname);
               if(medications!=null){
                    medication = medications;
                }else{
                    medication.setMedicationName(medicationname.toUpperCase());
                    medication.setCreatedDate(d);
                    medication.setMedicationStatus("ACTIVE");
                    medication.setMedicationDose(null);
                    medication.setMedicationFrequency(null);
                    medicationMasterDao.saveMedicationMaster(medication);
                    medication = medicationMasterDao.getMedication(medicationname);
                }
                String dose = medication_table.getValueAt(i, 2).toString();
                String frequency = medication_table.getValueAt(i, 3).toString();
                String route = medication_table.getValueAt(i, 4).toString();
                String comments = medication_table.getValueAt(i, 5).toString();
                String status = medication_table.getValueAt(i, 6).toString();
                String reorderStatus = medication_table.getValueAt(i, 7).toString();
                TPatientEncounter encId = null;
                if(!medication_table.getValueAt(i, 8).toString().equalsIgnoreCase("-")){
                    encId = (TPatientEncounter)medication_table.getValueAt(i, 8);
                }
                if(status.equalsIgnoreCase("Not Taking")){
                    encounterMedication.setStatus(0);
                }else if(status.equalsIgnoreCase("Canceled")){
                    encounterMedication.setStatus(2);
                }else{
                    encounterMedication.setStatus(1);
                }
                encounterMedication.setMedication(medication);
                encounterMedication.setDose(dose);
                encounterMedication.setFrequency(frequency);
                encounterMedication.setRoute(route);
                encounterMedication.setComments(comments);
                if(id.equalsIgnoreCase("-")){
                    encounterMedication.setEncounterMed(enc);
                    patientEncounterMedicationDao.saveMedicationEncounter(encounterMedication);
                }else{
                    if(reorderStatus.equalsIgnoreCase("ReOrdered")){
                        encounterMedication.setEncounterMed(enc);
                        encounterMedication.setStatus(1);
                        patientEncounterMedicationDao.saveMedicationEncounter(encounterMedication);
                        //updating
                        encounterMedication = patientEncounterMedicationDao.getEncMedById(Long.parseLong(id));
                        //encounterMedication.setId(Long.parseLong(id));
                        encounterMedication.setEncounterMed(encId);
                        encounterMedication.setStatus(0);
                        patientEncounterMedicationDao.updateMedicationEncounter(encounterMedication);
                    }else if(status.equalsIgnoreCase("taking") && !reorderStatus.equalsIgnoreCase("ReOrdered")){
                        encounterMedication = patientEncounterMedicationDao.getEncMedById(Long.parseLong(id));
                        //encounterMedication.setId(Long.parseLong(id));
                        encounterMedication.setEncounterMed(encId);
                        encounterMedication.setStatus(1);
                        patientEncounterMedicationDao.updateMedicationEncounter(encounterMedication);
                    }else if(status.equalsIgnoreCase("not taking") && !reorderStatus.equalsIgnoreCase("ReOrdered")){
                        encounterMedication = patientEncounterMedicationDao.getEncMedById(Long.parseLong(id));
                        //encounterMedication.setId(Long.parseLong(id));
                        encounterMedication.setEncounterMed(encId);
                        encounterMedication.setStatus(0);
                        patientEncounterMedicationDao.updateMedicationEncounter(encounterMedication);
                    }else if(status.equalsIgnoreCase("canceled")){
                        encounterMedication = patientEncounterMedicationDao.getEncMedById(Long.parseLong(id));
                        //encounterMedication.setId(Long.parseLong(id));
                        encounterMedication.setEncounterMed(encId);
                        encounterMedication.setStatus(2);
                        patientEncounterMedicationDao.updateMedicationEncounter(encounterMedication);
                    }
                    
                }
                
           }
           
           if(removeprocids.size()>0){
             for(Long ids:removeprocids){
                TEncounterProcedure removeProcedure = patientEncounterProcedureDao.getProcedureEncounterByID(ids);
                orderResultService.deleteOrderResultsEncounter(removeProcedure, enc);
                orderSpecimenCollectionService.deleteSpecimenDetailsEncounter(removeProcedure, enc);
                patientEncounterProcedureDao.deleteEncounterProcedure(ids);
             }
           }
           for(int i=0;i<procedure_table.getRowCount();i++){
               String procedurename = procedure_table.getValueAt(i, 0).toString();
               TProcedureMaster procedures = procedureMasterDao.getProcedure(procedurename);
               if(procedures!=null){
                    procedure = procedures;
                }else{
                    procedure.setProcedureName(Initcap.toInitCap(procedurename));
                    procedure.setCreatedDate(d);
                    procedure.setProcedureStatus("ACTIVE");
                    procedureMasterDao.saveProcedureMaster(procedure);
                    procedure = procedureMasterDao.getProcedure(procedurename);
                }
               
               Object procedurecomments = procedure_table.getValueAt(i, 1);
               Date orderdate = (Date)procedure_table.getValueAt(i, 3);
               String orderby = String.valueOf(procedure_table.getValueAt(i, 4));
               String orderstatus = String.valueOf(procedure_table.getValueAt(i, 5));
               String activeinactive = String.valueOf(procedure_table.getValueAt(i, 6));
               String specimencoll = String.valueOf(procedure_table.getValueAt(i, 7));
               String orderrecived = procedure_table.getValueAt(i, 8).toString();
               Date resultdate = (Date)procedure_table.getValueAt(i, 9);
               
               if(procedure_table.getValueAt(i, 2)!=null){
                    //encounterProcedure.setId(Long.valueOf(procedure_table.getValueAt(i, 2).toString()));
                   encounterProcedure = patientEncounterProcedureDao.getProcedureEncounterByID(Long.valueOf(procedure_table.getValueAt(i, 2).toString()));
                }else{
                   encounterProcedure.setId(null);
                }
               
                encounterProcedure.setProcedure(procedure);
                encounterProcedure.setEncounterProcedure(enc);
                if(procedurecomments!=null){
                    encounterProcedure.setComments(String.valueOf(procedurecomments));
                }else{
                    encounterProcedure.setComments(null);
                }
                encounterProcedure.setOrderDate(orderdate);
                encounterProcedure.setOrderBy(orderby);
                encounterProcedure.setOrderStatus(orderstatus);
                encounterProcedure.setOrderActiveInactiveStatus(activeinactive);
                encounterProcedure.setOrderSpecimenCollectionStatus(specimencoll);
                encounterProcedure.setPatientRecieved(orderrecived);
                encounterProcedure.setOrderResultedDate(resultdate);
                patientEncounterProcedureDao.saveProcedureEncounter(encounterProcedure);
           }
           
           if(removediaglist.size()>0){
             for(Long ids:removediaglist){
                patientEncounterDiagnosisDao.deleteEncounterDiagnosis(ids);
             }
           }           
           for(int i=0;i<diagnosis_table.getRowCount();i++){
               String diagnosisname = diagnosis_table.getValueAt(i, 1).toString();
               TDiagnosisMaster diagnosiss = diagnosisMasterDao.getDiagnosis(diagnosisname);
               if(diagnosiss!=null){
                    diagnosis = diagnosiss;
                }else{
                    diagnosis.setDiagnosisName(Initcap.toInitCap(diagnosisname));
                    diagnosis.setCreatedDate(d);
                    diagnosis.setDiagnosisStatus("ACTIVE");
                    diagnosisMasterDao.saveDiagnosisMaster(diagnosis);
                    diagnosis = diagnosisMasterDao.getDiagnosis(diagnosisname);
                }
               Object diagnosiscomments = diagnosis_table.getValueAt(i, 2);
               if(diagnosis_table.getValueAt(i, 3)!=null){
                    //encounterDiagnosis.setId(Long.valueOf(diagnosis_table.getValueAt(i, 3).toString()));
                   encounterDiagnosis = patientEncounterDiagnosisDao.getEncDiagById(Long.valueOf(diagnosis_table.getValueAt(i, 3).toString()));
                }else{
                    encounterDiagnosis.setId(null);
                }
               
                encounterDiagnosis.setDiagnosis(diagnosis);
                encounterDiagnosis.setEncounterDiagnosis(enc);
                if(diagnosiscomments!=null){
                    encounterDiagnosis.setComments(String.valueOf(diagnosiscomments));
                }else{
                    encounterDiagnosis.setComments(null);
                }
                patientEncounterDiagnosisDao.saveDiagnosisEncounter(encounterDiagnosis);
           }
           
           if(vitalsign.getBloodPressure()==null && vitalsign.getHeight()==null && vitalsign.getPulse()==null && vitalsign.getRespiration()==null && vitalsign.getSource()==null && vitalsign.getTemperature()==null &&vitalsign.getWeight()==null){
           }else{
               vitalsign.setEncounterVitalsign(enc);
               vitalsign.setRecordedDate(d);
               patientEncounterVitalSignsDao.saveVitalSignEncounter(vitalsign);
           }
           if(visitHistory.getWhyVisiting()==null && visitHistory.getVisitNotes()==null && visitHistory.getHistory()==null && visitHistory.getFollowUp()==null && visitHistory.getFollowUpType()==null){            
           }else{
                visitHistory.setEncounterVisitHistory(enc);
                visitHistory.setRecordedDate(d);
                patientEncounterVisitHistoryDao.saveVisitHistoryEncounter(visitHistory);
           }
           return enc;
        }catch(  HibernateOptimisticLockingFailureException | IllegalArgumentException e){
            Logger.getLogger(PatientEncounterServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw e;
        }catch (DataAccessException ex) {
            Logger.getLogger(PatientEncounterServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new ProcessingException();
        }catch(Exception e){
            Logger.getLogger(PatientEncounterServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw new HealthCareException("Error in Saving...");
        }
    }

    /* (non-Javadoc)
     * @see com.bestray.healthcareemr.Service.PatientEncounterService#getEncounterDates(com.bestray.healthcareemr.Vo.TPatient)
     */
    @Override
    public List<TPatientEncounter> getEncounterDates(TPatient patientinfo) throws ProcessingException {
        try{
            return patientEncounterDao.getEncounterDates(patientinfo);
        }catch (DataAccessException ex) {
            Logger.getLogger(PatientEncounterServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new ProcessingException();
        }catch(Exception e){
            Logger.getLogger(PatientEncounterServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw new HealthCareException("Error in Saving...");
        }
    }

    /* (non-Javadoc)
     * @see com.bestray.healthcareemr.Service.PatientEncounterService#countNumberOfVisit(com.bestray.healthcareemr.Vo.TPatient)
     */
    @Override
    public String countNumberOfVisit(TPatient patientinfo) throws ProcessingException {
        try{
            int number = patientEncounterDao.countNumberOfVisit(patientinfo);
            return (number==0)?null:String.valueOf(number);
            
        }catch (DataAccessException ex) {
            Logger.getLogger(PatientEncounterServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new ProcessingException();
        }catch(Exception e){
            Logger.getLogger(PatientEncounterServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw new HealthCareException("Error in Saving...");
        }
    }

    

    /* (non-Javadoc)
     * @see com.bestray.healthcareemr.Service.PatientEncounterService#getEncounter(java.lang.Long)
     */
    @Override
    public TPatientEncounter getEncounterById(Long encid) throws ProcessingException {
        try{
            return patientEncounterDao.getEncounterById(encid);
        }catch (DataAccessException ex) {
            Logger.getLogger(PatientEncounterServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new ProcessingException();
        }catch(Exception e){
            Logger.getLogger(PatientEncounterServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw new HealthCareException("Error in retriving...");
        }
    }

    

    @Override
    public TPatientEncounter getEncounterByAppoitment(TAppointment appointmentinfo) throws ProcessingException {
        try{
            return patientEncounterDao.getEncounterByAppoitment(appointmentinfo);
        }catch (DataAccessException ex) {
            Logger.getLogger(PatientEncounterServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new ProcessingException();
        }catch(Exception e){
            Logger.getLogger(PatientEncounterServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw new HealthCareException("Error in retriving...");
        }
    }

    
    @Override
    public List<TPatEncOrderResults> getLabResultsByProcedureId(TEncounterProcedure encprocedure) throws ProcessingException {
        try{
            return patientEncounterDao.getLabResultsByProcedureId(encprocedure);
        }catch (DataAccessException ex) {
            Logger.getLogger(PatientEncounterServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new ProcessingException();
        }catch(Exception e){
            Logger.getLogger(PatientEncounterServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw new HealthCareException("Error in retriving...");
        }
    }

    @Override
    public List<TAppointment> getOPAppointmentListByDate(Date appointmentDate) throws ProcessingException {
        List<TAppointment> opAppointments = new ArrayList<TAppointment>();
        try {
             List<TAppointment> appointments = appointmentDao.findAppointmentListByDate(appointmentDate);
             for(TAppointment appt:appointments){
                 if(appt.getScheduleType().equalsIgnoreCase("Out Patient")){
                     opAppointments.add(appt);
                 }
             }
             return opAppointments;
        }catch(DataAccessException e){
                Logger.getLogger(PatientEncounterServiceImpl.class.getName()).log(Level.SEVERE, null, e);
                throw new ProcessingException();
        } catch (Exception ex) {
                Logger.getLogger(PatientEncounterServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
                throw new HealthCareException("Error in populating appointments list");
        }
    }

    @Override
    public List<TAppointment> getOPAppointmentListByDoctor(Date date, TDepartmentMaster departmentValues, TDoctorInformation DoctorDetails) throws ProcessingException{
        List<TAppointment> opAppointments = new ArrayList<TAppointment>();
        try {
             List<TAppointment> appointments = appointmentDao.findAppointmentListByDoctor(date,departmentValues,DoctorDetails);
             for(TAppointment appt:appointments){
                 if(appt.getScheduleType().equalsIgnoreCase("Out Patient")){
                     opAppointments.add(appt);
                 }
             }
             return opAppointments;
        }catch(DataAccessException e){
                Logger.getLogger(PatientEncounterServiceImpl.class.getName()).log(Level.SEVERE, null, e);
                throw new ProcessingException();
        } catch (Exception ex) {
                Logger.getLogger(PatientEncounterServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
                throw new HealthCareException("Error in populating appointments list");
        }
    }

    @Override
    public List<TAppointment> getOPAppointmentListByDepartment(Date date, TDepartmentMaster departmentValues) throws ProcessingException{
        List<TAppointment> opAppointments = new ArrayList<TAppointment>();
        try {
             List<TAppointment> appointments = appointmentDao.findAppointmentListByDepartment(date,departmentValues);
             for(TAppointment appt:appointments){
                 if(appt.getScheduleType().equalsIgnoreCase("Out Patient")){
                     opAppointments.add(appt);
                 }
             }
             return opAppointments;
        }catch(DataAccessException e){
                Logger.getLogger(PatientEncounterServiceImpl.class.getName()).log(Level.SEVERE, null, e);
                throw new ProcessingException();
        } catch (Exception ex) {
                Logger.getLogger(PatientEncounterServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
                throw new HealthCareException("Error in populating appointments list");
        }
    }
    
    
    @Override
    public List<Object>/*TPatientEncounter*/ saveEncounter(TPatientEncounter patientenc,TEncounterHistoryVisit vh,
        List<TEncounterAllergy> encallergy,TEncounterVitalSign vitalsigns,List<Long> removeallergylist,
        List<TEncounterProcedure> encprocedure,List<Long> removeproclist,List<TEncounterMedication> encmedication,
        List<TEncounterDiagnosis> encdiagnosis,List<Long> removediagnosislist)throws ProcessingException {
        
        List<Object> objlist = new ArrayList<Object>();
        List<TEncounterProcedure> encproclist = new ArrayList<TEncounterProcedure>();
        try{
            enc = patientEncounterDao.savePatientEncounterInfo(patientenc);
            
            vh.setEncounterVisitHistory(enc);
            vitalsigns.setEncounterVitalsign(enc);
            patientEncounterVitalSignsDao.saveVitalSignEncounter(vitalsigns);
            patientEncounterVisitHistoryDao.saveVisitHistoryEncounter(vh);
            if(removeallergylist.size()>0){
             for(Long ids:removeallergylist){
                patientEncounterAllergyDao.deleteEncounterAllergies(ids);
             }
            }
            for(TEncounterAllergy al:encallergy){
                al.setEncounter(enc);
                patientEncounterAllergyDao.saveAllergyEncounter(al);
            }
            if(removeproclist.size()>0){
             for(Long ids:removeproclist){
                TEncounterProcedure removeProcedure = patientEncounterProcedureDao.getProcedureEncounterByID(ids);
                orderResultService.deleteOrderResultsEncounter(removeProcedure, enc);
                orderSpecimenCollectionService.deleteSpecimenDetailsEncounter(removeProcedure, enc);
                patientEncounterProcedureDao.deleteEncounterProcedure(ids);
             }
            }
            for(TEncounterProcedure proc:encprocedure){
                proc.setEncounterProcedure(enc);
                patientEncounterProcedureDao.saveProcedureEncounter(proc);
            }
            for(TEncounterMedication medic:encmedication){
                medic.setEncounterMed(enc);
                patientEncounterMedicationDao.saveMedicationEncounter(medic);
            }
            if(removediagnosislist.size()>0){
             for(Long ids:removediagnosislist){
                patientEncounterDiagnosisDao.deleteEncounterDiagnosis(ids);
             }
            }
            for(TEncounterDiagnosis diag:encdiagnosis){
                diag.setEncounterDiagnosis(enc);
                patientEncounterDiagnosisDao.saveDiagnosisEncounter(diag);
            }
            objlist.add(enc);
            objlist.add(encproclist);
            return objlist;
           // return enc;
        }catch(Exception e){
            Logger.getLogger(PatientEncounterServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw new HealthCareException("Error in saving...");
        }
    }

    @Override
    public TEncounterHistoryVisit saveVisitHistoryEnc(TEncounterHistoryVisit vh, TPatientEncounter patencbyappoitornew)throws ProcessingException {
        try{
            
                vh.setEncounterVisitHistory(patencbyappoitornew);
                vh.setRecordedDate(new Date());
             
             return patientEncounterVisitHistoryDao.saveVisitHistoryEncounter(vh);
        }catch(Exception e){
            Logger.getLogger(PatientEncounterServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw new HealthCareException("Error in saving...");
        }
    }

    @Override 
    public TEncounterAllergy getEncAllergyById(Long id)throws ProcessingException {
        try{
            return patientEncounterAllergyDao.getEncAllergyById(id);
        }catch(Exception e){
            Logger.getLogger(PatientEncounterServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw new HealthCareException("Error in saving...");
        }
    }

    @Override
    public void saveProcedureMaster(TProcedureMaster procedure)throws ProcessingException {
        try{
             procedureMasterDao.saveProcedureMaster(procedure);
        }catch(Exception e){
            Logger.getLogger(PatientEncounterServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw new HealthCareException("Error in saving...");
        }
    }

    @Override
    public TEncounterMedication getEncMedById(long id)throws ProcessingException {
        try{
             return patientEncounterMedicationDao.getEncMedById(id);
        }catch(Exception e){
            Logger.getLogger(PatientEncounterServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw new HealthCareException("Error in saving...");
        }
    }
    
    @Override
    public void savexrayimages(Set<XrayImage> xrayImages)throws ProcessingException {
        try{
             xrayImageDao.savexrayimages(xrayImages);
        }catch(Exception e){
            Logger.getLogger(PatientEncounterServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw new HealthCareException("Error in saving...");
        }
    }

@Override
    public List<XrayImage> getXrayImages(TPatientEncounter patientenc) throws ProcessingException {
    try{
           return xrayImageDao.getXrayImages(patientenc);
        }catch(Exception e){
            Logger.getLogger(PatientEncounterServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw new HealthCareException("Error in retriving...");
        }
    }

    @Override
    public List<TPatientEncounter> getAllOpenEncounter() throws ProcessingException {
        try{
            return patientEncounterDao.getAllOpenEncounter();
        }catch (DataAccessException ex) {
            Logger.getLogger(PatientEncounterServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new ProcessingException();
        }catch(Exception e){
            Logger.getLogger(PatientEncounterServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw new HealthCareException("Error in Saving...");
        }
    }

    @Override
    public TPatientEncounter createNewEncounter(TPatientEncounter encounter) throws ProcessingException {
        try{
            TRecentPatient recPatient = PatientClone.getPatient(encounter.getPatient());
            recentPatientService.saveRecentPatient(recPatient);
            return patientEncounterDao.savePatientEncounterInfo(encounter);
        }catch (DataAccessException ex) {
            Logger.getLogger(PatientEncounterServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new ProcessingException();
        }catch(Exception e){
            Logger.getLogger(PatientEncounterServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw new HealthCareException("Error in Saving...");
        }
    }
    
    @Override
    public void closeEncounter(TPatientEncounter encounter) throws DataAccessException,HibernateOptimisticLockingFailureException {
        try{
            patientEncounterDao.closeEncounter(encounter);
        }catch (DataAccessException ex) {
            Logger.getLogger(PatientEncounterServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new DataAccessException();
        }catch(Exception e){
            Logger.getLogger(PatientEncounterServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw new HealthCareException("Error in Saving...");
        }
    }

   
}