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

import com.bestray.transporttracking.DataSourceObject;
import com.bestray.transtracking.dao.AddressDao;
import com.bestray.transtracking.dao.CountryDao;
import com.bestray.transtracking.dao.EmployeeDao;
import com.bestray.transtracking.dao.impl.AddressDaoImpl;
import com.bestray.transtracking.dao.impl.CodeDaoImpl;
import com.bestray.transtracking.dao.impl.CountryDaoImpl;
import com.bestray.transtracking.dao.impl.EmployeeDaoImpl;
import com.bestray.transtracking.dto.EmployeeSearchResultDTO;
import com.bestray.transtracking.service.EmployeeService;
import com.bestray.trastrack.domain.Address;
import com.bestray.trastrack.domain.Code;
import com.bestray.trastrack.domain.Employee;
import java.util.Date;
import java.util.List;
import java.util.Vector;
import java.util.logging.Level;
import java.util.logging.Logger;
import com.bestray.transtracking.exceptions.TransTrackException;

public class EmployeeServiceImpl implements EmployeeService {

    private EmployeeDao employeeDao;
    private AddressDao addressDao;
    private CodeDaoImpl codeDao;
    private CountryDao countryDao;

    public EmployeeServiceImpl() {
    }

    public boolean NewEmployee(Employee employee) {
        try {
            addressDao = new AddressDaoImpl(DataSourceObject.getDataSourceObject());
            employeeDao = new EmployeeDaoImpl(DataSourceObject.getDataSourceObject());
            if (employee.getId() != null && employee.getId() > 0) {
                if(employee.getPermanentAddress()!=null){
                    if (employee.getPermanentAddress() != null && employee.getPermanentAddress().getId() != null && employee.getPermanentAddress().getId() > 0) {
                        addressDao.updateAddress(employee.getPermanentAddress());
                    }else{
                          addressDao.addAddress(employee.getPermanentAddress());                         
                    }
                }
                if(employee.getPresentAddress()!=null){
                    if (employee.getPresentAddress() != null && employee.getPresentAddress().getId() != null && employee.getPresentAddress().getId() > 0) {
                        addressDao.updateAddress(employee.getPresentAddress());
                    }else{
                        addressDao.addAddress(employee.getPresentAddress());
                    }
                }
                employeeDao.updateEmployee(employee);
            } else {
                if (employee.getPermanentAddress() != null) /*&& 
                        employee.getPermanentAddress().getAddress1() != null &&
                         employee.getPermanentAddress().getState() != null && 
                         employee.getPermanentAddress().getCity() != null)*/ {
                    employee.getPermanentAddress().setUpdatedDate(new Date());
                    employee.getPermanentAddress().setCreatedDate(new Date());
                    Address emppermanentaddr = addressDao.addAddress(employee.getPermanentAddress());
                    employee.setPermanentAddress(emppermanentaddr);
                }
                if (employee.getPresentAddress() != null) {
                    employee.getPresentAddress().setUpdatedDate(new Date());
                    employee.getPresentAddress().setCreatedDate(new Date());
                    Address emppresentaddr = addressDao.addAddress(employee.getPresentAddress());
                    employee.setPresentAddress(emppresentaddr);
                }
                employee.setUpdatedDate(new Date());
                employee.setCreatedDate(new Date());
                employeeDao.addEmployee(employee);
            }
            //employeeDao = new EmployeeDaoImpl( DataSourceObject.getDataSourceObject());
            //employee.setUpdatedDate(new Date());
            // employee.setCreatedDate(new Date());
            // employeeDao.addEmployee(employee);
            return true;
        } catch (Exception ex) {
            Logger.getLogger(EmployeeServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new TransTrackException("Error in creating Employee Record");
        }

    }

    public Vector<Vector<String>> getEmplyoeeList() {
        try {
            employeeDao = new EmployeeDaoImpl(DataSourceObject.getDataSourceObject());
            addressDao = new AddressDaoImpl(DataSourceObject.getDataSourceObject());
            codeDao = new CodeDaoImpl(DataSourceObject.getDataSourceObject());
            Vector<Vector<String>> employees = new Vector<Vector<String>>();
            List<Employee> employeeList = employeeDao.findAllEmployees();
            for (Employee empl : employeeList) {

                Address address = new Address();
                Code code = new Code();
                Vector<String> employeeVector = new Vector<String>();
                employeeVector.add(String.valueOf(empl.getId()));
                employeeVector.add(empl.getEmployee_Name());
                code = codeDao.getCodeById(empl.getCategoryCodeId() != null ? empl.getCategoryCodeId() : 0);
                if (code != null) {
                    employeeVector.add(code.getName());
                }
                address = addressDao.findById(empl.getPresentAddressid() != null ? empl.getPresentAddressid() : 0);
                if (address != null) {
                    employeeVector.add(address.getAddress1());
                    //employeeVector.add(address.getCity());
                }
                employeeVector.add(String.valueOf(empl.getContact1()));
                employeeVector.add(String.valueOf(empl.getOpen_Balance()));
                employeeVector.add(String.valueOf(empl.getLock()));

                employees.add(employeeVector);

            }



            return employees;
        } catch (Exception ex) {
            Logger.getLogger(EmployeeServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new TransTrackException("Error in Fetching Employee Record");
        }

    }

    public Employee getEmployeeRegistrationDetails(Long employeeId) {
        Employee employee;
        try {
            employeeDao = new EmployeeDaoImpl(DataSourceObject.getDataSourceObject());            
            codeDao = new CodeDaoImpl(DataSourceObject.getDataSourceObject());
            employee = employeeDao.findEmplRegistraion(employeeId);
            if(employee.getPresentAddressid()!=null&&employee.getPresentAddressid()>0){
            addressDao = new AddressDaoImpl(DataSourceObject.getDataSourceObject());
            Address address = addressDao.findById(employee.getPresentAddressid());
            if (address != null) {
                countryDao = new CountryDaoImpl(DataSourceObject.getDataSourceObject());
                if (address.getCountryId() != null) {
                    address.setCounty(countryDao.getCountryById(address.getCountryId()));
                }
                if (address.getStateId() != null) {
                    address.setState(countryDao.getStateById(address.getStateId()));
                }
                employee.setPresentAddress(address);
            }
            }else{
                employee.setPresentAddress(null);
            }
            
            Address address2 = new Address();
            
             if(employee.getPermanentAddressid()!= null && employee.getPermanentAddressid()>0){
             address2 = addressDao.findById(employee.getPermanentAddressid());
            if (address2 != null) {
                countryDao = new CountryDaoImpl(DataSourceObject.getDataSourceObject());
                if (address2.getCountryId() != null) {
                    address2.setCounty(countryDao.getCountryById(address2.getCountryId()));
                }
                if (address2.getStateId() != null) {
                    address2.setState(countryDao.getStateById(address2.getStateId()));
                }
            }
                employee.setPermanentAddress(address2);
             }else{
                 employee.setPermanentAddress(null);
             }           
            
        } catch (Exception ex) {
            Logger.getLogger(EmployeeServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new TransTrackException("Error in Fething Employee Record");
        }
        return employee;
    }

    public void deleteEmployee(Long employeeId) throws TransTrackException {
        try {
             addressDao = new AddressDaoImpl(DataSourceObject.getDataSourceObject());
            employeeDao = new EmployeeDaoImpl(DataSourceObject.getDataSourceObject());
            Employee emp = employeeDao.findEmplRegistraion(employeeId);
            employeeDao.delete(employeeId);
            if (emp.getPermanentAddressid() != null&&emp.getPermanentAddressid()>0) {
                addressDao.delete(emp.getPermanentAddressid());
            }
            if (emp.getPresentAddressid() != null&&emp.getPresentAddressid()>0) {
                addressDao.delete(emp.getPresentAddressid());
            }
            
        } catch (Exception ex) {
            Logger.getLogger(EmployeeServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new TransTrackException("Employee Information cannot be deleted");
        }
    }

    public List<Employee> getDriverNameList() {
        try {
            employeeDao = new EmployeeDaoImpl(DataSourceObject.getDataSourceObject());
            return employeeDao.findAllEmployees();
        } catch (Exception ex) {
            Logger.getLogger(DriverStaffPaymentServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new TransTrackException("Error in fetching Driver Record");
        }
    }

    public Vector<Vector<String>> getEmployeeNameLists() {
        try {
            addressDao = new AddressDaoImpl(DataSourceObject.getDataSourceObject());
            employeeDao = new EmployeeDaoImpl(DataSourceObject.getDataSourceObject());
            Vector<Vector<String>> employees = new Vector<Vector<String>>();
            List<Employee> employeeList = employeeDao.findAllEmployees();
            for (Employee employeee : employeeList) {
                Address address = new Address();
                Vector<String> employee = new Vector<String>();
                employee.add(String.valueOf(employeee.getId()));
                employee.add(employeee.getEmployee_Name());
                address = addressDao.findById(employeee.getPresentAddressid() != null ? employeee.getPresentAddressid() : 0);
                if (address != null) {
                    employee.add(address.getAddress1());
                    employee.add(address.getCity());
                }
                employees.add(employee);
            }
            return employees;
        } catch (Exception ex) {
            Logger.getLogger(EmployeeServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new TransTrackException("Error in Fetching Employee Record");
        }
    }

    public Vector<Vector<String>> findAllEmployeesList() throws TransTrackException {
        try {
            Vector<Vector<String>> employees = new Vector<Vector<String>>();
            employeeDao = new EmployeeDaoImpl(DataSourceObject.getDataSourceObject());
            List<EmployeeSearchResultDTO> employeeList;
            try {
                employeeList = employeeDao.findAllEmployeesList();
            } catch (Exception ex) {
                throw new TransTrackException("Error in populating Employee Data");
            }
            for (EmployeeSearchResultDTO employeee : employeeList) {
                Vector<String> employee = new Vector<String>();
                employee.add(employeee.getEmployeeId());
                employee.add(employeee.getEmployeeName());
                employee.add(employeee.getEmpleoyeeCategory());
                employee.add(employeee.getAddress());
                employee.add(employeee.getContactNbr());
                employee.add(employeee.getOpeningBalance());
                employee.add(employeee.getLock());

                employees.add(employee);
            }
            return employees;
        } catch (Exception ex) {
           Logger.getLogger(EmployeeServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new TransTrackException("Error in fetching employee Records");
        }
    }
}