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

import com.bestray.healthcarecommonutil.exception.ProcessingException;
import com.bestray.healthcarecommonutil.service.OrderSpecimenCollectionService;
import com.bestray.healthcarecommonutil.vo.TEncounterProcedure;
import com.bestray.healthcarecommonutil.vo.TPatEncOrderSpecimen;
import com.bestray.healthcarecommonutil.vo.TPatient;
import com.bestray.healthcarecommonutil.vo.TPatientEncounter;
import com.bestray.healthcarecommonutil.vo.TProcedureMaster;
import com.bestray.labinformationsystem.service.LabInformationService;
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 User1
 */
@Controller
public class LabInformationController {
    
    @Autowired
    private LabInformationService labInformationService;
    
    @Autowired
    private OrderSpecimenCollectionService orderSpecimenCollectionService;

    /*public LabInformationController(LabInformationService labInformationService, OrderSpecimenCollectionService orderSpecimenCollectionService) {
        this.labInformationService = labInformationService;
        this.orderSpecimenCollectionService = orderSpecimenCollectionService;
    }*/

    public Vector<Vector<String>> getPrescribeOrderList(TPatient patient) throws ProcessingException{
        try{
        return labInformationService.getPrescribeOrderList(patient);
        }catch(ProcessingException e){
            throw e;
        }
    } 
    
     public Vector<Vector<String>> getComponentListByProcedure(TEncounterProcedure orderDetails,TPatientEncounter encounter) throws ProcessingException{
        try{
        return labInformationService.getComponentListByProcedure(orderDetails,encounter);
        }catch(ProcessingException e){
            throw e;
        }
    } 
     
     public void saveSpecimenDetails(TPatEncOrderSpecimen patEncOrderSpecimen)throws ProcessingException{
        try{
            orderSpecimenCollectionService.saveSpecimenDetails(patEncOrderSpecimen);
        }catch(ProcessingException e){
            throw e;
        }
    }
     
     public Long saveProcedureEncounter(TEncounterProcedure encounterProcedure)throws ProcessingException{
        try{
            return labInformationService.saveProcedureEncounter(encounterProcedure);
        }catch(ProcessingException e){
            throw e;
        }
    }
     
     public void deleteProcedureEncounter(TProcedureMaster procrdure, TPatientEncounter encounter)throws ProcessingException,IllegalArgumentException {
        try{
            labInformationService.deleteProcedureEncounter(procrdure,encounter);
        }catch(IllegalArgumentException e){
            throw e;
        }catch(ProcessingException e){
            throw e;
        }
    }
     
     public TEncounterProcedure getProcedureEncounterByID(Long ID)throws ProcessingException {
        try{
            return labInformationService.getProcedureEncounterByID(ID);
        }catch(ProcessingException e){
            throw e;
        }
    }
     
     public void updateProcedureEncounter(TEncounterProcedure encounterProcedure)throws ProcessingException,HibernateOptimisticLockingFailureException {
        try{
            labInformationService.upDateProcedureEncounter(encounterProcedure);
        }catch(HibernateOptimisticLockingFailureException e){
            throw e;
        }catch(ProcessingException e){
            throw e;
        }
    }
    
    public void deleteProcedureEncounterDetailsByID(Long ID, TPatientEncounter encounter)throws ProcessingException,IllegalArgumentException {
        try{
            labInformationService.deleteProcedureEncounterDetailsByID(ID,encounter);
        }catch(IllegalArgumentException e){
            throw e;
        }catch(ProcessingException e){
            throw e;
        }
    }
    
    
    
    public List<TEncounterProcedure> getTodayPrescribeOrder(TPatient patient)throws ProcessingException{
         try{
          return labInformationService.getTodayPrescribeOrder(patient);
        }catch(ProcessingException e){
            throw e;
        }
     
     }
    
    public Vector<TProcedureMaster> getAllPrescribeOrderForPatient(TPatient patient)throws ProcessingException{
         try{
            Vector procedures = new Vector();
            List<TProcedureMaster> procedureList = labInformationService.getAllPrescribeOrderForPatient(patient);
            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<Vector<String>> getPrescribeOrderToday(TPatient patient) throws ProcessingException{
        try{
        return labInformationService.getPrescribeOrderToday(patient);
        }catch(ProcessingException e){
            throw e;
        }
    }
    public List<TEncounterProcedure> getEncounterProcedureForPatient(TPatient patient,TProcedureMaster orderSelected)throws ProcessingException{
        try{
        return labInformationService.getEncounterProcedureForPatient(patient,orderSelected);
        }catch(ProcessingException e){
            throw e;
        }
    }

    public List<TPatientEncounter> getEncounterDates(TPatient patient)throws ProcessingException {
        try{
            return labInformationService.getEncounterDates(patient);
        }catch(ProcessingException e){
            throw e;
        }
    }

     public List<TEncounterProcedure> findAllOrderListForCheckBoxTable(TPatient patient)throws ProcessingException{
         try{
          return labInformationService.findAllOrderListForCheckBoxTable(patient);
        }catch(ProcessingException e){
            throw e;
        }
     
     }

    public TPatientEncounter saveNewEncForSelectedPatient(TPatientEncounter enc)throws ProcessingException,HibernateOptimisticLockingFailureException {
        try{
            return labInformationService.saveNewEncForSelectedPatient(enc);
        }catch(HibernateOptimisticLockingFailureException e){
            throw e;
        }catch(ProcessingException e){
            throw e;
        }
    }

    public TPatientEncounter getencforlab(TPatient patient,String enctype)throws ProcessingException {
        try{
            return labInformationService.getencforlab(patient,enctype);
        }catch(ProcessingException e){
            throw e;
        }
    }

    public List<TEncounterProcedure> getPreviousLabTest(TPatient patient) throws ProcessingException{
        try{
            return labInformationService.getPreviousLabTest(patient);
        }catch(ProcessingException e){
            throw e;
        }
    }
     
}