package art.servers.asfserver.protocols.dgt;

import art.library.model.devices.DeviceStatus;
import art.library.model.devices.vms.asf.Asf;
import art.library.model.devices.vms.asf.AsfStatus;
import art.library.model.devices.vms.asf.information.AsfInformationConfigurationAddressState;
import art.library.model.devices.vms.general.VmsGeneral;
import art.library.model.devices.vms.general.VmsGeneralStatus;
import art.library.utils.common.ArrayUtils;
import art.library.utils.common.NumberUtils;
import art.servers.Shared;
import art.servers.asfserver.types.VmsGraphic;
import java.awt.Color;

public class AsfDgtProtocolAnalyser
{

    public AsfDgtProtocolAnalyser()
    {
    }

    public static void analyseResponseReset(int[] information) throws Exception
    {
        checkAck(information);
    }

    public static void analyseResponseTimeout(int[] information) throws Exception
    {
        checkAck(information);
    }

    public static void analyseResponseMPP(Asf deviceclone, int[] information) throws Exception
    {
        checkAck(information);
    }

    public static void analyseResponseMEP(Asf deviceclone, int[] information) throws Exception
    {
        int state = information[0];

        switch (state)
        {

            case AsfDgtConstants.ASF_OFF:
                deviceclone.getDeviceStatus().state = AsfStatus.STATE_OFF;
                break;

            case AsfDgtConstants.ASF_FIX:
                analyseFixState(deviceclone, information, 1);
                break;
            default:
                throw new Exception("Invalid operation");
        }
    }

    public static void analyseResponseEyA(Asf deviceclone, int[] information) throws Exception
    {
        int status = information[0];
        int brightness = information[1];
        int technology = information[2];
        int activeAlarms1 = information[3];
        int activeAlarms2 = information[4];
        int activeAlarms3 = information[5];
        int activeAlarms4 = information[6];

        if (brightness >= 0x30)
        {
            brightness = brightness - 0x30;
        }
        deviceclone.getDeviceStatus().brightnessLevel = AsfDgtProtocolConstructor.getBrightnessClientLevel(brightness, 100, deviceclone.getDeviceInformation().maximumBrightnessLevel);

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

        if ((status & 0x02) != 0)
        {
            // NC
            deviceclone.setAlarm("alarm_offline", true);
            deviceclone.setAlarm("alarm_abnormal_state", false);
        }

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

        deviceclone.setAlarm("alarm_open_door", ((activeAlarms1 & 0x01) != 0));
        deviceclone.setAlarm("alarm_configuration", ((activeAlarms1 & 0x02) != 0));
        deviceclone.setAlarm("alarm_terminal", ((activeAlarms1 & 0x04) != 0));
        deviceclone.setAlarm("alarm_ventilation_on", ((activeAlarms1 & 0x08) != 0));
        deviceclone.setAlarm("alarm_ventilation_failure", ((activeAlarms1 & 0x10) != 0));
        deviceclone.setAlarm("alarm_hardware_error", ((activeAlarms1 & 0x20) != 0));
        deviceclone.setAlarm("alarm_temperature_high", ((activeAlarms1 & 0x80) != 0));

        deviceclone.setAlarm("alarm_temperature_exceeded", ((activeAlarms2 & 0x01) != 0));
        deviceclone.setAlarm("alarm_mains_voltage_error", ((activeAlarms2 & 0x02) != 0));
        deviceclone.setAlarm("alarm_batteries_degraded", ((activeAlarms2 & 0x04) != 0));
        deviceclone.setAlarm("alarm_power_stopped", ((activeAlarms2 & 0x08) != 0));
        deviceclone.setAlarm("alarm_batteries_low", ((activeAlarms2 & 0x10) != 0));
        deviceclone.setAlarm("alarm_batteries_disconnected", ((activeAlarms2 & 0x20) != 0));
        deviceclone.setAlarm("alarm_heating_on", ((activeAlarms2 & 0x40) != 0));
        deviceclone.setAlarm("alarm_batteries_not_totally_charged", ((activeAlarms2 & 0x80) != 0));

        deviceclone.setAlarm("alarm_red_power_failure", ((activeAlarms3 & 0x01) != 0));
        deviceclone.setAlarm("alarm_green_power_failure", ((activeAlarms3 & 0x02) != 0));
        deviceclone.setAlarm("alarm_blue_power_failure", ((activeAlarms3 & 0x04) != 0));
        deviceclone.setAlarm("alarm_yellow_power_failure", ((activeAlarms3 & 0x08) != 0));
        deviceclone.setAlarm("alarm_white_power_failure", ((activeAlarms3 & 0x10) != 0));
        deviceclone.setAlarm("alarm_led_failure", ((activeAlarms3 & 0x20) != 0));

        deviceclone.setAlarm("alarm_power_failure", ((activeAlarms4 & 0x01) != 0));
        deviceclone.setAlarm("alarm_photocell_failure", ((activeAlarms4 & 0x08) != 0));
        deviceclone.setAlarm("alarm_power_contactor_failure", ((activeAlarms4 & 0x10) != 0));
        deviceclone.setAlarm("alarm_start_delay_condensation", ((activeAlarms4 & 0x20) != 0));
        deviceclone.setAlarm("alarm_humidity_sensor_failure", ((activeAlarms4 & 0x40) != 0));
    }

    public static void analyseResponseEP(Asf deviceclone, int[] information) throws Exception
    {
        int state = information[0];

        if (state == AsfDgtConstants.ASF_OFF)
        {
            deviceclone.getDeviceStatus().state = AsfStatus.STATE_OFF;
            return;
        }

        switch (state)
        {
            case AsfDgtConstants.ASF_FIX:
                analyseFixState(deviceclone, information, 1);
                break;
            case AsfDgtConstants.ASF_ALTERNANT:
            case AsfDgtConstants.ASF_SEQUENCE:
                throw new Exception("Operation not supported");
            default:
                throw new Exception("Invalid operation");
        }
    }

    public static void analyseResponsePP(Asf deviceclone, int[] information) throws Exception
    {
        int numberParameters = information[0];
        int pointer = 1;
        for (int i = 0; i < numberParameters; i++)
        {
            int parameterType = information[pointer++];
            switch (parameterType)
            {
                case AsfDgtConstants.ASF_BRIGHTNESS_PARAMETER:
                {
                    int brightnessMode = information[pointer++];
                    if (brightnessMode == 'A')
                    {
                        deviceclone.getDeviceStatus().brightnessMode = VmsGeneralStatus.BRIGHTNESS_MODE_AUTO;
                    } else
                    {
                        deviceclone.getDeviceStatus().brightnessMode = VmsGeneralStatus.BRIGHTNESS_MODE_MANUAL;
                    }
                }
                break;

                case AsfDgtConstants.ASF_ALTERNANCE_TIME_PARAMETER:
                {
                    int alternatingTime = information[pointer++];
                }
                break;

                case AsfDgtConstants.ASF_BLINK_TIMES_PARAMETER:
                {
                    deviceclone.getDeviceStatus().blinkOn = (float) ((float) information[pointer++] / 10f);
                    deviceclone.getDeviceStatus().blinkOff = (float) ((float) information[pointer++] / 10f);
                }
                break;
            }
        }
    }

    public static void getPixelsGraphic(VmsGeneral deviceclone, VmsGraphic graphic)
    {
        try
        {
            int pointer = 0;
            int height = graphic.graphicContent[pointer++];
            int width = graphic.graphicContent[pointer++];

            if ((height == 0) && (width == 0))
            {
                // Not exist the graphic in Vms memory
                // Return byte[0] and generate a black image
                return;
            }

            if ((height == 78) && (width == 32))
            {
                height = 32;
            }

            int initialRow = graphic.graphicContent[pointer++];
            int initialColumn = graphic.graphicContent[pointer++];
            int colorAreas = graphic.graphicContent[pointer++];
            int groupRows = height / 8;
            boolean[] green = new boolean[height * width];
            boolean[] red = new boolean[height * width];
            boolean[] blue = new boolean[height * width];

            for (int i = 0; i < height * width; i++)
            {
                green[i] = false;
                red[i] = false;
                blue[i] = false;
            }

            int pos = pointer;
            int maxPosPixel = 0;

            if (colorAreas > 0)
            {
                // GREEN

                for (int i = 0; i < groupRows; i++)
                {
                    for (int j = 0; j < width; j++)
                    {
                        byte byteCol = (byte) graphic.graphicContent[i * (width) + j + pos];
                        for (int k = 7; k >= 0; k--)
                        {
                            int bit = k;

                            int mask = (int) (java.lang.Math.pow(2.0, (double) bit));

                            int posPixel = (i * (8 * width)) + ((7 - k) * (width)) + j;

                            if (posPixel > maxPosPixel)
                            {
                                maxPosPixel = posPixel;
                            }
                            int value = byteCol & mask;
                            if (value != 0)
                            {
                                green[posPixel] = true;
                            }
                        }
                    }
                }

                pos = pos + (groupRows * width);
            }

            if (colorAreas > 1)
            {
                // RED

                for (int i = 0; i < groupRows; i++)
                {
                    for (int j = 0; j < width; j++)
                    {
                        byte byteCol = (byte) graphic.graphicContent[i * (width) + j + pos];

                        for (int k = 7; k >= 0; k--)
                        {
                            int bit = k;

                            int mask = (int) (java.lang.Math.pow(2.0, (double) bit));

                            int posPixel = (i * (8 * width)) + ((7 - k) * (width)) + j;

                            if (posPixel > maxPosPixel)
                            {
                                maxPosPixel = posPixel;
                            }
                            int value = byteCol & mask;
                            if (value != 0)
                            {
                                red[posPixel] = true;
                            }
                        }
                    }
                }

                pos = pos + (groupRows * width);
            }

            if (colorAreas > 2)
            {
                // BLUE

                for (int i = 0; i < groupRows; i++)
                {
                    for (int j = 0; j < width; j++)
                    {
                        byte byteCol = (byte) graphic.graphicContent[i * (width) + j + pos];

                        for (int k = 7; k >= 0; k--)
                        {
                            int bit = k;

                            int mask = (int) (java.lang.Math.pow(2.0, (double) bit));

                            int posPixel = (i * (8 * width)) + ((7 - k) * (width)) + j;

                            if (posPixel > maxPosPixel)
                            {
                                maxPosPixel = posPixel;
                            }
                            int value = byteCol & mask;
                            if (value != 0)
                            {
                                blue[posPixel] = true;
                            }
                        }
                    }
                }

                pos = pos + (groupRows * width);
            }

            graphic.pixels = new int[height * width];
            for (int i = 0; i < height * width; i++)
            {
                if (colorAreas >= 3)
                {
                    graphic.pixels[i] = getPixelColor(green[i], red[i], blue[i]);
                } else
                {
                    graphic.pixels[i] = getPixelColor(green[i], red[i]);
                }
            }

        } catch (Exception e)
        {

        }
    }

    private static void checkAck(int[] information) throws Exception
    {
        if (ArrayUtils.isNullOrEmpty(information) || information[0] != AsfDgtConstants.ASF_ACK)
        {
            throw new Exception("No ack received");
        }
    }

    private static void analyseFixState(Asf deviceclone, int[] information, int index) throws Exception
    {
        NumberUtils.AsciiToInt(information[index++]); //Topology
        int numberOfSubpanels = NumberUtils.AsciiToInt(information[index++]);
        int memory = -1;
        boolean blinking = false;

        for (int i = 0; i < numberOfSubpanels; i++)
        {
            int subpanel = NumberUtils.AsciiToInt(information[index++]);

            if (subpanel == 1)
            {
                int contentType = NumberUtils.AsciiToInt(information[index++]);
                if (contentType == 1)
                {
                    // Graphic memory content
                    memory = information[index++];
                    //Blinking
                    blinking = (information[index++] == (int) 'S');
                } else
                {
                    throw new Exception("Not valid content");
                }
            } else
            {
                throw new Exception("Not valid content");
            }
        }

        AsfStatus asfStatus = deviceclone.getDeviceStatus();

        AsfInformationConfigurationAddressState addressState = deviceclone.getDeviceInformation().configuration.getByAddressBlinking(memory, blinking);
        if (addressState == null || addressState.state < 0)
        {
            throw new Exception("Invalid address state");
        }

        asfStatus.state = addressState.state;
    }

    private static int getPixelColor(boolean green, boolean red, boolean blue)
    {
        try
        {
            if ((green == true) && (red == true) && (blue == true))
            {
                return (Color.WHITE.getRGB());
            }
            if ((green == true) && (red == true) && (blue == false))
            {
                return (Color.YELLOW.getRGB());
            }
            if ((green == false) && (red == true) && (blue == false))
            {
                return (Color.RED.getRGB());
            }
            if ((green == true) && (red == false) && (blue == false))
            {
                return (Color.GREEN.getRGB());
            }
            if ((green == false) && (red == false) && (blue == true))
            {
                return (Color.BLUE.getRGB());
            }
            if ((green == false) && (red == true) && (blue == true))
            {
                return (Color.MAGENTA.getRGB());
            }
            if ((green == true) && (red == false) && (blue == true))
            {
                return (Color.CYAN.getRGB());
            }
        } catch (Exception e)
        {
        }

        return (Color.BLACK.getRGB());
    }

    private static int getPixelColor(boolean green, boolean red)
    {
        try
        {
            if ((green == true) && (red == true))
            {
                return (Color.YELLOW.getRGB());
            }
            if ((green == false) && (red == true))
            {
                return (Color.RED.getRGB());
            }
            if ((green == true) && (red == false))
            {
                return (Color.GREEN.getRGB());
            }
        } catch (Exception e)
        {
        }

        return (Color.BLACK.getRGB());
    }

}