package com.bestray.transtracking.service.impl;

import com.bestray.transporttracking.DataSourceObject;
import com.bestray.transtracking.dao.AddressDao;
import com.bestray.transtracking.dao.ClientDao;
import com.bestray.transtracking.dao.impl.AddressDaoImpl;
import com.bestray.transtracking.dao.impl.ClientDaoImpl;
import com.bestray.transtracking.service.ClientService;
import com.bestray.trastrack.domain.Address;
import com.bestray.trastrack.domain.ClientUser;
import java.util.Date;
import java.util.List;
import java.util.Vector;
import com.bestray.transtracking.dao.CountryDao;
import com.bestray.transtracking.dao.EmployeeDao;
import com.bestray.transtracking.dao.impl.CountryDaoImpl;
import com.bestray.transtracking.dto.ClientSearchResultDTO;
import java.util.logging.Level;
import java.util.logging.Logger;
import com.bestray.transtracking.exceptions.TransTrackException;

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

/**
 *
 * @author user3
 */
public class ClientServiceImpl implements ClientService{
    
    private ClientDao clientDao;
    private EmployeeDao employeeDao;
    private DataSourceObject dobj;
    private AddressDao addrDao;
    private CountryDao countryDao;
    public ClientServiceImpl(){
        
    }
    
    public boolean registerClient(ClientUser user){
        
        /*cdao = new ClientDaoImpl( DataSourceObject.getDataSourceObject());
        cdao.saveClient(user);
        return true;*/
        boolean flag = false;
        try{
         addrDao = new AddressDaoImpl( DataSourceObject.getDataSourceObject());
          clientDao = new ClientDaoImpl( DataSourceObject.getDataSourceObject());
        if(user.getId() != null && user.getId()>0){
            if(user.getClientaddress() !=null){
            if(user.getClientaddress() != null && user.getClientaddress().getId() != null && user.getClientaddress().getId()>0){
               addrDao.updateAddress(user.getClientaddress()) ;
               //clientDao.updateClient(user);
            }else{
                addrDao.addAddress(user.getClientaddress());
            }
            }
            clientDao.updateClient(user);
        }else{
        
       
        if(user.getClientaddress()!=null){
            //System.out.println("Adding Address");
            user.getClientaddress().setUpdatedDate(new Date());
            user.getClientaddress().setCreatedDate(new Date());
            Address clientaddr = addrDao.addAddress(user.getClientaddress());
            user.setClientaddress(clientaddr);
        }      
        
        user.setUpdatedDate(new Date());
        user.setCreatedDate(new Date());
        clientDao.saveClient(user);
        
        }
        flag = true;
         } catch (Exception ex) {
            Logger.getLogger(ClientCollectionServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new TransTrackException("Error in Fetching Employee Name List");
        }
         return flag;
    }

    public Vector<Vector<String>> getClientList() throws TransTrackException{
        /*Vector<Vector<String>> clients = new Vector<Vector<String>>();
        try{
        addrDao = new AddressDaoImpl( DataSourceObject.getDataSourceObject());
        clientDao = new ClientDaoImpl( DataSourceObject.getDataSourceObject());
         
       List<ClientUser> clientList = clientDao.findAllClients();
         for(ClientUser client:clientList){
             Address address = new Address();
              Vector<String> employee = new Vector<String>();
              employee.add(String.valueOf(client.getId()));  
              employee.add(client.getClientname()); //Empid
              employee.add(String.valueOf(client.getOpeningbal()));
              employee.add(client.getLock());
              address = addrDao.findById(client.getAddressid()!= null?client.getAddressid():0);
              if (address != null){
              employee.add(address.getAddress1());
              employee.add(address.getCity());
              }
               clients.add(employee);
          }
           }catch(Exception e){
           throw new TransTrackException("Error in Fetching Client List");
       }
        return clients;*/
        try {
            Vector<Vector<String>> clients = new Vector<Vector<String>>();
            clientDao = new ClientDaoImpl(DataSourceObject.getDataSourceObject());
            List<ClientSearchResultDTO> clientList;
            try {
                clientList = clientDao.findAllClientsList();
            } catch (Exception ex) {
                throw new TransTrackException("Error in populating Client Data");
            }
            for (ClientSearchResultDTO clientt : clientList) {
                Vector<String> client = new Vector<String>();
                client.add(clientt.getClientId());
                client.add(clientt.getClientName());                
                client.add(clientt.getAddress());
                client.add(clientt.getCity());
                client.add(clientt.getOpeningBalance());
                client.add(clientt.getLock());
                clients.add(client);
            }
            return clients;
        } catch (Exception ex) {
            Logger.getLogger(ClientServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new TransTrackException("Error in fetching client Records");
        }
    
    }

    public ClientUser getClientRegistrationDetails(Long clientId) {
       ClientUser client;
       try{ 
       clientDao = new ClientDaoImpl( DataSourceObject.getDataSourceObject());
        client = clientDao.findClientRegistraion(clientId);
        if(client.getAddressid()!=null&&client.getAddressid()>0){  
                //System.out.println("Client Address find out: "+client.getAddressid());
                addrDao = new AddressDaoImpl( DataSourceObject.getDataSourceObject());
                Address address = addrDao.findById(client.getAddressid());
                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()));
                 }
            client.setClientaddress(address);  
            }
                
      }
      else{
            client.setClientaddress(null);
          }
      }
      catch(Exception e){
           throw new TransTrackException("Error in Fetching Client Registration");
      }
       return client;
    }

    public void deleteClient(Long clientId)  throws TransTrackException{
        try {
            clientDao = new ClientDaoImpl( DataSourceObject.getDataSourceObject());
            addrDao = new AddressDaoImpl( DataSourceObject.getDataSourceObject());
        ClientUser client = clientDao.findClientRegistraion(clientId);
        if(client.getAddressid() != null && client.getAddressid()>0){
            //clientDao.delete(clientId);
        //addrDao.delete(client.getAddressid());
        
            //System.out.println("Deleted client......");
            clientDao.delete(clientId);
            addrDao.delete(client.getAddressid());
            }
        else{
            //System.out.println("Deleted client");
            clientDao.delete(clientId);
        }
        } catch (Exception ex) {
            Logger.getLogger(ClientServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
            throw new TransTrackException("Error in Delete Client");
            //throw new Exception("Client Information cannot be deleted");
        }
        
        
    }

    public List<ClientUser> getClientNameList() {
        try{
        clientDao = new ClientDaoImpl( DataSourceObject.getDataSourceObject());
        return clientDao.findAllClients();
        }catch(Exception e){
           throw new TransTrackException("Error in Fetching Client List");
       }
    }

    /*public Vector<Vector<String>> getClientNameLists() {
        addrDao = new AddressDaoImpl( DataSourceObject.getDataSourceObject());
        clientDao = new ClientDaoImpl( DataSourceObject.getDataSourceObject());
        Vector<Vector<String>> clients = new Vector<Vector<String>>();
        List<ClientUser> clientList = clientDao.findAllClients();
        for(ClientUser client:clientList){
             Address address = new Address();
             Vector<String> employee = new Vector<String>();
             employee.add(String.valueOf(client.getId()));  
              employee.add(client.getClientname());
              address = addrDao.findById(client.getAddressid()!= null?client.getAddressid():0);
              if (address != null){
              employee.add(address.getAddress1());
              employee.add(address.getCity());
        }
        clients.add(employee);
    }
    return clients;
  } */

    /*public boolean collectClient(ClientCollection collect) {
        
        clientDao = new ClientDaoImpl( DataSourceObject.getDataSourceObject());
        clientDao.saveCollection(collect);
        return true;
    }*/

    /*public List<ClientCollection> getSearchResult(ClientCollectionSearchDTO search) {
         DataSource ds =  DataSourceObject.getDataSourceObject();
         clientDao = new ClientDaoImpl(ds);
          List<ClientCollection> results = clientDao.getSearchResults(search);
          for(ClientCollection object :results){
                object.setCollection_type_id(partyDao.findPartyRegistraion(object.getPartyId()));
                object.setVehicle(vehicleService.getVehicleRegistrationDetails(object.getVehicleId()));
            }
    }*/
}