package art.servers.etdserver.protocols.skp3;

import art.library.model.devices.Device;
import art.library.model.devices.etd.Etd;
import art.library.model.devices.etd.EtdAlarms;
import art.library.model.devices.etd.EtdInformation;
import art.library.model.devices.etd.EtdStatus;
import art.library.model.devices.etd.status.EtdStatusLane;
import art.servers.etdserver.Shared;
import java.util.HashMap;


public class SKP3_ProtocolAnalyser
{
    public static final int MASK_CHAR = 0x7D;
    public static final int FLAG_CHAR = 0x7E;


    public static int[] getData(int[] command)
    {
        int[] result = new int[command.length-3];
        System.arraycopy(command, 1, result, 0, result.length);
        return(unapplyMask(result));
    }


    public static int[] unapplyMask(int[] command)
    {
        try
        {
            int newLength = 0;
            for (int i=0; i<command.length; i++)
            {
                if (command[i] == MASK_CHAR)
                    newLength--;
                newLength++;
            }

            int[] result = new int[newLength];
            int index = 0;
            result[index++] = command[0];
            for (int i=1; i<command.length-1; i++)
            {
                if (command[i] == MASK_CHAR)
                {
                    if (command[i+1] == 0x5D)
                        result[index++] = MASK_CHAR;
                    else if (command[i+1] == 0x5E)
                        result[index++] = FLAG_CHAR;
                    i++;
                }
                else
                {
                    result[index++] = command[i];
                }
            }

            result[index++] = command[command.length-1];
            return(result);
        }
        catch (Exception e)
        {
            return(command);
        }
    }


    public static int[] createMessage(int[] command, int crc)
    {
        int[] result = new int[command.length + 3];
        int index = 0;
        result[index++] = FLAG_CHAR;
        for (int i=0; i<command.length; i++)
        {
            result[index++] = command[i];
        }

        result[index++] = crc;
        result[index++] = FLAG_CHAR;
        return(result);
    }


    public static int crc(int[] command)
    {
        int crc = 0;
        for (int i=0; i<command.length; i++)
        {
            crc += command[i];
        }

        return(crc%256);
    }


    public static int analyseReadSerialNumberResponse(SKP3_Message message) throws Exception
    {
        message.reset();
        message.check();

        int serialNumber = message.readShortHigh();
        return(serialNumber);
    }


    public static void analyseReadStatusResponse(Etd etd, SKP3_Message message) throws Exception
    {
        message.reset();
        message.check();

        int serial = message.readShortHigh();
        if (etd.getDeviceInformation().serialNumber.equalsIgnoreCase(""+serial) == false)
        {
            throw new Exception(Shared.getMessage("Message serial number incorrect"));
        }

        int commandCode = message.readByte();
        if (commandCode != SKP3_ProtocolWriter.READ_STATUS_CONTROLLER_RESPONSE)
        {
            throw new Exception(Shared.getMessage("Message answer code does not correspond to command"));
        }


        // Analyse received errors codes
        int errorCount = message.readByte();
        HashMap<String, String> hactiveAlarms = new HashMap<String, String>();

        for (int i=0; i<errorCount; i++)
        {
            try
            {
                // errorCfg = Error CFG code
                int errorCfg = message.readShortHigh();

                // error = Error code inside Error CFG code
                int error = message.readShortHigh();

                switch (errorCfg)
                {
                    case SKP3_ProtocolWriter.ERROR_CFG_EXTERNAL_MEMORY:
                    {
                        switch (error)
                        {
                            case SKP3_ProtocolWriter.ALARM_CFG_EXTERNAL_MEMORY_READ_ERROR:
                            {
                                etd.setAlarm("alarm_reading_error_memory", true);
                                hactiveAlarms.putIfAbsent("alarm_reading_error_memory", "alarm_reading_error_memory");
                            }
                            break;
                        }
                    }
                    break;

                    case SKP3_ProtocolWriter.ERROR_CFG_RAM:
                    {
                        switch (error)
                        {
                            case SKP3_ProtocolWriter.ALARM_CFG_RAM_UNINITIALISED:
                            {
                                etd.setAlarm("alarm_ram_uninitialized", true);
                                hactiveAlarms.putIfAbsent("alarm_ram_uninitialized", "alarm_ram_uninitialized");
                            }
                            break;
                            case SKP3_ProtocolWriter.ALARM_CFG_RAM_SHORTCIRCUIT_DATA:
                            {
                                etd.setAlarm("alarm_ram_short_circuit_data", true);
                                hactiveAlarms.putIfAbsent("alarm_ram_short_circuit_data", "alarm_ram_short_circuit_data");
                            }
                            break;
                            case SKP3_ProtocolWriter.ALARM_CFG_RAM_SHORTCIRCUIT_ADDRESS:
                            {
                                etd.setAlarm("alarm_ram_short_circuit_address", true);
                                hactiveAlarms.putIfAbsent("alarm_ram_short_circuit_address", "alarm_ram_short_circuit_address");
                            }
                            break;
                        }
                    }
                    break;

                    case SKP3_ProtocolWriter.ERROR_CFG_FLASH:
                    {
                        switch (error)
                        {
                            case SKP3_ProtocolWriter.ALARM_CFG_FLASH_UNINITIALISED:
                            {
                                etd.setAlarm("alarm_flash_uninitialized", true);
                                hactiveAlarms.putIfAbsent("alarm_flash_uninitialized", "alarm_flash_uninitialized");
                            }
                            break;
                            case SKP3_ProtocolWriter.ALARM_CFG_FLASH_LACK_COMMS:
                            {
                                etd.setAlarm("alarm_flash_lack_communication", true);
                                hactiveAlarms.putIfAbsent("alarm_flash_lack_communication", "alarm_flash_lack_communication");
                            }
                            break;
                            case SKP3_ProtocolWriter.ALARM_CFG_FLASH_MODEL_ERROR:
                            {
                                etd.setAlarm("alarm_flash_model_error", true);
                                hactiveAlarms.putIfAbsent("alarm_flash_model_error", "alarm_flash_model_error");
                            }
                            break;
                        }
                    }
                    break;

                    case SKP3_ProtocolWriter.ERROR_CFG_FRAM:
                    {
                        switch (error)
                        {
                            case SKP3_ProtocolWriter.ALARM_CFG_FRAM_UNINITIALISED:
                            {
                                etd.setAlarm("alarm_fram_uninitialized", true);
                                hactiveAlarms.putIfAbsent("alarm_fram_uninitialized", "alarm_fram_uninitialized");
                            }
                            break;
                            case SKP3_ProtocolWriter.ALARM_CFG_FRAM_LACK_COMMS:
                            {
                                etd.setAlarm("alarm_fram_lack_communication", true);
                                hactiveAlarms.putIfAbsent("alarm_fram_lack_communication", "alarm_fram_lack_communication");
                            }
                            break;
                        }
                    }
                    break;

                    case SKP3_ProtocolWriter.ERROR_CFG_RTC:
                    {
                        switch (error)
                        {
                            case SKP3_ProtocolWriter.ALARM_CFG_RTC_UNINITIALISED:
                            {
                                etd.setAlarm("alarm_rtc_uninitialized", true);
                                hactiveAlarms.putIfAbsent("alarm_rtc_uninitialized", "alarm_rtc_uninitialized");
                            }
                            break;
                            case SKP3_ProtocolWriter.ALARM_CFG_RTC_LACK_COMMS:
                            {
                                etd.setAlarm("alarm_rtc_lack_communication", true);
                                hactiveAlarms.putIfAbsent("alarm_rtc_lack_communication", "alarm_rtc_lack_communication");
                            }
                            break;
                        }
                    }
                    break;

                    case SKP3_ProtocolWriter.ERROR_CFG_WIZNET:
                    {
                        switch (error)
                        {
                            case SKP3_ProtocolWriter.ALARM_CFG_WIZNET_UNINITIALISED:
                            {
                                etd.setAlarm("alarm_wiznet_uninitialized", true);
                                hactiveAlarms.putIfAbsent("alarm_wiznet_uninitialized", "alarm_wiznet_uninitialized");
                            }
                            break;
                            case SKP3_ProtocolWriter.ALARM_CFG_WIZNET_NO_COMMS:
                            {
                                etd.setAlarm("alarm_wiznet_no_communication", true);
                                hactiveAlarms.putIfAbsent("alarm_wiznet_no_communication", "alarm_wiznet_no_communication");
                            }
                            break;
                        }
                    }
                    break;

                    case SKP3_ProtocolWriter.ERROR_CFG_CPLD_HW:
                    {
                        switch (error)
                        {
                            case SKP3_ProtocolWriter.ALARM_CFG_CPLD_HW_UNKNOWN_ERROR:
                            {
                                etd.setAlarm("alarm_cpld_hw_unknown_error", true);
                                hactiveAlarms.putIfAbsent("alarm_cpld_hw_unknown_error", "alarm_cpld_hw_unknown_error");
                            }
                            break;
                            case SKP3_ProtocolWriter.ALARM_CFG_CPLD_HW_WRITE_ERROR:
                            {
                                etd.setAlarm("alarm_cpld_hw_write_error", true);
                                hactiveAlarms.putIfAbsent("alarm_cpld_hw_write_error", "alarm_cpld_hw_write_error");
                            }
                            break;
                            case SKP3_ProtocolWriter.ALARM_CFG_CPLD_HW_LIMIT_EXCEEDED:
                            {
                                etd.setAlarm("alarm_cpld_hw_exceeded_limit", true);
                                hactiveAlarms.putIfAbsent("alarm_cpld_hw_exceeded_limit", "alarm_cpld_hw_exceeded_limit");
                            }
                            break;
                            case SKP3_ProtocolWriter.ALARM_CFG_CPLD_HW_UNKNOWN_COMMAND:
                            {
                                etd.setAlarm("alarm_cpld_hw_unknown_command", true);
                                hactiveAlarms.putIfAbsent("alarm_cpld_hw_unknown_command", "alarm_cpld_hw_unknown_command");
                            }
                            break;
                            case SKP3_ProtocolWriter.ALARM_CFG_CPLD_HW_UNKNOWN_STATE:
                            {
                                etd.setAlarm("alarm_cpld_hw_unknown_state", true);
                                hactiveAlarms.putIfAbsent("alarm_cpld_hw_unknown_state", "alarm_cpld_hw_unknown_state");
                            }
                            break;
                            case SKP3_ProtocolWriter.ALARM_CFG_CPLD_HW_OVERFLOW:
                            {
                                etd.setAlarm("alarm_cpld_hw_overflow", true);
                                hactiveAlarms.putIfAbsent("alarm_cpld_hw_overflow", "alarm_cpld_hw_overflow");
                            }
                            break;
                            case SKP3_ProtocolWriter.ALARM_CFG_CPLD_HW_LACK_BUFFER_SPACE1:
                            {
                                etd.setAlarm("alarm_cpld_hw_lack_buffer_space", true);
                                hactiveAlarms.putIfAbsent("alarm_cpld_hw_lack_buffer_space", "alarm_cpld_hw_lack_buffer_space");
                            }
                            break;
                            case SKP3_ProtocolWriter.ALARM_CFG_CPLD_HW_LACK_BUFFER_SPACE2:
                            {
                                etd.setAlarm("alarm_cpld_hw_lack_buffer_space", true);
                                hactiveAlarms.putIfAbsent("alarm_cpld_hw_lack_buffer_space", "alarm_cpld_hw_lack_buffer_space");
                            }
                            break;
                        }
                    }
                    break;

                    case SKP3_ProtocolWriter.ERROR_CFG_CPLD_SW:
                    {
                        switch (error)
                        {
                            case SKP3_ProtocolWriter.ALARM_CFG_CPLD_SW_UNKNOWN_ERROR:
                            {
                                etd.setAlarm("alarm_cpld_sw_unknown_error", true);
                                hactiveAlarms.putIfAbsent("alarm_cpld_sw_unknown_error", "alarm_cpld_sw_unknown_error");
                            }
                            break;
                            case SKP3_ProtocolWriter.ALARM_CFG_CPLD_SW_WRITE_ERROR:
                            {
                                etd.setAlarm("alarm_cpld_sw_write_error", true);
                                hactiveAlarms.putIfAbsent("alarm_cpld_sw_write_error", "alarm_cpld_sw_write_error");
                            }
                            break;
                            case SKP3_ProtocolWriter.ALARM_CFG_CPLD_SW_LIMIT_EXCEEDED:
                            {
                                etd.setAlarm("alarm_cpld_sw_exceeded_limit", true);
                                hactiveAlarms.putIfAbsent("alarm_cpld_sw_exceeded_limit", "alarm_cpld_sw_exceeded_limit");
                            }
                            break;
                            case SKP3_ProtocolWriter.ALARM_CFG_CPLD_SW_UNKNOWN_COMMAND:
                            {
                                etd.setAlarm("alarm_cpld_sw_unknown_command", true);
                                hactiveAlarms.putIfAbsent("alarm_cpld_sw_unknown_command", "alarm_cpld_sw_unknown_command");
                            }
                            break;
                            case SKP3_ProtocolWriter.ALARM_CFG_CPLD_SW_UNKNOWN_STATE:
                            {
                                etd.setAlarm("alarm_cpld_sw_unknown_state", true);
                                hactiveAlarms.putIfAbsent("alarm_cpld_sw_unknown_state", "alarm_cpld_sw_unknown_state");
                            }
                            break;
                            case SKP3_ProtocolWriter.ALARM_CFG_CPLD_SW_OVERFLOW:
                            {
                                etd.setAlarm("alarm_cpld_sw_overflow", true);
                                hactiveAlarms.putIfAbsent("alarm_cpld_sw_overflow", "alarm_cpld_sw_overflow");
                            }
                            break;
                            case SKP3_ProtocolWriter.ALARM_CFG_CPLD_SW_LACK_BUFFER_SPACE1:
                            {
                                etd.setAlarm("alarm_cpld_sw_lack_buffer_space", true);
                                hactiveAlarms.putIfAbsent("alarm_cpld_sw_lack_buffer_space", "alarm_cpld_sw_lack_buffer_space");
                            }
                            break;
                            case SKP3_ProtocolWriter.ALARM_CFG_CPLD_SW_LACK_BUFFER_SPACE2:
                            {
                                etd.setAlarm("alarm_cpld_sw_lack_buffer_space", true);
                                hactiveAlarms.putIfAbsent("alarm_cpld_sw_lack_buffer_space", "alarm_cpld_sw_lack_buffer_space");
                            }
                            break;
                        }
                    }
                    break;
                }
            }
            catch (Exception e)
            {
                
            }
        }


        EtdAlarms alarms = etd.getDeviceAlarms();

        if (hactiveAlarms.containsKey("alarm_reading_error_memory") == false)
        {
            etd.setAlarm("alarm_reading_error_memory", false);
        }

        if (hactiveAlarms.containsKey("alarm_ram_uninitialized") == false)
        {
            etd.setAlarm("alarm_ram_uninitialized", false);
        }

        if (hactiveAlarms.containsKey("alarm_ram_short_circuit_data") == false)
        {
            etd.setAlarm("alarm_ram_short_circuit_data", false);
        }

        if (hactiveAlarms.containsKey("alarm_ram_short_circuit_address") == false)
        {
            etd.setAlarm("alarm_ram_short_circuit_address", false);
        }

        if (hactiveAlarms.containsKey("alarm_flash_uninitialized") == false)
        {
            etd.setAlarm("alarm_flash_uninitialized", false);
        }

        if (hactiveAlarms.containsKey("alarm_flash_lack_communication") == false)
        {
            etd.setAlarm("alarm_flash_lack_communication", false);
        }

        if (hactiveAlarms.containsKey("alarm_flash_model_error") == false)
        {
            etd.setAlarm("alarm_flash_model_error", false);
        }

        if (hactiveAlarms.containsKey("alarm_fram_uninitialized") == false)
        {
            etd.setAlarm("alarm_fram_uninitialized", false);
        }

        if (hactiveAlarms.containsKey("alarm_fram_lack_communication") == false)
        {
            etd.setAlarm("alarm_fram_lack_communication", false);
        }

        if (hactiveAlarms.containsKey("alarm_rtc_uninitialized") == false)
        {
            etd.setAlarm("alarm_rtc_uninitialized", false);
        }

        if (hactiveAlarms.containsKey("alarm_rtc_lack_communication") == false)
        {
            etd.setAlarm("alarm_rtc_lack_communication", false);
        }

        if (hactiveAlarms.containsKey("alarm_wiznet_uninitialized") == false)
        {
            etd.setAlarm("alarm_wiznet_uninitialized", false);
        }

        if (hactiveAlarms.containsKey("alarm_wiznet_no_communication") == false)
        {
            etd.setAlarm("alarm_wiznet_no_communication", false);
        }

        if (hactiveAlarms.containsKey("alarm_cpld_hw_unknown_error") == false)
        {
            etd.setAlarm("alarm_cpld_hw_unknown_error", false);
        }

        if (hactiveAlarms.containsKey("alarm_cpld_hw_write_error") == false)
        {
            etd.setAlarm("alarm_cpld_hw_write_error", false);
        }

        if (hactiveAlarms.containsKey("alarm_cpld_hw_exceeded_limit") == false)
        {
            etd.setAlarm("alarm_cpld_hw_exceeded_limit", false);
        }

        if (hactiveAlarms.containsKey("alarm_cpld_hw_unknown_command") == false)
        {
            etd.setAlarm("alarm_cpld_hw_unknown_command", false);
        }

        if (hactiveAlarms.containsKey("alarm_cpld_hw_unknown_state") == false)
        {
            etd.setAlarm("alarm_cpld_hw_unknown_state", false);
        }

        if (hactiveAlarms.containsKey("alarm_cpld_hw_overflow") == false)
        {
            etd.setAlarm("alarm_cpld_hw_overflow", false);
        }

        if (hactiveAlarms.containsKey("alarm_cpld_hw_lack_buffer_space") == false)
        {
            etd.setAlarm("alarm_cpld_hw_lack_buffer_space", false);
        }

        if (hactiveAlarms.containsKey("alarm_cpld_sw_unknown_error") == false)
        {
            etd.setAlarm("alarm_cpld_sw_unknown_error", false);
        }

        if (hactiveAlarms.containsKey("alarm_cpld_sw_write_error") == false)
        {
            etd.setAlarm("alarm_cpld_sw_write_error", false);
        }

        if (hactiveAlarms.containsKey("alarm_cpld_sw_exceeded_limit") == false)
        {
            etd.setAlarm("alarm_cpld_sw_exceeded_limit", false);
        }

        if (hactiveAlarms.containsKey("alarm_cpld_sw_unknown_command") == false)
        {
            etd.setAlarm("alarm_cpld_sw_unknown_command", false);
        }

        if (hactiveAlarms.containsKey("alarm_cpld_sw_unknown_state") == false)
        {
            etd.setAlarm("alarm_cpld_sw_unknown_state", false);
        }

        if (hactiveAlarms.containsKey("alarm_cpld_sw_overflow") == false)
        {
            etd.setAlarm("alarm_cpld_sw_overflow", false);
        }

        if (hactiveAlarms.containsKey("alarm_cpld_sw_lack_buffer_space") == false)
        {
            etd.setAlarm("alarm_cpld_sw_lack_buffer_space", false);
        }

        if (hactiveAlarms.containsKey("alarm_lanes") == false)
        {
            etd.setAlarm("alarm_lanes", false);
        }
    }


    public static void analyseReadCurrentTrafficDataPeriodResponse(Etd etd, SKP3_Message message) throws Exception
    {
        message.reset();
        message.check();

        int serial = message.readShortHigh();
        if (etd.getDeviceInformation().serialNumber.equalsIgnoreCase(""+serial) == false)
        {
            throw new Exception(Shared.getMessage("Message serial number incorrect"));
        }

        int commandCode = message.readByte();
        if (commandCode != SKP3_ProtocolWriter.READ_DATA_RESPONSE)
        {
            throw new Exception(Shared.getMessage("Message answer code does not correspond to command"));
        }

        int version = message.readByte();
        int cfg = message.readByte();
        int stationId = message.readShortHigh();
        int ts = message.readIntHigh();
        long timestamp = (long)(ts * 1000L);
        int idsCount = message.readByte();
        EtdStatus status = etd.getDeviceStatus();
        status.period = etd.getDeviceInformation().period;
        EtdInformation information = etd.getDeviceInformation();
        long lastTimestamp = Device.getTimestamp(status.getMeasurementTimestamp());

        status.setMeasurementTimestamp(Device.getDate(timestamp));
        Shared.println(etd.information.name, "1.Timestamp Period: " + status.getMeasurementTimestamp());

        if (status.llane.size() < information.lLane.size())
        {
            for (int i=status.llane.size(); i<information.lLane.size(); i++)
            {
                EtdStatusLane laneStatus = new EtdStatusLane();
                laneStatus.number = information.lLane.get(i).number;
                laneStatus.totalMeasurements = 1;
                laneStatus.correctMeasurements = 1;
                laneStatus.lengths = new int[information.lLengthClassification.size()];
                laneStatus.speeds = new int[information.lSpeedClassification.size()];
                laneStatus.speedxlength = new int[information.lSpeedClassification.size()][information.lLengthClassification.size()];
                status.llane.add(laneStatus);
            }
        }
        else if (status.llane.size() > information.lLane.size())
        {
            for (int i=status.llane.size()-1; i>=information.lLane.size(); i--)
            {
                status.llane.remove(status.llane.size()-1);
            }
        }

        for (int i=0; i<status.llane.size(); i++)
        {
            EtdStatusLane laneStatus = status.llane.get(i);
            laneStatus.totalMeasurements = 1;
            laneStatus.correctMeasurements = 1;
            if ((laneStatus.lengths.length != information.lLengthClassification.size()) || (laneStatus.speeds.length != information.lSpeedClassification.size()))
                laneStatus.speedxlength = new int[information.lSpeedClassification.size()][information.lLengthClassification.size()];
            if (laneStatus.lengths.length != information.lLengthClassification.size())
                laneStatus.lengths = new int[information.lLengthClassification.size()];
            if (laneStatus.speeds.length != information.lSpeedClassification.size())
                laneStatus.speeds = new int[information.lSpeedClassification.size()];

            for (int j=0; j<laneStatus.lengths.length; j++)
                laneStatus.lengths[j] = 0;
            for (int j=0; j<laneStatus.speeds.length; j++)
                laneStatus.speeds[j] = 0;
            for (int j=0; j<laneStatus.speedxlength.length; j++)
            {
                for (int k=0; k<laneStatus.speedxlength[j].length; k++)
                    laneStatus.speedxlength[j][k] = 0;
            }

            laneStatus.counting = 0;
            laneStatus.unclassified = 0;
            laneStatus.occupancy = 0;
            laneStatus.speed = 0;
        }


        if (status.lsection.size() < information.lSection.size())
        {
            for (int i=status.lsection.size(); i<information.lSection.size(); i++)
            {
                EtdStatusLane sectionStatus = new EtdStatusLane();
                sectionStatus.number = information.lSection.get(i).number;
                sectionStatus.lengths = new int[information.lLengthClassification.size()];
                sectionStatus.speeds = new int[information.lSpeedClassification.size()];
                sectionStatus.speedxlength = new int[information.lSpeedClassification.size()][information.lLengthClassification.size()];
                status.lsection.add(sectionStatus);
            }
        }
        else if (status.lsection.size() > information.lSection.size())
        {
            for (int i=status.lsection.size()-1; i>=information.lSection.size(); i--)
            {
                status.lsection.remove(status.lsection.size()-1);
            }
        }

        for (int i=0; i<status.lsection.size(); i++)
        {
            EtdStatusLane sectionStatus = status.lsection.get(i);
            if ((sectionStatus.lengths.length != information.lLengthClassification.size()) || (sectionStatus.speeds.length != information.lSpeedClassification.size()))
                sectionStatus.speedxlength = new int[information.lSpeedClassification.size()][information.lLengthClassification.size()];
            if (sectionStatus.lengths.length != information.lLengthClassification.size())
                sectionStatus.lengths = new int[information.lLengthClassification.size()];
            if (sectionStatus.speeds.length != information.lSpeedClassification.size())
                sectionStatus.speeds = new int[information.lSpeedClassification.size()];

            for (int j=0; j<sectionStatus.lengths.length; j++)
                sectionStatus.lengths[j] = 0;
            for (int j=0; j<sectionStatus.speeds.length; j++)
                sectionStatus.speeds[j] = 0;
            for (int j=0; j<sectionStatus.speedxlength.length; j++)
            {
                for (int k=0; k<sectionStatus.speedxlength[j].length; k++)
                    sectionStatus.speedxlength[j][k] = 0;
            }

            sectionStatus.counting = 0;
            sectionStatus.unclassified = 0;
            sectionStatus.occupancy = 0;
            sectionStatus.speed = 0;
        }

        status.total = new EtdStatusLane();
        status.total.number = 0;
        status.total.totalMeasurements = information.lLane.size();
        status.total.correctMeasurements = information.lLane.size();
        status.total.lengths = new int[information.lLengthClassification.size()];
        status.total.speeds = new int[information.lSpeedClassification.size()];
        status.total.speedxlength = new int[information.lSpeedClassification.size()][information.lLengthClassification.size()];
        for (int j=0; j<status.total.lengths.length; j++)
            status.total.lengths[j] = 0;
        for (int j=0; j<status.total.speeds.length; j++)
            status.total.speeds[j] = 0;
        for (int j=0; j<status.total.speedxlength.length; j++)
        {
            for (int k=0; k<status.total.speedxlength[j].length; k++)
                status.total.speedxlength[j][k] = 0;
        }

        status.total.counting = 0;
        status.total.unclassified = 0;
        status.total.occupancy = 0;
        status.total.speed = 0;

        Shared.println(etd.information.name, "2.Ids Count: " + idsCount);

        for (int i=0; i<idsCount; i++)
        {
            SKP3_TrafficData data = new SKP3_TrafficData();
            data.identifier = message.readShortHigh();
            int aux = message.readByte();
            data.cfg = (aux >> 4) & 0x0F;
            data.value = message.readShortHigh();
            data.value = data.value + ((aux & 0x0F) << 16);

            try
            {
                switch (data.identifier)
                {
                    case SKP3_ProtocolWriter.DATA_ID_TOTAL_L1:
                    {
                        status.llane.get(0).counting = (int)data.getValue();
                    }
                    break;
                    case SKP3_ProtocolWriter.DATA_ID_TOTAL_L2:
                    {
                        status.llane.get(1).counting = (int)data.getValue();
                    }
                    break;
                    case SKP3_ProtocolWriter.DATA_ID_AVG_SPEED_L1:
                    {
                        status.llane.get(0).speed = data.getValue();
                    }
                    break;
                    case SKP3_ProtocolWriter.DATA_ID_AVG_SPEED_L2:
                    {
                        status.llane.get(1).speed = data.getValue();
                    }
                    break;
                    case SKP3_ProtocolWriter.DATA_ID_K1_L1:
                    {
                        status.llane.get(0).lengths[0] += (int)data.getValue();
                    }
                    break;
                    case SKP3_ProtocolWriter.DATA_ID_K2_L1:
                    {
                        status.llane.get(0).lengths[0] += (int)data.getValue();
                    }
                    break;
                    case SKP3_ProtocolWriter.DATA_ID_K3_L1:
                    {
                        status.llane.get(0).lengths[1] += (int)data.getValue();
                    }
                    break;
                    case SKP3_ProtocolWriter.DATA_ID_K1_L2:
                    {
                        status.llane.get(1).lengths[0] += (int)data.getValue();
                    }
                    break;
                    case SKP3_ProtocolWriter.DATA_ID_K2_L2:
                    {
                        status.llane.get(1).lengths[0] += (int)data.getValue();
                    }
                    break;
                    case SKP3_ProtocolWriter.DATA_ID_K3_L2:
                    {
                        status.llane.get(1).lengths[1] += (int)data.getValue();
                    }
                    break;
                    case SKP3_ProtocolWriter.DATA_ID_30_L1:
                    {
                        status.llane.get(0).speeds[0] = (int)data.getValue();
                    }
                    break;
                    case SKP3_ProtocolWriter.DATA_ID_30_40_L1:
                    {
                        status.llane.get(0).speeds[1] = (int)data.getValue();
                    }
                    break;
                    case SKP3_ProtocolWriter.DATA_ID_40_50_L1:
                    {
                        status.llane.get(0).speeds[2] = (int)data.getValue();
                    }
                    break;
                    case SKP3_ProtocolWriter.DATA_ID_50_60_L1:
                    {
                        status.llane.get(0).speeds[3] = (int)data.getValue();
                    }
                    break;
                    case SKP3_ProtocolWriter.DATA_ID_60_70_L1:
                    {
                        status.llane.get(0).speeds[4] = (int)data.getValue();
                    }
                    break;
                    case SKP3_ProtocolWriter.DATA_ID_70_80_L1:
                    {
                        status.llane.get(0).speeds[5] = (int)data.getValue();
                    }
                    break;
                    case SKP3_ProtocolWriter.DATA_ID_80_90_L1:
                    {
                        status.llane.get(0).speeds[6] = (int)data.getValue();
                    }
                    break;
                    case SKP3_ProtocolWriter.DATA_ID_90_100_L1:
                    {
                        status.llane.get(0).speeds[7] = (int)data.getValue();
                    }
                    break;
                    case SKP3_ProtocolWriter.DATA_ID_100_110_L1:
                    {
                        status.llane.get(0).speeds[8] = (int)data.getValue();
                    }
                    break;
                    case SKP3_ProtocolWriter.DATA_ID_110_120_L1:
                    {
                        status.llane.get(0).speeds[9] = (int)data.getValue();
                    }
                    break;
                    case SKP3_ProtocolWriter.DATA_ID_120_130_L1:
                    {
                        status.llane.get(0).speeds[10] = (int)data.getValue();
                    }
                    break;
                    case SKP3_ProtocolWriter.DATA_ID_130_140_L1:
                    {
                        status.llane.get(0).speeds[11] = (int)data.getValue();
                    }
                    break;
                    case SKP3_ProtocolWriter.DATA_ID_140_150_L1:
                    {
                        status.llane.get(0).speeds[12] = (int)data.getValue();
                    }
                    break;
                    case SKP3_ProtocolWriter.DATA_ID_150_160_L1:
                    {
                        status.llane.get(0).speeds[13] = (int)data.getValue();
                    }
                    break;
                    case SKP3_ProtocolWriter.DATA_ID_160_170_L1:
                    {
                        status.llane.get(0).speeds[14] = (int)data.getValue();
                    }
                    break;
                    case SKP3_ProtocolWriter.DATA_ID_170_180_L1:
                    {
                        status.llane.get(0).speeds[15] = (int)data.getValue();
                    }
                    break;
                    case SKP3_ProtocolWriter.DATA_ID_180_L1:
                    {
                        status.llane.get(0).speeds[16] = (int)data.getValue();
                    }
                    break;
                    case SKP3_ProtocolWriter.DATA_ID_30_L2:
                    {
                        status.llane.get(1).speeds[0] = (int)data.getValue();
                    }
                    break;
                    case SKP3_ProtocolWriter.DATA_ID_30_40_L2:
                    {
                        status.llane.get(1).speeds[1] = (int)data.getValue();
                    }
                    break;
                    case SKP3_ProtocolWriter.DATA_ID_40_50_L2:
                    {
                        status.llane.get(1).speeds[2] = (int)data.getValue();
                    }
                    break;
                    case SKP3_ProtocolWriter.DATA_ID_50_60_L2:
                    {
                        status.llane.get(1).speeds[3] = (int)data.getValue();
                    }
                    break;
                    case SKP3_ProtocolWriter.DATA_ID_60_70_L2:
                    {
                        status.llane.get(1).speeds[4] = (int)data.getValue();
                    }
                    break;
                    case SKP3_ProtocolWriter.DATA_ID_70_80_L2:
                    {
                        status.llane.get(1).speeds[5] = (int)data.getValue();
                    }
                    break;
                    case SKP3_ProtocolWriter.DATA_ID_80_90_L2:
                    {
                        status.llane.get(1).speeds[6] = (int)data.getValue();
                    }
                    break;
                    case SKP3_ProtocolWriter.DATA_ID_90_100_L2:
                    {
                        status.llane.get(1).speeds[7] = (int)data.getValue();
                    }
                    break;
                    case SKP3_ProtocolWriter.DATA_ID_100_110_L2:
                    {
                        status.llane.get(1).speeds[8] = (int)data.getValue();
                    }
                    break;
                    case SKP3_ProtocolWriter.DATA_ID_110_120_L2:
                    {
                        status.llane.get(1).speeds[9] = (int)data.getValue();
                    }
                    break;
                    case SKP3_ProtocolWriter.DATA_ID_120_130_L2:
                    {
                        status.llane.get(1).speeds[10] = (int)data.getValue();
                    }
                    break;
                    case SKP3_ProtocolWriter.DATA_ID_130_140_L2:
                    {
                        status.llane.get(1).speeds[11] = (int)data.getValue();
                    }
                    break;
                    case SKP3_ProtocolWriter.DATA_ID_140_150_L2:
                    {
                        status.llane.get(1).speeds[12] = (int)data.getValue();
                    }
                    break;
                    case SKP3_ProtocolWriter.DATA_ID_150_160_L2:
                    {
                        status.llane.get(1).speeds[13] = (int)data.getValue();
                    }
                    break;
                    case SKP3_ProtocolWriter.DATA_ID_160_170_L2:
                    {
                        status.llane.get(1).speeds[14] = (int)data.getValue();
                    }
                    break;
                    case SKP3_ProtocolWriter.DATA_ID_170_180_L2:
                    {
                        status.llane.get(1).speeds[15] = (int)data.getValue();
                    }
                    break;
                    case SKP3_ProtocolWriter.DATA_ID_180_L2:
                    {
                        status.llane.get(1).speeds[16] = (int)data.getValue();
                    }
                    break;
                }
            }
            catch (Exception e)
            {
                
            }
        }

        try
        {
            for (EtdStatusLane laneStatus : status.llane)
            {
                int classified = 0;
                for (int i=0; i<laneStatus.lengths.length; i++)
                {
                    classified += laneStatus.lengths[i];
                }

                laneStatus.unclassified = laneStatus.counting - classified;
                if (laneStatus.unclassified < 0) laneStatus.unclassified = 0;
            }
        }
        catch (Exception e)
        {
            
        }

        Shared.setSectionsData(etd);
        Shared.setTotalData(etd);


        // Fill maxSpeed, overspeedCars, heavyTrucks
        int speedLimit = etd.getDeviceInformation().speedLimit;
        if (speedLimit <= 0)
        {
            speedLimit = getSpeedLimit(etd.getIdentifier());
        }

        for (int l=0; l<status.llane.size(); l++)
        {
            EtdStatusLane laneStatus = status.llane.get(l);
            int totalTrucksLane = 0;
            int totalVehiclesLane = laneStatus.counting;
            for (int j=0; j<laneStatus.lengths.length; j++)
            {
                if (laneStatus.lengths.length <= 2)
                {
                    if (j == 1) totalTrucksLane += laneStatus.lengths[j];
                }
                else if (laneStatus.lengths.length >= 7)
                {
                    if ((j == 3) || (j == 4) || (j == 5)) totalTrucksLane += laneStatus.lengths[j];
                }
            }

            laneStatus.overspeedCars = 0;
            for (int k=0; k<laneStatus.speeds.length; k++)
            {
                if (laneStatus.speeds[k] > 0)
                {
                    laneStatus.maxSpeed = (double)((double)etd.getDeviceInformation().lSpeedClassification.get(k).upperLimit + (double)etd.getDeviceInformation().lSpeedClassification.get(k).lowerLimit) / 2d;

                    if (etd.getDeviceInformation().lSpeedClassification.get(k).lowerLimit >= speedLimit)
                    {
                        laneStatus.overspeedCars += laneStatus.speeds[k];
                    }
                }
            }

            if (totalVehiclesLane > 0)
            {
                laneStatus.heavyTrucks = (float)((float)totalTrucksLane / (float)totalVehiclesLane) * 100f;
                int heavyTrucks = (int)(laneStatus.heavyTrucks*100f);
                laneStatus.heavyTrucks = (float)((float)heavyTrucks / 100f);
            }

            if (laneStatus.maxSpeed > 0)
            {
                int maxSpeed = (int)(laneStatus.maxSpeed*100d);
                laneStatus.maxSpeed = (double)((double)maxSpeed / 100d);
            }
        }

        for (int s=0; s<status.lsection.size(); s++)
        {
            EtdStatusLane sectionStatus = status.lsection.get(s);
            int totalTrucksLane = 0;
            int totalVehiclesLane = sectionStatus.counting;
            for (int j=0; j<sectionStatus.lengths.length; j++)
            {
                if (sectionStatus.lengths.length <= 2)
                {
                    if (j == 1) totalTrucksLane += sectionStatus.lengths[j];
                }
                else if (sectionStatus.lengths.length >= 7)
                {
                    if ((j == 3) || (j == 4) || (j == 5)) totalTrucksLane += sectionStatus.lengths[j];
                }
            }

            sectionStatus.overspeedCars = 0;
            for (int k=0; k<sectionStatus.speeds.length; k++)
            {
                if (sectionStatus.speeds[k] > 0)
                {
                    sectionStatus.maxSpeed = (double)((double)etd.getDeviceInformation().lSpeedClassification.get(k).upperLimit + (double)etd.getDeviceInformation().lSpeedClassification.get(k).lowerLimit) / 2d;

                    if (etd.getDeviceInformation().lSpeedClassification.get(k).lowerLimit >= speedLimit)
                    {
                        sectionStatus.overspeedCars += sectionStatus.speeds[k];
                    }
                }
            }

            if (totalVehiclesLane > 0)
            {
                sectionStatus.heavyTrucks = (float)((float)totalTrucksLane / (float)totalVehiclesLane) * 100f;
                int heavyTrucks = (int)(sectionStatus.heavyTrucks*100f);
                sectionStatus.heavyTrucks = (float)((float)heavyTrucks / 100f);
            }

            if (sectionStatus.maxSpeed > 0)
            {
                int maxSpeed = (int)(sectionStatus.maxSpeed*100d);
                sectionStatus.maxSpeed = (double)((double)maxSpeed / 100d);
            }
        }


        EtdStatusLane totalStatus = status.total;
        int totalTrucksLane = 0;
        int totalVehiclesLane = totalStatus.counting;
        for (int j=0; j<totalStatus.lengths.length; j++)
        {
            if (totalStatus.lengths.length <= 2)
            {
                if (j == 1) totalTrucksLane += totalStatus.lengths[j];
            }
            else if (totalStatus.lengths.length >= 7)
            {
                if ((j == 3) || (j == 4) || (j == 5)) totalTrucksLane += totalStatus.lengths[j];
            }
        }

        totalStatus.overspeedCars = 0;
        for (int k=0; k<totalStatus.speeds.length; k++)
        {
            if (totalStatus.speeds[k] > 0)
            {
                totalStatus.maxSpeed = (double)((double)etd.getDeviceInformation().lSpeedClassification.get(k).upperLimit + (double)etd.getDeviceInformation().lSpeedClassification.get(k).lowerLimit) / 2d;

                if (etd.getDeviceInformation().lSpeedClassification.get(k).lowerLimit >= speedLimit)
                {
                    totalStatus.overspeedCars += totalStatus.speeds[k];
                }
            }
        }

        if (totalVehiclesLane > 0)
        {
            totalStatus.heavyTrucks = (float)((float)totalTrucksLane / (float)totalVehiclesLane) * 100f;
            int heavyTrucks = (int)(totalStatus.heavyTrucks*100f);
            totalStatus.heavyTrucks = (float)((float)heavyTrucks / 100f);
        }

        if (totalStatus.maxSpeed > 0)
        {
            int maxSpeed = (int)(totalStatus.maxSpeed*100d);
            totalStatus.maxSpeed = (double)((double)maxSpeed / 100d);
        }
    }




    private static int getSpeedLimit(String etdIdentifier)
    {
        try
        {
            if (etdIdentifier.equalsIgnoreCase("etd-krzewica-1")) return(90);
            if (etdIdentifier.equalsIgnoreCase("etd-terespol-1")) return(90);
            if (etdIdentifier.equalsIgnoreCase("etd-wólkaokopska-1")) return(70);
            if (etdIdentifier.equalsIgnoreCase("etd-żyrzyn-1")) return(70);
            if (etdIdentifier.equalsIgnoreCase("etd-piaski-1")) return(50);
            if (etdIdentifier.equalsIgnoreCase("etd-łopienniknadrzeczny-1")) return(50);
            if (etdIdentifier.equalsIgnoreCase("etd-izbica-1")) return(50);
            if (etdIdentifier.equalsIgnoreCase("etd-łabuniereforma-1")) return(50);
            if (etdIdentifier.equalsIgnoreCase("etd-polanówka-1")) return(50);
            if (etdIdentifier.equalsIgnoreCase("etd-hrebenne-1")) return(70);
            if (etdIdentifier.equalsIgnoreCase("etd-międzyrzecpodlaski-1")) return(100);
            if (etdIdentifier.equalsIgnoreCase("etd-radzyńpodlaski-1")) return(90);
            if (etdIdentifier.equalsIgnoreCase("etd-sobieszyn-1")) return(70);
            if (etdIdentifier.equalsIgnoreCase("etd-annopol-1")) return(70);
            if (etdIdentifier.equalsIgnoreCase("etd-szczebrzeszyn-1")) return(70);
            if (etdIdentifier.equalsIgnoreCase("etd-miączyn-1")) return(70);
            if (etdIdentifier.equalsIgnoreCase("etd-łęczna-1")) return(70);
            if (etdIdentifier.equalsIgnoreCase("etd-włodawa-1")) return(50);
            if (etdIdentifier.equalsIgnoreCase("etd-wisznice-1")) return(70);
            if (etdIdentifier.equalsIgnoreCase("etd-sławatycze-1")) return(50);
            if (etdIdentifier.equalsIgnoreCase("etd-staraprawda-1")) return(60);
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }

        return(70);
    }

}