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

import com.bestray.healthcarecommonutil.exception.ProcessingException;
import com.bestray.healthcarecommonutil.service.AllergiesMasterService;
import com.bestray.healthcarecommonutil.service.DiagnosisMasterService;
import com.bestray.healthcarecommonutil.service.MedicationMasterService;
import com.bestray.healthcarecommonutil.service.ProcedureMasterService;
import com.bestray.healthcarecommonutil.vo.TAllergiesMaster;
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.healthcarecommonutil.vo.TProcedureMaster;
import com.bestray.healthcareinpatient.service.InpatientRoundingService;
import java.util.List;
import java.util.Vector;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.hibernate3.HibernateOptimisticLockingFailureException;
import org.springframework.stereotype.Controller;

/**
 *
 * @author user3
 */
@Controller
public class InPatientRoundingController {
    
    @Autowired
    private AllergiesMasterService allergiesMasterService;
    @Autowired
    private MedicationMasterService medicationMasterService;
    @Autowired
    private ProcedureMasterService procedureMasterService;
    @Autowired
    private DiagnosisMasterService diagnosisMasterService;
    @Autowired
    private InpatientRoundingService inpatientRoundingService;
    
    
    public Vector<TAllergiesMaster> getAllAllergies() throws ProcessingException {
        try{
            Vector allergies = new Vector();
            TAllergiesMaster alrgy ;
            List<TAllergiesMaster> allergyList = allergiesMasterService.getAllergyList();
            for(TAllergiesMaster allergy:allergyList){
                alrgy = new TAllergiesMaster();
                alrgy.setId(allergy.getId());
                alrgy.setAllergiesName(allergy.getAllergiesName());
                allergies.addElement(alrgy);
            }
            return allergies;
        }catch(ProcessingException e){
            throw e;
        }
    }
    
    public Vector<TMedicationMaster> getAllMedication()throws ProcessingException {
        try{
            Vector<TMedicationMaster> medications = new Vector<TMedicationMaster>();
            List<TMedicationMaster> medicationList = medicationMasterService.getMedicationList();
            for(TMedicationMaster medication:medicationList){
                medications.addElement(medication);
            }
            return medications;
        }catch(ProcessingException e){
            throw e;
        }
    }
    
    public Vector<TProcedureMaster> getAllProcedure()throws ProcessingException {
        try{
            Vector procedures = new Vector();
            List<TProcedureMaster> procedureList = procedureMasterService.getAllProcedureList();
            for(TProcedureMaster procedure:procedureList){
                TProcedureMaster tempprocedure = new TProcedureMaster();
                tempprocedure.setId(procedure.getId());
                tempprocedure.setProcedureName(procedure.getProcedureName());
                procedures.addElement(tempprocedure);
            }
            return procedures;
        }catch(ProcessingException e){
            throw e;
        }
    }
    
    public Vector<TDiagnosisMaster> getAllDiagnosis()throws ProcessingException {
        try{
            Vector<TDiagnosisMaster> diagnosis = new Vector<TDiagnosisMaster>();
            List<TDiagnosisMaster> diagnosisList = diagnosisMasterService.getDiagnosisList();
            for(TDiagnosisMaster diagnos:diagnosisList){
                diagnosis.addElement(diagnos);
            }
            return diagnosis;
        }catch(ProcessingException e){
            throw e;
        }
    }

    public TPatientEncounter getIPEncounterByPatient(TPatient pat)throws ProcessingException {
        try{
           return inpatientRoundingService.getIPEncounterByPatient(pat);
        }catch(ProcessingException e){
            throw e;
        }
    }

    /*public TPatientEncounter createIPEncounter(TPatientEncounter enc)throws ProcessingException,HibernateOptimisticLockingFailureException{
        try{
            return inpatientRoundingService.createIPEncounter(enc);
        }catch(  HibernateOptimisticLockingFailureException | ProcessingException e){
            throw e;
        }
    }*/
    
    public TMedicationMaster getMedication(String name)throws ProcessingException{
        try{
            return medicationMasterService.getMedication(name);
        }catch(ProcessingException e){
            throw e;
        }
    }

    public TEncounterMedication saveMedication(TEncounterMedication encounterMedication)throws ProcessingException,HibernateOptimisticLockingFailureException {
        try{
             return inpatientRoundingService.saveMedication(encounterMedication);
        }catch(  HibernateOptimisticLockingFailureException | ProcessingException ex){
            throw ex;
        }
    }

    public void saveMedicationMaster(TMedicationMaster medication) throws ProcessingException,HibernateOptimisticLockingFailureException{
        try{
            medicationMasterService.saveMedicationMaster(medication);
        }catch(  HibernateOptimisticLockingFailureException | ProcessingException ex){
            throw ex;
        }
    }

    public List<TEncounterMedication> getEncounterMedication(TPatientEncounter encounter,int status) throws ProcessingException {
        try{
            return inpatientRoundingService.getEncounterMedication(encounter,status);
        }catch(ProcessingException e){
            throw e;
        }
    }
    
    public List<TEncounterMedication> getEncounterMedicationByEncIdnType(TPatientEncounter encounter,String type) throws ProcessingException{
        try{
            return inpatientRoundingService.getEncounterMedicationByEncIdnType(encounter,type);
        }catch(ProcessingException e){
            throw e;
        }
    }
    
    public List<TEncounterVitalSign> getEncounterVitalsignByEncIdnType(TPatientEncounter encounter,String type) throws ProcessingException{
      try{
            return inpatientRoundingService.getEncounterVitalsignByEncIdnType(encounter,type);
        }catch(ProcessingException e){
            throw e;
        } 
    }
  public List<TEncounterProcedure>  getEncounterProcedureByEncIdnType(TPatientEncounter encounter,String type) throws ProcessingException{
      try{
            return inpatientRoundingService.getEncounterProcedureByEncIdnType(encounter,type);
        }catch(ProcessingException e){
            throw e;
        }
  }

    public TEncounterMedication getEncounterMedicationById(Long encmedid) throws ProcessingException{
        try{
            return inpatientRoundingService.getEncounterMedicationById(encmedid);
        }catch(ProcessingException e){
            e.printStackTrace();
            throw e;
        }
    }

    public TEncounterMedication reorderMedication(TEncounterMedication encmed) throws ProcessingException {
        try{
            return inpatientRoundingService.reorderMedication(encmed);
        }catch(ProcessingException e){
            throw e;
        }
    }

    public TPatientEncounter getEncounterById(Long encid)throws ProcessingException  {
        try{
            return inpatientRoundingService.getEncounterById(encid);
        }catch(ProcessingException e){
            throw e;
        }
    }

    public TProcedureMaster getProcedure(String procname)throws ProcessingException {
        try{
            return procedureMasterService.getProcedureByName(procname);
        }catch(ProcessingException e){
            throw e;
        }
    }
    
    public TProcedureMaster getProcedureById(Long id)throws ProcessingException {
        try{
            return procedureMasterService.getProcedureValues(id);
        }catch(ProcessingException e){
            throw e;
        }
    }

    public void saveProcedureMaster(TProcedureMaster procedure)throws ProcessingException{
        /*try{
            procedureMasterService.saveProcedureMaster(procedure);
        }catch(ProcessingException e){
            throw e;
        }*/
    }

    public TEncounterProcedure saveProcedure(TEncounterProcedure encounterProcedure)throws ProcessingException,HibernateOptimisticLockingFailureException {
        try{
             return inpatientRoundingService.saveProcedure(encounterProcedure);
        }catch(  HibernateOptimisticLockingFailureException | ProcessingException ex){
            throw ex;
        }
    }

    public List<TEncounterProcedure> getEncounterProcedure(TPatientEncounter encounter)throws ProcessingException {
        try{
            return inpatientRoundingService.getEncounterProcedure(encounter);
        }catch(ProcessingException e){
            throw e;
        }
    }

    public TEncounterProcedure getEncProcedure(Long encprocid)throws ProcessingException {
        try{
            return inpatientRoundingService.getEncProcedure(encprocid);
        }catch(ProcessingException e){
            throw e;
        }
    }

    public void deleteEncProc(TEncounterProcedure encproc)throws ProcessingException {
        try{
            inpatientRoundingService.deleteEncProc(encproc);
        }catch(ProcessingException e){
            throw e;
        }
    }

    public TPatientEncounter saveIPEncounter(boolean b,TPatientEncounter inpatenc)throws ProcessingException {
        try{
            return inpatientRoundingService.saveIPEncounter(b,inpatenc);
        }catch(ProcessingException e){
            throw e;
        }
    }

    public TPatEncToDo saveToDo(TPatEncToDo encounterToDo) throws ProcessingException{
        try{
             return inpatientRoundingService.saveToDo(encounterToDo);
        }catch(HibernateOptimisticLockingFailureException | ProcessingException ex){
            throw ex;
        }
    }
    //Prasanta. To save vital sign
     public void saveVitalSign(TEncounterVitalSign encounterVitalSign) throws ProcessingException{
        try{
              inpatientRoundingService.saveVitalSign(encounterVitalSign);
        }catch(HibernateOptimisticLockingFailureException | ProcessingException ex){
            throw ex;
        }
    }
     public void saveAnesthesiaDetails(TAnesthesiaDetails anesthesiaDetails) throws ProcessingException{
        try{
              inpatientRoundingService.saveAnesthesiaDetails(anesthesiaDetails);
        }catch(HibernateOptimisticLockingFailureException | ProcessingException ex){
            throw ex;
        }
    }
     
     public List<TEncounterVitalSign> getAllVitalSignsForPatient(TPatientEncounter encounter) throws ProcessingException{
         
        try{
            return inpatientRoundingService.getAllVitalSignsForPatient(encounter);
        }catch(ProcessingException e){
            throw e;
        }
    }
     
     
    public TEncounterVitalSign  getVitalsignDetailById(long id)throws ProcessingException {
        try{
            return inpatientRoundingService.getVitalsignDetailById(id);
        }
        catch(ProcessingException e){
            e.printStackTrace();
            throw e;
        }
    }
     public List<TAnesthesiaDetails> getAllAnesthesiaDetailsForPatient(TPatientEncounter encounter) throws ProcessingException{
         
        try{
            return inpatientRoundingService.getAllAnesthesiaDetailsForPatient(encounter);
        }catch(ProcessingException e){
            throw e;
        }
    }
     public TAnesthesiaDetails  getAnesthesiaDetailById(long id)throws ProcessingException {
        try{
            return inpatientRoundingService.getAnesthesiaDetailById(id);
        }
        catch(ProcessingException e){
            e.printStackTrace();
            throw e;
        }
    }

    public List<TPatEncToDo> getTasksForEncounter(TPatientEncounter encounter)throws ProcessingException {
        try{
            return inpatientRoundingService.getTasksForEncounter(encounter);
        }catch(ProcessingException e){
            throw e;
        }
    }

    public TPatEncToDo getEncTask(Long enctaskid) throws ProcessingException{
        try{
            return inpatientRoundingService.getEncTask(enctaskid);
        }catch(ProcessingException e){
            throw e;
        }
    }

    public void deleteEncTask(TPatEncToDo enctodo)throws ProcessingException {
        try{
            inpatientRoundingService.deleteEncTask(enctodo);
        }catch(ProcessingException e){
            throw e;
        }
    }
    public void deleteAnesthesiaDetails(TAnesthesiaDetails anesthesiaDetails) throws ProcessingException{
     try{
            inpatientRoundingService.deleteAnesthesiaDetails(anesthesiaDetails);
        }catch(ProcessingException e){
            throw e;
        }   
    }
    
     public void deleteEncounterMedication(TEncounterMedication encmed) throws ProcessingException{
     try{
            inpatientRoundingService.deleteEncounterMedication(encmed);
        }catch(ProcessingException e){
            throw e;
        }   
    }
     public void deleteEncounterProcedure(TEncounterProcedure encProc)throws ProcessingException{
         try{
            inpatientRoundingService.deleteEncounterProcedure(encProc);
        }catch(ProcessingException e){
            throw e;
        }  
     }
     
    public void  deleteEncounterVitalSign(TEncounterVitalSign encVitalSign)throws ProcessingException{
        try{
            inpatientRoundingService.deleteEncounterVitalSign(encVitalSign);
        }catch(ProcessingException e){
            throw e;
        }  
    }
    public Vector<TDiagnosisMaster> getDiagnosis(String expr)throws ProcessingException {
        try{
            Vector<TDiagnosisMaster> diagnosis = new Vector<TDiagnosisMaster>();
            List<TDiagnosisMaster> diagnosisList = inpatientRoundingService.getDiagnosis(expr);
            for(TDiagnosisMaster diagnos:diagnosisList){
                diagnosis.addElement(diagnos);
            }
            return diagnosis;
        }catch(ProcessingException e){
            throw e;
        }
    }
    
    public TDiagnosisMaster getDiagnosisValues(Integer diagnosisId)throws ProcessingException {
        try{
            return diagnosisMasterService.getDiagnosisValues(diagnosisId);
        }catch(ProcessingException e){
            throw e;
        }
    }

    public TEncounterDiagnosis saveDiagnosis(TEncounterDiagnosis encounterDiagnosis)throws ProcessingException {
        try{
             return inpatientRoundingService.saveDiagnosis(encounterDiagnosis);
        }catch(  HibernateOptimisticLockingFailureException | ProcessingException ex){
            throw ex;
        }
    }

    public List<TEncounterDiagnosis> getEncounterDiagnosis(TPatientEncounter encounter)throws ProcessingException {
        try{
            return inpatientRoundingService.getEncounterDiagnosis(encounter);
        }catch(ProcessingException e){
            throw e;
        }
    }

    public void deleteEncDiag(TEncounterDiagnosis ediag)throws ProcessingException {
        try{
            inpatientRoundingService.deleteEncDiag(ediag);
        }catch(ProcessingException e){
            throw e;
        }
    }

   public Vector<TProcedureMaster> getProcedureByName(String expr)throws ProcessingException {
        try{
            Vector<TProcedureMaster> procedures = new Vector<TProcedureMaster>();
            List<TProcedureMaster> procedureList = procedureMasterService.getProcedureListBySearch(expr);
            for(TProcedureMaster proc:procedureList){
                procedures.addElement(proc);
            }
            return procedures;
        }catch(ProcessingException e){
            throw e;
        }
    }
}