package art.servers.etdserver.controller;


import art.library.interop.InteropParameter;
import art.library.interop.InteropParameters;
import art.library.interop.InteropResponse;
import art.library.model.devices.DeviceStatus;
import art.library.model.devices.etd.Etd;
import art.library.interop.serialization.Serialization;
import art.library.interop.serialization.SerializationException;
import art.library.model.devices.Device;
import art.library.model.devices.DevicePersistenceTimeless;
import art.library.model.devices.application.Application;
import art.library.model.devices.etd.EtdInformation;
import art.library.model.devices.etd.EtdStatus;
import art.library.model.devices.etd.information.EtdInformationSection;
import art.library.model.devices.etd.status.EtdStatusLane;
import art.library.model.transactions.traces.Trace;
import art.library.utils.common.NumberUtils;
import art.library.utils.synchro.Mutex;
import art.servers.ServerException;
import art.servers.etdserver.Shared;
import static java.lang.Thread.sleep;
import java.net.Socket;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;


public class ControllerMController extends ControllerEtd
{
    private SimpleDateFormat sdh = new SimpleDateFormat("HH:mm");
    private Socket socket = null;
    private boolean connected = false;
    private long lastTimestamp = 0;
    private int status = DeviceStatus.STATUS_ALARM;
    private boolean firstTime = true;
    private List<EtdStatus> letdStatus = new ArrayList<EtdStatus>();
    private String serverAddress = "";
    private int serverPort = 0;
    private int serverTimeout = 30000;
    private Mutex mutexEtdStatus = new Mutex();


    public ControllerMController(Etd etd)
    {
        super(etd);
        this.device = etd;
        this.name = Shared.getMessage("Controller etd") + " " + etd.information.name;
    }
    
    
    
    
    public void run()
    {
        String  message = Shared.getMessage("Running");
        // <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>      
        status = DeviceStatus.STATUS_ONLINE;

        while ((isInterrupted() == false) && (exit == false))
        {
            long startTimestamp = System.currentTimeMillis();

            try
            {
                if (art.servers.Shared.isServerEnabled() == true)
                {
                    getColorsServer();

                    if (connected == false) 
                    {
                        connect();
                    }

                    update();
                }
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }

            if (startTimestamp > System.currentTimeMillis())
            {
                startTimestamp = System.currentTimeMillis();
            }

            long stopTimestamp = startTimestamp + (device.getDeviceInformation().polling * 1000);

            while ((System.currentTimeMillis() < stopTimestamp) && (exit == false))
            {
                try
                {
                    sleep(50);
                }
                catch (Exception e)
                {
                }
            }
           
            if (art.servers.Shared.model.existsDevice(device.getIdentifier()) == false)
            {
                art.servers.Shared.println(name, art.servers.Shared.getMessage("Device no longer exists"));
                exit = true;
            }
        }
        
        // <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>      
    }


    public EtdStatus[] getRealtimeTrafficData (long timestamp1, long timestamp2)
    {
        List<EtdStatus> list = new ArrayList<EtdStatus>();

        try
        {
            mutexEtdStatus.lockRead();

            for (EtdStatus etdStatus : letdStatus)
            {
                if ((timestamp1 <= etdStatus.measurementTimestamp) && (etdStatus.measurementTimestamp <= timestamp2))
                {
                    list.add(etdStatus);
                }
            }
        }
        catch (Exception e)
        {
            
        }
        finally
        {
            mutexEtdStatus.releaseRead();
        }

        return(list.toArray(new EtdStatus[0]));
    }




    /*
        Private controller functions
    */

    private void getColorsServer()
    {
        try
        {
            List<Device> ldevice = (List<Device>)DevicePersistenceTimeless.getDevices((List<Object>)(List<?>)Shared.controllerDatabase.timeless_getObject(DevicePersistenceTimeless.class.getName(), "type = '" + Application.class.getName() + "'"));

            for (Device device : ldevice)
            {
                if (device instanceof Application)
                {
                    Application application = (Application)device;
                    if (application.getDeviceInformation().serverServiceName.equalsIgnoreCase("colors") == true)
                    {
                        String serverAddress = application.getDeviceInformation().serverAddress;
                        int serverPort = application.getDeviceInformation().serverPort;
                        if ((this.serverAddress.equalsIgnoreCase(serverAddress) == false) || (this.serverPort != serverPort))
                        {
                            disconnect();
                        }

                        this.serverAddress = serverAddress;
                        this.serverPort = serverPort;
                    }
                }
            }
        }
        catch (Exception e)
        {   
            // If any error, we continues with last serverAddress and serverPort values
        }
    }


    private EtdStatus getRealtimeTrafficData() throws ServerException, SerializationException, Exception
    {
        InteropParameters parameters = new InteropParameters();
        parameters.addParameter(new InteropParameter("service", name));
        parameters.addParameter(new InteropParameter("operation", "getRealtimeTrafficData"));
        parameters.addParameter(new InteropParameter("language", Shared.configuration.general.language));
        parameters.addParameter(new InteropParameter("identifier", this.device.getIdentifier().replaceAll("etd-", "")));
        parameters.addParameter(new InteropParameter("timestamp", String.valueOf(lastTimestamp)));
        InteropResponse response = (InteropResponse)Serialization.invoke("get", parameters, socket);
        EtdStatus[] etdStatus = Arrays.copyOf(response.getValue(), response.getValue().length, EtdStatus[].class);

        lastTimestamp = etdStatus[0].measurementTimestamp;

        return(etdStatus[0]);
    }


    private void update() throws Exception
    {
        Etd etdclone = (Etd)Serialization.clone(device);

        try
        {
            EtdStatus etdStatus = getRealtimeTrafficData();

            updateEtdStatus(etdclone, etdStatus);

            addEtdStatus(etdclone.getDeviceStatus());

            online(etdclone);
            return;
        }
        catch (Exception exception)
        {
            Shared.printstack(name, exception);
            if ((etdclone.alarms.alarm_offline <= 0) || (firstTime == true))
            {
                firstTime = false;
                String message = art.servers.Shared.getMessage("Etd offline");
                art.servers.Shared.println(name, exception);
            }

            offline(etdclone);
            try{disconnect();} catch (Exception ex){};
        }
    }




    private void offline(Etd etdclone)throws Exception
    {
        if (etdclone.getAlarm("alarm_offline") <= 0)
        {
            etdclone.getDeviceAlarms().clear();
        }

        etdclone.setAlarm("alarm_offline", true);
        Shared.model.updateDevice(device, etdclone);
    }


    private void online(Etd etdclone) throws Exception
    {
        if ((etdclone.alarms.alarm_offline > 0) || (firstTime == true))
        {
            firstTime = false;
            String message = art.servers.Shared.getMessage("Etd online");
            art.servers.Shared.println(name, message);
        }

        etdclone.setAlarm("alarm_offline", false);
        etdclone.setAlarm("alarm_invalid", false);
        Shared.model.updateDevice(device, etdclone);
    }


    private void addEtdStatus (EtdStatus etdStatus)
    {
        try
        {
            mutexEtdStatus.lockWrite();

            if (letdStatus.size() == this.device.getDeviceInformation().realTimeSavingPeriods)
            {
                letdStatus.remove(0);
            }

            letdStatus.add(etdStatus);
        }
        catch (Exception e)
        {
            
        }
        finally
        {
            mutexEtdStatus.releaseWrite();
        }
    }


    private void updateEtdStatus (Etd etdclone, EtdStatus etdStatusController)
    {
        try
        {
            EtdStatus etdStatusCurrent = etdclone.getDeviceStatus();
            etdStatusCurrent.measurementTimestamp = etdStatusController.measurementTimestamp;
            etdStatusCurrent.period = etdclone.getDeviceInformation().period;
            etdStatusCurrent.llane.clear();
            etdStatusCurrent.llane = etdStatusController.llane;

            etdStatusCurrent.lsection.clear();

            if (etdStatusCurrent.total == null)
            {
                etdStatusCurrent.total = new EtdStatusLane();
            }

            emptyTotal(etdclone, etdStatusCurrent);
            etdStatusCurrent.total.status = DeviceStatus.STATUS_OFFLINE;

            for (EtdStatusLane laneStatus : etdStatusCurrent.llane)
            {
                addLaneToTotal(laneStatus, etdStatusCurrent);
                List<EtdInformationSection> lsectionInformation = getSectionInformationLane(etdclone.getDeviceInformation(), laneStatus.number);
                for (EtdInformationSection sectionInformation : lsectionInformation)
                {
                    EtdStatusLane sectionStatus = etdStatusCurrent.getSection(sectionInformation.number);
                    if (sectionStatus == null)
                    {
                        sectionStatus = new EtdStatusLane();
                        sectionStatus.number = sectionInformation.number;
                        sectionStatus.status = DeviceStatus.STATUS_OFFLINE;
                        etdStatusCurrent.lsection.add(sectionStatus);
                    }

                    addLaneToSection(laneStatus, sectionStatus);
                }
            }

            // Adjust Total and Sections values
            if (etdStatusCurrent.total.counting > 0)
            {
                etdStatusCurrent.total.speed = (int)(etdStatusCurrent.total.speed / etdStatusCurrent.total.counting);
                etdStatusCurrent.total.length = (etdStatusCurrent.total.length / etdStatusCurrent.total.counting);
                etdStatusCurrent.total.distance = (etdStatusCurrent.total.speed / etdStatusCurrent.total.counting);
                etdStatusCurrent.total.occupancy = (etdStatusCurrent.total.occupancy / etdStatusCurrent.total.counting);
                etdStatusCurrent.total.occupancy = NumberUtils.ajustarDecimales(etdStatusCurrent.total.occupancy, 1);
                etdStatusCurrent.total.length = NumberUtils.ajustarDecimales((float)(etdStatusCurrent.total.length/10d), 1);
                etdStatusCurrent.total.distance = NumberUtils.ajustarDecimales((float)etdStatusCurrent.total.distance, 1);
                if (etdStatusCurrent.total.occupancy > 100) etdStatusCurrent.total.occupancy = 100;
                if (etdStatusCurrent.total.occupancy < 0) etdStatusCurrent.total.occupancy = 0;
                if (etdStatusCurrent.total.length < 0) etdStatusCurrent.total.length = 0;
                if (etdStatusCurrent.total.distance < 0) etdStatusCurrent.total.distance = 0;
                if (etdStatusCurrent.total.speed < 0) etdStatusCurrent.total.speed = 0;
            }

            for (EtdStatusLane sectionStatus : etdStatusCurrent.lsection)
            {
                sectionStatus.speed = (int)(sectionStatus.speed / sectionStatus.counting);
                sectionStatus.length = (sectionStatus.length / sectionStatus.counting);
                sectionStatus.distance = (sectionStatus.speed / sectionStatus.counting);
                sectionStatus.occupancy = (sectionStatus.occupancy / sectionStatus.counting);
                sectionStatus.occupancy = NumberUtils.ajustarDecimales(sectionStatus.occupancy, 1);
                sectionStatus.length = NumberUtils.ajustarDecimales((float)(sectionStatus.length/10d), 1);
                sectionStatus.distance = NumberUtils.ajustarDecimales((float)sectionStatus.distance, 1);
                if (sectionStatus.occupancy > 100) sectionStatus.occupancy = 100;
                if (sectionStatus.occupancy < 0) sectionStatus.occupancy = 0;
                if (sectionStatus.length < 0) sectionStatus.length = 0;
                if (sectionStatus.distance < 0) sectionStatus.distance = 0;
                if (sectionStatus.speed < 0) sectionStatus.speed = 0;
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }


    private void connect()
    {
        try
        {
            if (socket != null)
            {
                if (this.connected == true)
                {
                    return;
                }
            }

            socket = new Socket(serverAddress, serverPort);
            socket.setSoTimeout(serverTimeout);
            this.connected = true;
        }
        catch (Exception e)
        {
            try{disconnect();} catch (Exception ex){};
        }
    }
    
    
    

    private void disconnect() throws ServerException, Exception
    {
        try { socket.close(); }catch (Exception e) {}
        socket = null;
        this.connected = false;
    }




    private List<EtdInformationSection> getSectionInformationLane (EtdInformation etdInformation, int lane)
    {
        List<EtdInformationSection> lresult = new ArrayList<EtdInformationSection>();

        for (EtdInformationSection sectionInformation : etdInformation.lSection)
        {
            for (Integer number : sectionInformation.llane)
            {
                if ((number.intValue()) == lane) lresult.add(sectionInformation);
            }
        }

        return(lresult);
    }


    private void addLaneToTotal (EtdStatusLane laneStatus, EtdStatus etdStatus)
    {
        etdStatus.total.totalMeasurements += 1;

        if (laneStatus.status == DeviceStatus.STATUS_ONLINE)
        {
            etdStatus.total.status = DeviceStatus.STATUS_ONLINE;
            etdStatus.total.correctMeasurements += 1;
            etdStatus.total.counting += laneStatus.counting;
            etdStatus.total.speed += (laneStatus.counting*laneStatus.speed);
            etdStatus.total.occupancy += (laneStatus.counting*laneStatus.occupancy);
            etdStatus.total.length += (laneStatus.counting*laneStatus.length);
            etdStatus.total.distance += (laneStatus.counting*laneStatus.distance);
            etdStatus.total.unclassified += laneStatus.unclassified;
            for (int i=0; i<etdStatus.total.lengths.length; i++) etdStatus.total.lengths[i] += laneStatus.lengths[i];
            for (int i=0; i<etdStatus.total.speeds.length; i++) etdStatus.total.speeds[i] += laneStatus.speeds[i];
            for (int i=0; i<etdStatus.total.speedxlength.length; i++)
            {
                for (int j=0; j<etdStatus.total.speedxlength[i].length; j++)
                    etdStatus.total.speedxlength[i][j] += laneStatus.speedxlength[i][j];
            }

            if (laneStatus.congestionDetection == true)
                etdStatus.total.congestionDetection = true;
            if (laneStatus.wrongWayVehicleDetection == true)
                etdStatus.total.wrongWayVehicleDetection = true;
        }
    }


    private void addLaneToSection (EtdStatusLane laneStatus, EtdStatusLane sectionStatus)
    {
        sectionStatus.status = DeviceStatus.STATUS_ONLINE;
        sectionStatus.correctMeasurements += 1;
        sectionStatus.totalMeasurements += 1;
        sectionStatus.counting += laneStatus.counting;
        sectionStatus.speed += (laneStatus.counting*laneStatus.speed);
        sectionStatus.occupancy += (laneStatus.counting*laneStatus.occupancy);
        sectionStatus.length += (laneStatus.counting*laneStatus.length);
        sectionStatus.distance += (laneStatus.counting*laneStatus.distance);
        sectionStatus.unclassified += laneStatus.unclassified;
        for (int i=0; i<sectionStatus.lengths.length; i++) sectionStatus.lengths[i] += laneStatus.lengths[i];
        for (int i=0; i<sectionStatus.speeds.length; i++) sectionStatus.speeds[i] += laneStatus.speeds[i];
        for (int i=0; i<sectionStatus.speedxlength.length; i++)
        {
            for (int j=0; j<sectionStatus.speedxlength[i].length; j++)
                sectionStatus.speedxlength[i][j] += laneStatus.speedxlength[i][j];
        }

        if (laneStatus.congestionDetection == true)
            sectionStatus.congestionDetection = true;
        if (laneStatus.wrongWayVehicleDetection == true)
            sectionStatus.wrongWayVehicleDetection = true;
    }


    private void emptyTotal (Etd etdclone, EtdStatus etdStatus)
    {
        etdStatus.total.totalMeasurements = 0;
        etdStatus.total.correctMeasurements = 0;
        etdStatus.total.status = DeviceStatus.STATUS_OFFLINE;
        etdStatus.total.counting = 0;
        etdStatus.total.speed = 0;
        etdStatus.total.occupancy = 0;
        etdStatus.total.length = 0;
        etdStatus.total.distance = 0;
        etdStatus.total.unclassified = 0;
        etdStatus.total.congestionDetection = false;
        etdStatus.total.wrongWayVehicleDetection = false;
        etdStatus.total.lengths = new int[etdclone.getDeviceInformation().lLengthClassification.size()];
        for (int l=0; l<etdStatus.total.lengths.length; l++)
            etdStatus.total.lengths[l] = 0;
        etdStatus.total.speeds = new int[etdclone.getDeviceInformation().lSpeedClassification.size()];
        for (int s=0; s<etdStatus.total.speeds.length; s++)
            etdStatus.total.speeds[s] = 0;
        etdStatus.total.speedxlength = new int[etdclone.getDeviceInformation().lSpeedClassification.size()][etdclone.getDeviceInformation().lLengthClassification.size()];
        for (int s=0; s<etdStatus.total.speeds.length; s++)
        {
            for (int l=0; l<etdStatus.total.lengths.length; l++)
            {
                etdStatus.total.speedxlength[s][l] = 0;
            }
        }
    }

}