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

import com.bestray.healthcarecommonutil.exception.ProcessingException;
import com.bestray.healthcarecommonutil.service.AllergiesMasterService;
import com.bestray.healthcarecommonutil.service.DiagnosisMasterService;
import com.bestray.healthcarecommonutil.service.GroupProcedureService;
import com.bestray.healthcarecommonutil.service.MedicationMasterService;
import com.bestray.healthcarecommonutil.service.MyFavService;
import com.bestray.healthcarecommonutil.service.ProcedureMasterService;
import com.bestray.healthcarecommonutil.vo.TAccount;
import com.bestray.healthcarecommonutil.vo.TAllergiesMaster;
import com.bestray.healthcarecommonutil.vo.TCCodeValues;
import com.bestray.healthcarecommonutil.vo.TDiagnosisMaster;
import com.bestray.healthcarecommonutil.vo.TEncounterProcedure;
import com.bestray.healthcarecommonutil.vo.TEncounterTreatmentSession;
import com.bestray.healthcarecommonutil.vo.TGroupMaster;
import com.bestray.healthcarecommonutil.vo.TMedicationMaster;
import com.bestray.healthcarecommonutil.vo.TMyFav;
import com.bestray.healthcarecommonutil.vo.TPatientEncounter;
import com.bestray.healthcarecommonutil.vo.TProcedureMaster;
import java.util.List;
import java.util.Vector;
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.Controller;

/**
 *
 * @author user3
 */
@Controller
public class MyFavController {
    @Autowired
    private MyFavService myFavService;
    @Autowired
    private DiagnosisMasterService diagnosisMasterService;
    @Autowired
    private ProcedureMasterService procedureMasterService;
    @Autowired
    private MedicationMasterService medicationMasterService;
    @Autowired
    private AllergiesMasterService allergyMasterService;
    @Autowired
    private GroupProcedureService groupProcedureService;
    
    public void saveMyFavDiagnosis(List<TMyFav> favdiaglist)throws ProcessingException{
        try{
            myFavService.saveMyFavDiagnosis(favdiaglist);
        }catch(ProcessingException e){
            throw e;
        }
    }
    public Vector<TDiagnosisMaster> getFavDiagByAccount(TAccount useracc,String type)throws ProcessingException{
        Vector<TDiagnosisMaster> diagList=null;
        try{
            List<TMyFav> favdiags = myFavService.getFavDiagByAccount(useracc,type);
            diagList = new Vector<TDiagnosisMaster>();
            for(TMyFav mfav:favdiags){
                TDiagnosisMaster diag = diagnosisMasterService.getDiagnosisValues(Integer.valueOf(mfav.getObjId().toString()));
                diagList.add(diag);
            }
        }catch(ProcessingException e){
            throw e;
        }
        return diagList;
    }
    
    public Vector<TProcedureMaster> getFavProcedureByAccount(TAccount useracc,String type)throws ProcessingException{
        Vector<TProcedureMaster> procList=null;
        try{
            List<TMyFav> favprocs = myFavService.getFavDiagByAccount(useracc,type);
            procList = new Vector<TProcedureMaster>();
            for(TMyFav mfav:favprocs){
                TProcedureMaster proc = procedureMasterService.getProcedureValues(mfav.getObjId());
                procList.add(proc);
            }
        }catch(ProcessingException e){
            throw e;
        }
        return procList;
    }
    
    public Vector<TMedicationMaster> getFavMedicationByAccount(TAccount useracc,String type)throws ProcessingException{
        Vector<TMedicationMaster> medList=null;
        try{
            List<TMyFav> favprocs = myFavService.getFavDiagByAccount(useracc,type);
            medList = new Vector<TMedicationMaster>();
            for(TMyFav mfav:favprocs){
                TMedicationMaster med = medicationMasterService.getMedicationValues(mfav.getObjId());
                medList.add(med);
            }
        }catch(ProcessingException e){
            throw e;
        }
        return medList;
    }
    
    public Vector<TAllergiesMaster> getFavAllergyByAccount(TAccount useracc,String type)throws ProcessingException{
        Vector<TAllergiesMaster> allergyList=null;
        try{
            List<TMyFav> favprocs = myFavService.getFavDiagByAccount(useracc,type);
            allergyList = new Vector<TAllergiesMaster>();
            for(TMyFav mfav:favprocs){
                TAllergiesMaster allergy = allergyMasterService.getAllergiesValues(mfav.getObjId());
                allergyList.add(allergy);
            }
        }catch(ProcessingException e){
            throw e;
        }
        return allergyList;
    }
    
    public Vector<TMedicationMaster> getMedicationByName(String expr)throws ProcessingException {
        try{
            Vector<TMedicationMaster> medics = new Vector<TMedicationMaster>();
            List<TMedicationMaster> medicationList = medicationMasterService.getMedicationByName(expr);
            for(TMedicationMaster med:medicationList){
                medics.addElement(med);
            }
            return medics;
        }catch(ProcessingException e){
            throw e;
        }
    }
    
    public Vector<TDiagnosisMaster> getDiagnosisByName(String expr)throws ProcessingException {
        try{
            Vector<TDiagnosisMaster> diagnosis = new Vector<TDiagnosisMaster>();
            List<TDiagnosisMaster> diagnosisList = diagnosisMasterService.getDiagnosisByName(expr);
            for(TDiagnosisMaster diagnos:diagnosisList){
                diagnosis.addElement(diagnos);
            }
            return diagnosis;
        }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 procedure:procedureList){
                procedures.addElement(procedure);
            }
            return procedures;
        }catch(ProcessingException e){
            throw e;
        }
    }
    
    public Vector<TAllergiesMaster> getAllergyByName(String expr)throws ProcessingException {
        try{
            Vector<TAllergiesMaster> allergies = new Vector<TAllergiesMaster>();
            List<TAllergiesMaster> allergiesList = allergyMasterService.searchForAllergyName(expr);
            System.out.println("ALLERGY SIZE:::"+allergiesList.size());
            for(TAllergiesMaster allergy:allergiesList){
                allergies.addElement(allergy);
            }
            System.out.println("ALLERGY SIZE:::"+allergies.size());
            return allergies;
        }catch(ProcessingException e){
            throw e;
        }
    }

    public List<TCCodeValues> getAllTreatmentList()throws ProcessingException {
        try{
            return myFavService.getAllTreatmentList();
        }catch(ProcessingException e){
            throw e;
        }
    }
    
    public Vector<TCCodeValues> getAllTreatmentVector()throws ProcessingException {
        try{
            Vector<TCCodeValues> allergies = new Vector<TCCodeValues>();
            List<TCCodeValues> allergiesList = myFavService.getAllTreatmentList();
            for(TCCodeValues allergy:allergiesList){
                allergies.addElement(allergy);
            }
            return allergies;
        }catch(ProcessingException e){
            throw e;
        }
    }

    public void deleteFavList(Long ObjId,String type) throws ProcessingException{
        try {
            myFavService.deleteFavList(ObjId,type);
        } catch (ProcessingException ex) {
            Logger.getLogger(MyFavController.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
    
    public Vector<TGroupMaster> getAllGroups() throws ProcessingException{
     
        List<TGroupMaster> groupList;
        try {
            groupList = myFavService.getAllGroupList();
            Vector<TGroupMaster> groupData = new Vector<>();
            for (TGroupMaster tGroupMaster : groupList) {
                groupData.addElement(tGroupMaster);
            }
            return groupData;
        } catch (ProcessingException ex) {
            Logger.getLogger(MyFavController.class.getName()).log(Level.SEVERE, null, ex);
            throw new ProcessingException();      
        }  
    }
    
    public List<TProcedureMaster> getSelectedProcedureByGroup(TGroupMaster groupMaster)throws ProcessingException{
        try {
            return groupProcedureService.getSelectedProcedureByGroup(groupMaster); 
        } catch (Exception ex) {
            Logger.getLogger(MyFavController.class.getName()).log(Level.SEVERE, null, ex);
            throw new ProcessingException();
        }
    }
    public List<TEncounterProcedure> getAllTreatmentsByEncounter(TPatientEncounter encounter)throws ProcessingException{
        try{
           return myFavService.getAllTreatmentsByEncounter(encounter);
        }catch(ProcessingException e){
            throw e;
        }
    }
    public List<TEncounterTreatmentSession> getAllSessionByTreatment(TEncounterProcedure encProcedure)throws ProcessingException{
        try{
            return myFavService.getAllSessionByTreatment(encProcedure);
        }catch(ProcessingException e){
            throw e;
        }
    }
    
    
    public void UpdateTreatmentSession(TEncounterTreatmentSession encounterTreatmentSession)throws ProcessingException,HibernateOptimisticLockingFailureException{
        try{
            myFavService.UpdateTreatmentSession(encounterTreatmentSession);
        }catch(  HibernateOptimisticLockingFailureException | ProcessingException e){
            throw e;
        }
    }

    
}