package art.servers.etdserver.controller;

import art.library.interop.InteropParameters;
import art.library.interop.InteropResponse;
import art.library.model.devices.Device;
import art.library.model.devices.DeviceStatus;
import art.library.model.devices.dps.DPS;
import art.library.model.devices.dps.types.DPSVehicle;
import art.library.model.transactions.traces.Trace;
import art.library.utils.synchro.Mutex;
import art.servers.etdserver.Shared;
import art.servers.etdserver.configuration.ConfigurationDPS;
import java.io.BufferedReader;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;


public class ControllerDPS extends art.servers.controller.Controller
{
    private ConfigurationDPS configurationDPS = null; 
    private DPS dps = null; 
    private Socket socket = null;
    private BufferedReader reader = null;
    private int status = DeviceStatus.STATUS_ALARM;
    private List<DPSVehicle> lvehicle = new ArrayList<DPSVehicle>();
    private long lastTimestamp = System.currentTimeMillis();
    private Mutex mutexList = new Mutex();
    private String name = "";


    public ControllerDPS(ConfigurationDPS configurationDPS)
    {
        this.configurationDPS = configurationDPS;
        this.name = "Controller DPS: " + configurationDPS.identifier;
        this.setName(this.name);
    }
    
    
    
    
    
    public DPS getDPS()
    {
        return this.dps;
    }    
    
    
    public ConfigurationDPS getConfigurationDPS()
    {
        return this.configurationDPS;
    }    


    public void run()
    {
        // <editor-fold defaultstate="collapsed" desc="Trace">
        art.servers.Shared.println(Trace.getTraceInformation(art.servers.Shared.getApplicationName(), name, art.servers.Shared.getMessage("Starting"), art.servers.Shared.getMessage("Success")), true);
        // </editor-fold>      

        while ((isInterrupted() == false) && (exit == false))
        {
            try
            {
                update();
            }
            catch (Exception e)
            {

            }

            try{sleep(configurationDPS.polling);} catch (Exception e){};
        }

        // <editor-fold defaultstate="collapsed" desc="Trace">
        art.servers.Shared.println(Trace.getTraceInformation(art.servers.Shared.getApplicationName(), name, art.servers.Shared.getMessage("Finishing"), art.servers.Shared.getMessage("Success")), true);
        // </editor-fold>      
    }
    
    
    
    
    private void update()
    {
        try
        {
            long timestamp = lastTimestamp;
            this.dps = (DPS)Shared.model.getDeviceExternal(configurationDPS.identifier);

            InteropParameters parameters = new InteropParameters();
            parameters.addParameter("service", "dps");
            parameters.addParameter("operation", "getVehicles");
            parameters.addParameter("identifier", this.dps.getIdentifier());
            parameters.addParameter("timestamp", String.valueOf(timestamp));

            if ((Shared.deviceLog != null) && (dps.getIdentifier().indexOf(Shared.deviceLog) > -1))
            {
                System.out.println("#" + Device.getDate(System.currentTimeMillis()) + ";GetVehicles;From=" + Device.getDate(timestamp));
            }

            InteropResponse response = this.dps.invoke("get", parameters, 40000);

            Object[] lobject = response.getValue();

            List<DPSVehicle> lvehicle = new ArrayList<DPSVehicle>();
            for (Object object : lobject)
            {
                DPSVehicle vehicle = (DPSVehicle)object;
                lvehicle.add(vehicle);
            }

            long maxTimestamp = timestamp;
            for (DPSVehicle vehicle : lvehicle)
            {
                if (vehicle.timestamp > maxTimestamp) maxTimestamp = vehicle.timestamp;
                addVehicle(vehicle);
            }

            this.lastTimestamp = maxTimestamp;
            if ((Shared.deviceLog != null) && (dps.getIdentifier().indexOf(Shared.deviceLog) > -1))
            {
                System.out.println("#" + Device.getDate(System.currentTimeMillis()) + ";GetVehicles;Next=" + Device.getDate(maxTimestamp));
            }

            long timestampRemove = System.currentTimeMillis() - (1L*60L*60000L);
            clearVehicles(timestampRemove);
        }
        catch (Exception e)
        {
            Shared.println(this.name, e);
        }
    }




    private void addVehicle (DPSVehicle vehicle)
    {
        try
        {
            mutexList.lockWrite();
            this.lvehicle.add(vehicle);
            logger(vehicle);
        }
        catch (Exception e)
        {
            
        }
        finally
        {
            mutexList.releaseWrite();
        }
    }


    public List<DPSVehicle> getVehicles(long from, long to, int lane)
    {
        List<DPSVehicle> lresult = new ArrayList<DPSVehicle>();

        try
        {
            loggerVehicles(Device.getDate(System.currentTimeMillis()) + ";From="+Device.getDate(from)+";To="+Device.getDate(to)+";Lane="+lane, lane);
            mutexList.lockRead();
            for (DPSVehicle vehicle : lvehicle)
            {
                if ((from <= vehicle.timestamp) && (vehicle.timestamp <= to) && (vehicle.lane == lane))
                {
                    loggerVehicles("\t" + Device.getDate(System.currentTimeMillis()) + ";TS="+Device.getDate(vehicle.timestamp)+";Device="+vehicle.device+";Occ="+vehicle.occupancy+";Lane="+vehicle.lane, lane);
                    lresult.add(vehicle);
                }
            }
        }
        catch (Exception e)
        {
            
        }
        finally
        {
            mutexList.releaseRead();
        }

        loggerVehicles(Device.getDate(System.currentTimeMillis()) + ";From="+Device.getDate(from)+";To="+Device.getDate(to)+";Lane="+lane+";Counting="+lresult.size(), lane);
        return(lresult);
    }




    private void clearVehicles (long timestamp)
    {
        try
        {
            mutexList.lockWrite();
            List<DPSVehicle> lremove = new ArrayList<DPSVehicle>();
            for (DPSVehicle vehicle : lvehicle)
            {
                if (vehicle.timestamp < timestamp)
                {
                    lremove.add(vehicle);
                }
            }

            this.lvehicle.removeAll(lremove);
        }
        catch (Exception e)
        {
            
        }
        finally
        {
            mutexList.releaseWrite();
        }
    }




    // <editor-fold defaultstate="collapsed" desc="Logger">

    private void loggerVehicles (String message, int lane)
    {
        try
        {
            if ((Shared.deviceLog != null) && (dps.getIdentifier().indexOf(Shared.deviceLog) > -1) && (lane == 1))
            {
                System.out.println(message);
            }
        }
        catch (Exception e)
        {
            
        }
    }


    private void logger(DPSVehicle vehicle)
    {
        try
        {
            if (Shared.logDPS == true)
            {
                if (Shared.deviceLog != null)
                {
                    if ((vehicle.device.equalsIgnoreCase(Shared.deviceLog)) && (vehicle.lane == 1))
                    {
                        System.out.println(Device.getDate(System.currentTimeMillis())+";"+Device.getDate(vehicle.timestamp)+";device="+vehicle.device+"lane="+vehicle.lane+";speed="+vehicle.speed+";occupancy="+vehicle.occupancy);
                    }
                }
                else
                {
                    System.out.println(Device.getDate(System.currentTimeMillis())+";"+Device.getDate(vehicle.timestamp)+";device="+vehicle.device+"lane="+vehicle.lane+";speed="+vehicle.speed+";occupancy="+vehicle.occupancy);
                }
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
    
    // </editor-fold>

}