package art.servers.etdserver.protocols.dgt;

import art.library.model.devices.Device;
import art.library.model.devices.DeviceStatus;
import art.library.model.devices.etd.Etd;
import art.library.model.devices.etd.EtdInformation;
import art.library.model.devices.etd.EtdStatus;
import art.library.model.devices.etd.information.EtdClassification;
import art.library.model.devices.etd.information.EtdInformationLane;
import art.library.model.devices.etd.information.EtdInformationSection;
import art.library.model.devices.etd.status.EtdStatusLane;

import art.library.utils.common.NumberUtils;
import art.library.utils.common.TimeUtils;
import art.servers.Shared;


public class EtdDgtProtocolAnalyser
{
    public EtdDgtProtocolAnalyser ()
    {
    }


    public void analyseResponseEyA (Etd device, int[] information) throws Exception
    {
        if (device.status == null)
        {
            device.status = createEtdStatus(device);
        }

        if ((device.getDeviceStatus().llane.size() != device.getDeviceInformation().lLane.size()) ||
            (device.getDeviceStatus().lsection.size() != device.getDeviceInformation().lSection.size()))
        {
            device.status = createEtdStatus(device);
        }

        int status = information[0];
        int alarms = information[1];
        int numberOfSensors = information[2];
        int[] sensorsType = new int[numberOfSensors];
        int[] sensorsAlarms = new int[numberOfSensors];
        int pointer = 3;
        EtdStatus etdStatus = device.getDeviceStatus();
        boolean existSensorAlarm = false;
        for (int i=0; i<numberOfSensors; i++)
        {
            try
            {
                sensorsType[i] = information[pointer++];
                sensorsAlarms[i] = information[pointer++];

                EtdStatusLane laneStatus = etdStatus.getLane(i+1);
                if (sensorsAlarms[i] == EtdDgtConstants.ETD_SENSOR_FAILURE)
                {
                    existSensorAlarm = true;
                    laneStatus.status = DeviceStatus.STATUS_OFFLINE;
                }
                else if (sensorsAlarms[i] == EtdDgtConstants.ETD_SENSOR_OK)
                {
                    laneStatus.status = DeviceStatus.STATUS_ONLINE;
                }
            }
            catch (Exception e)
            {
                e.printStackTrace();
                System.out.println(device.getIdentifier() + " - EyA EX: " + e.toString());
            }
        }


        if ((status & 0x01) != 0)
        {
            // AN
            device.setAlarm("alarm_offline", false);
            device.setAlarm("alarm_abnormal_state", false);
        }

        if ((status & 0x02) != 0)
        {
            // NC
            if (device.getAlarm("alarm_offline") <= 0)
            {
                device.getDeviceAlarms().clear();
            }
            device.setAlarm("alarm_offline", true);
            device.setAlarm("alarm_abnormal_state", false);
        }

        if ((status & 0x04) != 0)
        {
            // EA
            device.setAlarm("alarm_offline", false);
            device.setAlarm("alarm_abnormal_state", true);
        }

        device.setAlarm("alarm_terminal", ((alarms & 0x01) != 0));
        device.setAlarm("alarm_open_door", ((alarms & 0x02) != 0));
        device.setAlarm("alarm_mains_voltage_error", ((alarms & 0x04) != 0));
        device.setAlarm("alarm_batteries_low", ((alarms & 0x08) != 0));
        device.setAlarm("alarm_power_stopped", ((alarms & 0x10) != 0));
        device.setAlarm("alarm_batteries_disconnected", ((alarms & 0x20) != 0));
        device.setAlarm("alarm_clock_failure", ((alarms & 0x40) != 0));

        device.setAlarm("alarm_lanes", existSensorAlarm);
    }


    public void analyseResponseDUP (Etd device, int[] information) throws Exception
    {
//        if (device.status == null)
//        {
//            device.status = createEtdStatus(device);
//        }
//
//        if ((device.getDeviceStatus().llane.size() != device.getDeviceInformation().lLane.size()) ||
//            (device.getDeviceStatus().lsection.size() != device.getDeviceInformation().lSection.size()))
//        {
//            device.status = createEtdStatus(device);
//        }

        int available = information[0];

//        clearEtdStatus(device);
//        EtdStatus etdStatus = device.getDeviceStatus();

if (device.getIdentifier().equalsIgnoreCase("01etd02-a2") == true)
{
    System.out.println(Device.getDate(System.currentTimeMillis()) + " - " + device.getIdentifier() + " - Avail: " + available);
}
        if (available == EtdDgtConstants.ETD_DUP_NOT_AVAILABLE)
        {
            // TODO
            // When there is not current data 
            return;
        }

        int pointer = 1;
        int day = information[pointer++];
        int month = information[pointer++];
        int year = NumberUtils.getInt(information[pointer+1], information[pointer]);
        pointer += 2;
        int hour = information[pointer++];
        int minutes = information[pointer++];
        int seconds = information[pointer++];
        int period = NumberUtils.getInt(information[pointer+1], information[pointer]);
        pointer += 2;
        int relativeError = information[pointer++];

        long measurementTimestamp = TimeUtils.toTimestamp(day, month, year, hour, minutes, seconds);
        int numberOfSensorsClasses = information[pointer++];

        initialiseStatus(device, measurementTimestamp);
        EtdStatus etdStatus = device.getDeviceStatus();
if (device.getIdentifier().equalsIgnoreCase("01etd02-a2") == true)
{
    System.out.println(Device.getDate(System.currentTimeMillis()) + " - " + device.getIdentifier() + " - TS: " + Device.getDate(measurementTimestamp) + " - #Classes: " + numberOfSensorsClasses);
}
//        etdStatus.setMeasurementTimestamp(Device.getDate(measurementTimestamp));

        for (int i=0; i<numberOfSensorsClasses; i++)
        {
            try
            {
                int sensorClass = information[pointer++];
if (device.getIdentifier().equalsIgnoreCase("01etd02-a2") == true)
{
    System.out.println(Device.getDate(System.currentTimeMillis()) + " - " + device.getIdentifier() + " - TS: " + Device.getDate(measurementTimestamp) + " - #SensorClass: " + sensorClass);
}
                if (sensorClass == EtdDgtConstants.ETD_SENSOR_TYPE_DOUBLE)
                {
                    pointer = fillDoubleDetectors(device, etdStatus, information, pointer);
                }
                else if (sensorClass == EtdDgtConstants.ETD_SENSOR_TYPE_SIMPLE)
                {
                    pointer = fillSimpleDetectors(device, etdStatus, information, pointer);
                }
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }
        }


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

        for (EtdStatusLane sectionStatus : etdStatus.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;
        }
    }


    private int fillDoubleDetectors (Etd device, EtdStatus etdStatus, int[] information, int index) throws Exception
    {
        int pointer = index;

        try
        {
            int numberOfSensors = information[pointer++];

            for (int j=0; j<numberOfSensors; j++)
            {
                int detectorNumber = information[pointer++];
                EtdStatusLane laneStatus = etdStatus.getLane(detectorNumber);
if (device.getIdentifier().equalsIgnoreCase("01etd02-a2") == true)
{
    System.out.println(Device.getDate(System.currentTimeMillis()) + " - " + device.getIdentifier() + " - #Detector: " + detectorNumber);
}
                laneStatus.correctMeasurements = 1;
                laneStatus.counting = NumberUtils.getInt(information[pointer+1], information[pointer]);
                pointer += 2;
                laneStatus.occupancy = information[pointer++];
                laneStatus.congestionDetection = (information[pointer++]==0x01);
                laneStatus.wrongWayVehicleDetection = (information[pointer++]==0x01);
                laneStatus.direction = information[pointer++];
                laneStatus.speed = information[pointer++];
                laneStatus.length = information[pointer++];
                laneStatus.distance = information[pointer++];
                if (laneStatus.occupancy > 100) laneStatus.occupancy = 100;
                if (laneStatus.occupancy < 0) laneStatus.occupancy = 0;
                if (laneStatus.length < 0) laneStatus.length = 0;
                if (laneStatus.distance < 0) laneStatus.distance = 0;
                if (laneStatus.speed < 0) laneStatus.speed = 0;

                int numberOfClassifications = information[pointer++];
if (device.getIdentifier().equalsIgnoreCase("01etd02-a2") == true)
{
    System.out.println(Device.getDate(System.currentTimeMillis()) + " - " + device.getIdentifier() + " - #Classif: " + detectorNumber);
}
                for (int k=0; k<numberOfClassifications; k++)
                {
                    int classificationType = information[pointer++];
if (device.getIdentifier().equalsIgnoreCase("01etd02-a2") == true)
{
    System.out.println(Device.getDate(System.currentTimeMillis()) + " - " + device.getIdentifier() + " - #ClassifType: " + classificationType);
}
                    if (classificationType == EtdDgtConstants.ETD_LENGHT_CLASSIFICATION)
                    {
                        pointer = readLengthClassification(device, laneStatus, information, pointer);
                    }
                    else if (classificationType == EtdDgtConstants.ETD_SPEED_CLASSIFICATION)
                    {
                        pointer = readSpeedClassification(device, laneStatus, information, pointer);
                    }
                    else if (classificationType == EtdDgtConstants.ETD_SPEED_X_LENGTH_CLASSIFICATION)
                    {
                        pointer = readSpeedxLengthClassification(laneStatus, information, pointer);
                    }
                }

                int classified = 0;
                for (int i=0; i<laneStatus.lengths.length; i++)
                {
                    classified += laneStatus.lengths[i];
                }

                laneStatus.unclassified = laneStatus.counting - classified;
                laneStatus.correctMeasurements = 1;
                laneStatus.totalMeasurements = 1;
                laneStatus.status = DeviceStatus.STATUS_ONLINE;

                addLaneToTotal(device, laneStatus, etdStatus);
                EtdInformationSection sectionInformation = getSectionInformationLane(device.getDeviceInformation(), laneStatus.number);
                if (sectionInformation != null)
                {
                    EtdStatusLane sectionStatus = etdStatus.getSection(sectionInformation.number);
                    addLaneToSection(device, laneStatus, sectionStatus);
                }
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
            System.out.println(device.getIdentifier() + " 1.EX: " + e.toString());
        }

        return(pointer);
    }


    private EtdInformationSection getSectionInformationLane (EtdInformation etdInformation, int lane)
    {
        for (EtdInformationSection sectionInformation : etdInformation.lSection)
        {
            for (Integer number : sectionInformation.llane)
            {
                if ((number.intValue()) == lane) return(sectionInformation);
            }
        }

        return(null);
    }


    private int fillSimpleDetectors (Etd device, EtdStatus etdStatus, int[] information, int index) throws Exception
    {
        int pointer = index;

        try
        {
            int numberOfSensors = information[pointer++];

            for (int j=0; j<numberOfSensors; j++)
            {
                int detectorNumber = information[pointer++];
                EtdStatusLane laneStatus = etdStatus.getLane(detectorNumber);
                laneStatus.counting = NumberUtils.getInt(information[pointer+1], information[pointer]);
                pointer += 2;
                laneStatus.occupancy = information[pointer++];
                if (laneStatus.occupancy > 100) laneStatus.occupancy = 100;
                if (laneStatus.occupancy < 0) laneStatus.occupancy = 0;
                laneStatus.congestionDetection = (information[pointer++]==0x01);

                addLaneToTotal(device, laneStatus, etdStatus);
                EtdInformationSection sectionInformation = getSectionInformationLane(device.getDeviceInformation(), laneStatus.number);
                if (sectionInformation != null)
                {
                    EtdStatusLane sectionStatus = etdStatus.getSection(sectionInformation.number);
                    addLaneToSection(device, laneStatus, sectionStatus);
                }
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }

        return(pointer);
    }


    private void addLaneToTotal (Etd device, EtdStatusLane laneStatus, EtdStatus etdStatus)
    {
        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 (Etd device, EtdStatusLane laneStatus, EtdStatusLane sectionStatus)
    {
        sectionStatus.status = DeviceStatus.STATUS_ONLINE;
        sectionStatus.correctMeasurements += 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 int readLengthClassification (Etd device, EtdStatusLane laneStatus, int[] information, int index) throws Exception
    {
        int pointer = index;

        try
        {
            int numberOfValues = information[pointer++];
            laneStatus.lengths = new int[numberOfValues];
if (device.getIdentifier().equalsIgnoreCase("01etd02-a2") == true)
{
    System.out.println(Device.getDate(System.currentTimeMillis()) + " - " + device.getIdentifier() + " - #Lengths: " + numberOfValues);
}

            if (device.getDeviceInformation().lLengthClassification.size() == 0)
            {
                EtdInformation etdInformation = device.getDeviceInformation();
                for (int i=0; i<numberOfValues; i++)
                {
                    EtdClassification classification = new EtdClassification();
                    classification.identifier = (i+1);

                    if (numberOfValues == 2)
                    {
                        if (i == 0)
                        {
                            classification.lowerLimit = 0;
                            classification.upperLimit = 70;
                            classification.description = "Lleugers";
                        }
                        else if (i == 1)
                        {
                            classification.lowerLimit = 70;
                            classification.upperLimit = 255;
                            classification.description = "Pessats";
                        }
                    }

                    etdInformation.lLengthClassification.add(classification);
                }
            }

            for (int j=0; j<numberOfValues; j++)
            {
                laneStatus.lengths[j] = NumberUtils.getInt(information[pointer+1], information[pointer]);
if (device.getIdentifier().equalsIgnoreCase("01etd02-a2") == true)
{
    System.out.println(Device.getDate(System.currentTimeMillis()) + " - " + device.getIdentifier() + " - #Lengths[" + j + "]: " + laneStatus.lengths[j]);
}
                pointer += 2;
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }

        return(pointer);
    }


    private int readSpeedClassification (Etd device, EtdStatusLane laneStatus, int[] information, int index) throws Exception
    {
        int pointer = index;

        try
        {
            int numberOfValues = information[pointer++];
            laneStatus.speeds = new int[numberOfValues];
if (device.getIdentifier().equalsIgnoreCase("01etd02-a2") == true)
{
    System.out.println(Device.getDate(System.currentTimeMillis()) + " - " + device.getIdentifier() + " - #Speeds: " + numberOfValues + " - " + device.getDeviceInformation().lSpeedClassification.size());
}

            if (device.getDeviceInformation().lSpeedClassification.size() == 0)
            {
                EtdInformation etdInformation = device.getDeviceInformation();
                for (int i=0; i<numberOfValues; i++)
                {
                    EtdClassification classification = new EtdClassification();
                    classification.identifier = (i+1);

                    if (numberOfValues == 10)
                    {
                        if (i == 0)
                        {
                            classification.lowerLimit = 0;
                            classification.upperLimit = 40;
                            classification.description = "<40";
                        }
                        else if (i == 1)
                        {
                            classification.lowerLimit = 40;
                            classification.upperLimit = 50;
                            classification.description = "40-50";
                        }
                        else if (i == 2)
                        {
                            classification.lowerLimit = 50;
                            classification.upperLimit = 60;
                            classification.description = "50-60";
                        }
                        else if (i == 3)
                        {
                            classification.lowerLimit = 60;
                            classification.upperLimit = 70;
                            classification.description = "60-70";
                        }
                        else if (i == 4)
                        {
                            classification.lowerLimit = 70;
                            classification.upperLimit = 80;
                            classification.description = "70-80";
                        }
                        else if (i == 5)
                        {
                            classification.lowerLimit = 80;
                            classification.upperLimit = 90;
                            classification.description = "80-90";
                        }
                        else if (i == 6)
                        {
                            classification.lowerLimit = 90;
                            classification.upperLimit = 100;
                            classification.description = "90-100";
                        }
                        else if (i == 7)
                        {
                            classification.lowerLimit = 100;
                            classification.upperLimit = 110;
                            classification.description = "100-110";
                        }
                        else if (i == 8)
                        {
                            classification.lowerLimit = 110;
                            classification.upperLimit = 120;
                            classification.description = "110-120";
                        }
                        else if (i == 9)
                        {
                            classification.lowerLimit = 120;
                            classification.upperLimit = 255;
                            classification.description = ">120";
                        }
                    }

                    etdInformation.lSpeedClassification.add(classification);
                }

                device.getDeviceStatus().total.speeds = new int[device.getDeviceInformation().lSpeedClassification.size()];
                for (int s=0; s<device.getDeviceStatus().total.speeds.length; s++)
                    device.getDeviceStatus().total.speeds[s] = 0;
                device.getDeviceStatus().total.speedxlength = new int[device.getDeviceInformation().lSpeedClassification.size()][device.getDeviceInformation().lLengthClassification.size()];
                for (int s=0; s<device.getDeviceStatus().total.speeds.length; s++)
                {
                    for (int l=0; l<device.getDeviceStatus().total.lengths.length; l++)
                    {
                        device.getDeviceStatus().total.speedxlength[s][l] = 0;
                    }
                }
            }
            else if ((device.getDeviceInformation().lSpeedClassification.size() > 0) && (device.getDeviceInformation().lSpeedClassification.size() > numberOfValues))
            {
                EtdInformation etdInformation = device.getDeviceInformation();
                etdInformation.lSpeedClassification.clear();

                for (int i=0; i<numberOfValues; i++)
                {
                    EtdClassification classification = new EtdClassification();
                    classification.identifier = (i+1);

                    if (numberOfValues == 10)
                    {
                        if (i == 0)
                        {
                            classification.lowerLimit = 0;
                            classification.upperLimit = 40;
                            classification.description = "<40";
                        }
                        else if (i == 1)
                        {
                            classification.lowerLimit = 40;
                            classification.upperLimit = 50;
                            classification.description = "40-50";
                        }
                        else if (i == 2)
                        {
                            classification.lowerLimit = 50;
                            classification.upperLimit = 60;
                            classification.description = "50-60";
                        }
                        else if (i == 3)
                        {
                            classification.lowerLimit = 60;
                            classification.upperLimit = 70;
                            classification.description = "60-70";
                        }
                        else if (i == 4)
                        {
                            classification.lowerLimit = 70;
                            classification.upperLimit = 80;
                            classification.description = "70-80";
                        }
                        else if (i == 5)
                        {
                            classification.lowerLimit = 80;
                            classification.upperLimit = 90;
                            classification.description = "80-90";
                        }
                        else if (i == 6)
                        {
                            classification.lowerLimit = 90;
                            classification.upperLimit = 100;
                            classification.description = "90-100";
                        }
                        else if (i == 7)
                        {
                            classification.lowerLimit = 100;
                            classification.upperLimit = 110;
                            classification.description = "100-110";
                        }
                        else if (i == 8)
                        {
                            classification.lowerLimit = 110;
                            classification.upperLimit = 120;
                            classification.description = "110-120";
                        }
                        else if (i == 9)
                        {
                            classification.lowerLimit = 120;
                            classification.upperLimit = 255;
                            classification.description = ">120";
                        }
                    }
                    else if (numberOfValues == 3)
                    {
                        if (i == 0)
                        {
                            classification.lowerLimit = 0;
                            classification.upperLimit = 50;
                            classification.description = "<50";
                        }
                        else if (i == 1)
                        {
                            classification.lowerLimit = 50;
                            classification.upperLimit = 100;
                            classification.description = "50-100";
                        }
                        else if (i == 9)
                        {
                            classification.lowerLimit = 100;
                            classification.upperLimit = 255;
                            classification.description = ">100";
                        }
                    }

                    etdInformation.lSpeedClassification.add(classification);
                }

                device.getDeviceStatus().total.speeds = new int[device.getDeviceInformation().lSpeedClassification.size()];
                for (int s=0; s<device.getDeviceStatus().total.speeds.length; s++)
                    device.getDeviceStatus().total.speeds[s] = 0;
                device.getDeviceStatus().total.speedxlength = new int[device.getDeviceInformation().lSpeedClassification.size()][device.getDeviceInformation().lLengthClassification.size()];
                for (int s=0; s<device.getDeviceStatus().total.speeds.length; s++)
                {
                    for (int l=0; l<device.getDeviceStatus().total.lengths.length; l++)
                    {
                        device.getDeviceStatus().total.speedxlength[s][l] = 0;
                    }
                }
            }

            for (int j=0; j<numberOfValues; j++)
            {
                laneStatus.speeds[j] = NumberUtils.getInt(information[pointer+1], information[pointer]);
if (device.getIdentifier().equalsIgnoreCase("01etd02-a2") == true)
{
    System.out.println(Device.getDate(System.currentTimeMillis()) + " - " + device.getIdentifier() + " - #Speeds[" + j + "]: " + laneStatus.speeds[j]);
}
                pointer += 2;
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }

        return(pointer);
    }


    private int readSpeedxLengthClassification (EtdStatusLane laneStatus, int[] information, int index) throws Exception
    {
        int pointer = index;

        try
        {
            int numberOfValues = information[pointer++];
            if (numberOfValues != (laneStatus.lengths.length*laneStatus.speeds.length))
            {
                throw new Exception(Shared.getMessage("Number of Speed x Length categories not correct: ") + numberOfValues + " - " + laneStatus.lengths.length + " * " + laneStatus.speeds.length);
            }

            laneStatus.speedxlength = new int[laneStatus.speeds.length][];
            for (int j=0; j<laneStatus.speeds.length; j++)
            {
                laneStatus.speedxlength[j] = new int[laneStatus.lengths.length];
                for (int k=0; k<laneStatus.lengths.length; k++)
                {
                    laneStatus.speedxlength[j][k] = NumberUtils.getInt(information[pointer+1], information[pointer]);
                    pointer += 2;
                }
            }


            // Read Average speed by length
            int numberOfSpeeds = information[pointer++];
            for (int i=0; i<numberOfSpeeds; i++)
            {
                int value = information[pointer++];
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }

        return(pointer);
    }


    private void initialiseStatus (Etd deviceclone, long tsperiod)
    {
        if (deviceclone.getDeviceStatus() == null)
        {
            deviceclone.status = new EtdStatus();
            for (EtdInformationLane laneInformation : deviceclone.getDeviceInformation().lLane)
            {
                EtdStatusLane laneStatus = new EtdStatusLane();
                laneStatus.number = laneInformation.number;
                laneStatus.correctMeasurements = 1;
                laneStatus.totalMeasurements = 1;
                deviceclone.getDeviceStatus().llane.add(laneStatus);
            }

            for (EtdInformationSection sectionInformation : deviceclone.getDeviceInformation().lSection)
            {
                EtdStatusLane sectionStatus = new EtdStatusLane();
                sectionStatus.number = sectionInformation.number;
                sectionStatus.correctMeasurements = 0;
                sectionStatus.totalMeasurements = 0;
                deviceclone.getDeviceStatus().lsection.add(sectionStatus);
            }

            deviceclone.getDeviceStatus().total = new EtdStatusLane();
        }

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

        deviceclone.getDeviceStatus().llane.clear();
        deviceclone.getDeviceStatus().lsection.clear();
        for (EtdInformationLane laneInformation : deviceclone.getDeviceInformation().lLane)
        {
            EtdStatusLane laneStatus = new EtdStatusLane();
            laneStatus.number = laneInformation.number;
            laneStatus.status = DeviceStatus.STATUS_OFFLINE;
            laneStatus.totalMeasurements = 0;
            laneStatus.correctMeasurements = 0;
            laneStatus.lengths = new int[deviceclone.getDeviceInformation().lLengthClassification.size()];
            for (int l=0; l<laneStatus.lengths.length; l++)
                laneStatus.lengths[l] = 0;
            laneStatus.speeds = new int[deviceclone.getDeviceInformation().lSpeedClassification.size()];
            for (int s=0; s<laneStatus.speeds.length; s++)
                laneStatus.speeds[s] = 0;
            laneStatus.speedxlength = new int[deviceclone.getDeviceInformation().lSpeedClassification.size()][deviceclone.getDeviceInformation().lLengthClassification.size()];
            for (int s=0; s<laneStatus.speeds.length; s++)
            {
                for (int l=0; l<laneStatus.lengths.length; l++)
                {
                    laneStatus.speedxlength[s][l] = 0;
                }
            }
            deviceclone.getDeviceStatus().llane.add(laneStatus);
        }

        for (EtdInformationSection sectionInformation : deviceclone.getDeviceInformation().lSection)
        {
            EtdStatusLane sectionStatus = new EtdStatusLane();
            sectionStatus.number = sectionInformation.number;
            sectionStatus.status = DeviceStatus.STATUS_OFFLINE;
            sectionStatus.totalMeasurements = sectionInformation.llane.size();
            sectionStatus.correctMeasurements = 0;
            sectionStatus.lengths = new int[deviceclone.getDeviceInformation().lLengthClassification.size()];
            for (int l=0; l<sectionStatus.lengths.length; l++)
                sectionStatus.lengths[l] = 0;
            sectionStatus.speeds = new int[deviceclone.getDeviceInformation().lSpeedClassification.size()];
            for (int s=0; s<sectionStatus.speeds.length; s++)
                sectionStatus.speeds[s] = 0;
            sectionStatus.speedxlength = new int[deviceclone.getDeviceInformation().lSpeedClassification.size()][deviceclone.getDeviceInformation().lLengthClassification.size()];
            for (int s=0; s<sectionStatus.speeds.length; s++)
            {
                for (int l=0; l<sectionStatus.lengths.length; l++)
                {
                    sectionStatus.speedxlength[s][l] = 0;
                }
            }
            deviceclone.getDeviceStatus().lsection.add(sectionStatus);
        }

        deviceclone.getDeviceStatus().total.status = DeviceStatus.STATUS_OFFLINE;
        deviceclone.getDeviceStatus().total.correctMeasurements = 0;
        deviceclone.getDeviceStatus().total.totalMeasurements = deviceclone.getDeviceInformation().lLane.size();
        deviceclone.getDeviceStatus().total.counting = 0;
        deviceclone.getDeviceStatus().total.distance = 0;
        deviceclone.getDeviceStatus().total.length = 0;
        deviceclone.getDeviceStatus().total.occupancy = 0;
        deviceclone.getDeviceStatus().total.speed = 0;
        deviceclone.getDeviceStatus().total.unclassified = 0;
        deviceclone.getDeviceStatus().total.wrongWayVehicleDetection = false;
        deviceclone.getDeviceStatus().total.congestionDetection = false;
        deviceclone.getDeviceStatus().total.lengths = new int[deviceclone.getDeviceInformation().lLengthClassification.size()];
        for (int l=0; l<deviceclone.getDeviceStatus().total.lengths.length; l++)
            deviceclone.getDeviceStatus().total.lengths[l] = 0;
        deviceclone.getDeviceStatus().total.speeds = new int[deviceclone.getDeviceInformation().lSpeedClassification.size()];
        for (int s=0; s<deviceclone.getDeviceStatus().total.speeds.length; s++)
            deviceclone.getDeviceStatus().total.speeds[s] = 0;
        deviceclone.getDeviceStatus().total.speedxlength = new int[deviceclone.getDeviceInformation().lSpeedClassification.size()][deviceclone.getDeviceInformation().lLengthClassification.size()];
        for (int s=0; s<deviceclone.getDeviceStatus().total.speeds.length; s++)
        {
            for (int l=0; l<deviceclone.getDeviceStatus().total.lengths.length; l++)
            {
                deviceclone.getDeviceStatus().total.speedxlength[s][l] = 0;
            }
        }

        deviceclone.getDeviceStatus().period = deviceclone.getDeviceInformation().period;
        deviceclone.getDeviceStatus().setMeasurementTimestamp(Device.getDate(tsperiod));
    }


    private EtdStatus createEtdStatus (Etd device) throws Exception
    {
        try
        {
            EtdStatus status = new EtdStatus();
            status.period = device.getDeviceInformation().period;
            status.setMeasurementTimestamp(Device.getDate(TimeUtils.thisperiod(device.getDeviceInformation().period)));
            status.total = new EtdStatusLane();
            for (EtdInformationLane laneInformation : device.getDeviceInformation().lLane)
            {
                EtdStatusLane laneStatus = new EtdStatusLane();
                laneStatus.number = laneInformation.number;
                status.llane.add(laneStatus);
            }

            for (EtdInformationSection sectionInformation : device.getDeviceInformation().lSection)
            {
                EtdStatusLane laneStatus = new EtdStatusLane();
                laneStatus.number = sectionInformation.number;
                status.lsection.add(laneStatus);
            }

            return(status);
        }
        catch (Exception e)
        {
            throw e;
        }
    }


    private void clearEtdStatus (Etd device) throws Exception
    {
        try
        {
            EtdStatus etdStatus = device.getDeviceStatus();
            etdStatus.period = device.getDeviceInformation().period;
            etdStatus.setMeasurementTimestamp(Device.getDate(TimeUtils.thisperiod(device.getDeviceInformation().period)));

            clearEtdStatusLane(device, etdStatus.total);
            etdStatus.total.totalMeasurements = device.getDeviceInformation().lLane.size();

            for (EtdStatusLane laneStatus : device.getDeviceStatus().llane)
            {
                clearEtdStatusLane(device, laneStatus);
                laneStatus.totalMeasurements = 1;
            }

            for (EtdStatusLane sectionStatus : device.getDeviceStatus().lsection)
            {
                clearEtdStatusLane(device, sectionStatus);
                sectionStatus.totalMeasurements = device.getDeviceInformation().getSection(sectionStatus.number).llane.size();
            }
        }
        catch (Exception e)
        {
            throw e;
        }
    }


    private void clearEtdStatusLane (Etd device, EtdStatusLane laneStatus)
    {
        laneStatus.congestionDetection = false;
        laneStatus.correctMeasurements = 0;
        laneStatus.counting = 0;
        laneStatus.direction = EtdStatusLane.ETD_STATUS_DIRECTION_UNKNOWN;
        laneStatus.distance = 0;
        laneStatus.length = 0;
        laneStatus.lengths = new int[device.getDeviceInformation().lLengthClassification.size()];
        laneStatus.occupancy = 0;
        laneStatus.speed = 0;
        laneStatus.speeds = new int[device.getDeviceInformation().lSpeedClassification.size()];
        laneStatus.speedxlength = new int[device.getDeviceInformation().lSpeedClassification.size()][];
        for (int i=0; i<laneStatus.speedxlength.length; i++)
        {
            laneStatus.speedxlength[i] = new int[device.getDeviceInformation().lLengthClassification.size()];
        }

        laneStatus.totalMeasurements = 0;
        laneStatus.unclassified = 0;
        laneStatus.wrongWayVehicleDetection = false;
    }

}