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

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.MedicationMasterService;
import com.bestray.healthcarecommonutil.vo.TAnesthesiaDetails;
import com.bestray.healthcarecommonutil.vo.TDiagnosisMaster;
import com.bestray.healthcarecommonutil.vo.TEncounterDiagnosis;
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.TPatEncToDo;
import com.bestray.healthcarecommonutil.vo.TPatient;
import com.bestray.healthcarecommonutil.vo.TPatientEncounter;
import com.bestray.healthcareinpatient.dao.InpatientRoundingDao;
import com.bestray.healthcareinpatient.service.InpatientRoundingService;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.hibernate3.HibernateOptimisticLockingFailureException;
import org.springframework.stereotype.Service;

/**
 *
 * @author user3
 */
@Service
public class InpatientRoundingServiceImpl implements InpatientRoundingService{
    
    @Autowired
    private InpatientRoundingDao inpatientRoundingDao;
    @Autowired
    private MedicationMasterService medicationMasterService;
    @Autowired
    private MedicationMasterDao medicationMasterDao;
    
    private TMedicationMaster medication;
    private SimpleDateFormat sdf;

    public InpatientRoundingServiceImpl() {
        
        sdf = new SimpleDateFormat("dd-MM-YYYY");
    }

    @Override
    public TPatientEncounter getIPEncounterByPatient(TPatient pat) throws ProcessingException {
        try{
            return inpatientRoundingDao.getIPEncounterByPatient(pat);
        }catch (DataAccessException ex) {
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new ProcessingException();
        }catch(Exception e){
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw new HealthCareException("Error in retriving...");
        }
    }

    /*@Override
    public TPatientEncounter createIPEncounter(TPatientEncounter enc) throws ProcessingException,HibernateOptimisticLockingFailureException {
        try{
            if(enc.getEncId()!=null){
                enc.setEncUpdateDate(new Date());
            }else{
                enc.setEncDate(new Date());
                enc.setEncStatus("Opened");
                enc.setEncType("IP");
            }
            return inpatientRoundingDao.createIPEncounter(enc);
        }catch(HibernateOptimisticLockingFailureException e){
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw e;
        }catch (DataAccessException ex) {
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new ProcessingException();
        }catch(Exception e){
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw new HealthCareException("Error in retriving...");
        }
    }*/

    @Override
    public TEncounterMedication saveMedication(TEncounterMedication encounterMedication) throws ProcessingException,HibernateOptimisticLockingFailureException {
        try {
            return inpatientRoundingDao.saveMedication(encounterMedication);
        }catch(HibernateOptimisticLockingFailureException e){
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw e;
        }catch(DataAccessException ex) {
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new ProcessingException();
        }
    }

    @Override
    public List<TEncounterMedication> getEncounterMedication(TPatientEncounter encounter,int status) throws ProcessingException {
        try{
            return inpatientRoundingDao.getEncounterMedication(encounter,status);
        }catch (DataAccessException ex) {
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new ProcessingException();
        }catch(Exception e){
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw new HealthCareException("Error in retriving...");
        }
    }
    
    @Override
    public List<TEncounterMedication> getEncounterMedicationByEncIdnType(TPatientEncounter encounter,String type)throws ProcessingException {
        try{
            return inpatientRoundingDao.getEncounterMedicationByEncIdnType(encounter,type);
        }catch (DataAccessException ex) {
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new ProcessingException();
        }catch(Exception e){
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw new HealthCareException("Error in retriving...");
        }
    }
    
    
    @Override
     public List<TEncounterProcedure>  getEncounterProcedureByEncIdnType(TPatientEncounter encounter,String type) throws ProcessingException {
        try{
            return inpatientRoundingDao.getEncounterProcedureByEncIdnType(encounter,type);
        }catch (DataAccessException ex) {
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new ProcessingException();
        }catch(Exception e){
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw new HealthCareException("Error in retriving...");
        }
    }
    
    @Override
   public List<TEncounterVitalSign> getEncounterVitalsignByEncIdnType(TPatientEncounter encounter,String type) throws ProcessingException{
      try{
            return inpatientRoundingDao.getEncounterVitalsignByEncIdnType(encounter,type);
        }catch (DataAccessException ex) {
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new ProcessingException();
        }catch(Exception e){
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw new HealthCareException("Error in retriving...");
        } 
   }

    @Override
    public TEncounterMedication getEncounterMedicationById(Long encmedid) throws ProcessingException {
        try{
            return inpatientRoundingDao.getEncounterMedicationById(encmedid);
        }catch (DataAccessException ex) {
            ex.printStackTrace();
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new ProcessingException();
        }catch(Exception e){
            e.printStackTrace();
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw new HealthCareException("Error in retriving...");
        }
    }
    
    

    @Override
    public TEncounterMedication reorderMedication(TEncounterMedication encmed) throws ProcessingException {
        try{
            TEncounterMedication medclone = encmed;
            saveMedication(encmed);
            TEncounterMedication med = new TEncounterMedication();
            med.setStatus(1);
            med.setMedication(medclone.getMedication());
            med.setFrequency(medclone.getFrequency());
            med.setDose(medclone.getDose());
            med.setRoute(medclone.getRoute());
            med.setEncounterMed(medclone.getEncounterMed());
            med.setComments(medclone.getComments());
            return saveMedication(med);
        }catch (ProcessingException ex) {
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new ProcessingException();
        }catch(Exception e){
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw new HealthCareException("Error in retriving...");
        }
    }

    @Override
    public TPatientEncounter getEncounterById(Long encid) throws ProcessingException {
        try{
            return inpatientRoundingDao.getEncounterById(encid);
        }catch (DataAccessException ex) {
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new ProcessingException();
        }catch(Exception e){
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw new HealthCareException("Error in retriving...");
        }
    }

    @Override
    public TEncounterProcedure saveProcedure(TEncounterProcedure encounterProcedure) throws ProcessingException,HibernateOptimisticLockingFailureException {
        try {
            return inpatientRoundingDao.saveProcedure(encounterProcedure);
        }catch(HibernateOptimisticLockingFailureException e){
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw e;
        }catch(DataAccessException ex) {
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new ProcessingException();
        }
    }

    @Override
    public List<TEncounterProcedure> getEncounterProcedure(TPatientEncounter encounter) throws ProcessingException {
        try{
            return inpatientRoundingDao.getEncounterProcedure(encounter);
        }catch (DataAccessException ex) {
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new ProcessingException();
        }catch(Exception e){
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw new HealthCareException("Error in retriving...");
        }
    }

    @Override
    public TEncounterProcedure getEncProcedure(Long encprocid) throws ProcessingException {
        try{
            return inpatientRoundingDao.getEncProcedure(encprocid);
        }catch (DataAccessException ex) {
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new ProcessingException();
        }catch(Exception e){
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw new HealthCareException("Error in retriving...");
        }
    }

    @Override
    public void deleteEncProc(TEncounterProcedure encproc) throws ProcessingException {
        try{
            inpatientRoundingDao.deleteEncProc(encproc);
        }catch (DataAccessException ex) {
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new ProcessingException();
        }catch(Exception e){
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw new HealthCareException("Error in deleting...");
        }
    }

    @Override
    public TPatientEncounter saveIPEncounter(boolean b,TPatientEncounter inpatenc) throws ProcessingException {
        try{
            if(b==true){
                inpatenc.setEncUpdateDate(new Date());
            }else if(b==false){
                inpatenc.setEncDate(new Date());
                inpatenc.setEncStatus("Opened");
                inpatenc.setEncType("IP");
            }
            return inpatientRoundingDao.saveIPEncounter(inpatenc);
        }catch(HibernateOptimisticLockingFailureException e){
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw e;
        }catch (DataAccessException ex) {
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new ProcessingException();
        }catch(Exception e){
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw new HealthCareException("Error in retriving...");
        }
    }

    @Override
    public TPatEncToDo saveToDo(TPatEncToDo encounterToDo) throws ProcessingException,HibernateOptimisticLockingFailureException {
        try {
            return inpatientRoundingDao.saveToDo(encounterToDo);
        }catch(HibernateOptimisticLockingFailureException e){
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw e;
        }catch(DataAccessException ex) {
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new ProcessingException();
        }
    }
    
      @Override
    public void saveVitalSign(TEncounterVitalSign encounterVitalSign) throws ProcessingException,HibernateOptimisticLockingFailureException {
        try {
            inpatientRoundingDao.saveVitalSign(encounterVitalSign);
        }catch(HibernateOptimisticLockingFailureException e){
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw e;
        }catch(ProcessingException ex) {
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new ProcessingException();
        }
    }
      @Override
    public void saveAnesthesiaDetails(TAnesthesiaDetails anesthesiaDetails)throws ProcessingException{
        try {
            inpatientRoundingDao.saveAnesthesiaDetails(anesthesiaDetails);
        
        }catch(Exception ex) {
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            ex.printStackTrace();
        }
    }
     
public TEncounterVitalSign  getVitalsignDetailById(long id)throws ProcessingException {
        try{
            return inpatientRoundingDao.getVitalsignDetailById(id);
        }
        catch(ProcessingException e){
            throw e;
        }
    }
public List<TEncounterVitalSign> getAllVitalSignsForPatient(TPatientEncounter encounter) throws ProcessingException{
    try{
            return inpatientRoundingDao.getAllVitalSignsForPatient(encounter);
        }
        catch(Exception e){
             Logger.getLogger(InPatientPaidServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw new HealthCareException("Error in populating inpatient Vitalsign list");
        }
}
 @Override
 public TAnesthesiaDetails getAnesthesiaDetailById(long id)throws ProcessingException {
        try {
            return inpatientRoundingDao.getAnesthesiaDetailById(id);
        } catch (DataAccessException ex) {
            ex.printStackTrace();
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new HealthCareException("Error in populating inpatient Anesthesia list");
        }
}
public List<TAnesthesiaDetails> getAllAnesthesiaDetailsForPatient(TPatientEncounter encounter) throws ProcessingException{
   try{
            return inpatientRoundingDao.getAllAnesthesiaDetailsForPatient(encounter);
        }
        catch(Exception e){
             Logger.getLogger(InPatientPaidServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw new HealthCareException("Error in populating inpatient Vitalsign list");
        } 
}
    @Override
    public List<TPatEncToDo> getTasksForEncounter(TPatientEncounter encounter) throws ProcessingException {
        try{
            return inpatientRoundingDao.getTasksForEncounter(encounter);
        }catch (DataAccessException ex) {
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new ProcessingException();
        }catch(Exception e){
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw new HealthCareException("Error in retriving...");
        }
    }

    @Override
    public TPatEncToDo getEncTask(Long enctaskid) throws ProcessingException {
        try{
            return inpatientRoundingDao.getEncTask(enctaskid);
        }catch (DataAccessException ex) {
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new ProcessingException();
        }catch(Exception e){
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw new HealthCareException("Error in retriving...");
        }
    }

    @Override
    public void deleteEncTask(TPatEncToDo enctodo) throws ProcessingException {
        try{
            inpatientRoundingDao.deleteEncTask(enctodo);
        }catch (DataAccessException ex) {
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new ProcessingException();
        }catch(Exception e){
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw new HealthCareException("Error in deleting...");
        }
    }
     @Override
    public void deleteEncounterMedication(TEncounterMedication encmed) throws ProcessingException{
         try{
            inpatientRoundingDao.deleteEncounterMedication(encmed);
        }catch (DataAccessException ex) {
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new ProcessingException();
        }catch(Exception e){
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw new HealthCareException("Error in deleting...");
        }
        
    }
     
      @Override
     public void  deleteEncounterVitalSign(TEncounterVitalSign encVitalSign)throws ProcessingException{
         try{
            inpatientRoundingDao.deleteEncounterVitalSign(encVitalSign);
        }catch (DataAccessException ex) {
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new ProcessingException();
        }catch(Exception e){
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw new HealthCareException("Error in deleting...");
        }
     }
     @Override
     public void deleteEncounterProcedure(TEncounterProcedure encProc)throws ProcessingException{
        try{
            inpatientRoundingDao.deleteEncounterProcedure(encProc);
        }catch (DataAccessException ex) {
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new ProcessingException();
        }catch(Exception e){
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw new HealthCareException("Error in deleting...");
        }
         
     }
    @Override
public void deleteAnesthesiaDetails(TAnesthesiaDetails anesthesiaDetails) throws ProcessingException{
        try{
            inpatientRoundingDao.deleteAnesthesiaDetails(anesthesiaDetails);
        }catch (DataAccessException ex) {
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new ProcessingException();
        }catch(Exception e){
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw new HealthCareException("Error in deleting...");
        }
    
}
    @Override
    public List<TDiagnosisMaster> getDiagnosis(String expr) throws ProcessingException {
        try{
            return inpatientRoundingDao.getDiagnosis(expr);
        }catch (DataAccessException ex) {
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new ProcessingException();
        }catch(Exception e){
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw new HealthCareException("Error in retriving...");
        }
    }

    @Override
    public TEncounterDiagnosis saveDiagnosis(TEncounterDiagnosis encounterDiagnosis) throws ProcessingException {
        try {
            return inpatientRoundingDao.saveDiagnosis(encounterDiagnosis);
        }catch(HibernateOptimisticLockingFailureException e){
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw e;
        }catch(DataAccessException ex) {
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new ProcessingException();
        }
    }

    @Override
    public List<TEncounterDiagnosis> getEncounterDiagnosis(TPatientEncounter encounter) throws ProcessingException {
        try{
            return inpatientRoundingDao.getEncounterDiagnosis(encounter);
        }catch (DataAccessException ex) {
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new ProcessingException();
        }catch(Exception e){
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw new HealthCareException("Error in retriving...");
        }
    }

    @Override
    public void deleteEncDiag(TEncounterDiagnosis ediag) throws ProcessingException {
        try{
            inpatientRoundingDao.deleteEncDiag(ediag);
        }catch (DataAccessException ex) {
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new ProcessingException();
        }catch(Exception e){
            Logger.getLogger(InpatientRoundingServiceImpl.class.getName()).log(Level.SEVERE, null, e);
            throw new HealthCareException("Error in deleting...");
        }
    }
    
}