package art.servers.lighting.lightstudsserver.controller;

import art.library.interop.InteropParameters;
import art.library.interop.serialization.Serialization;
import art.library.interop.serialization.SerializationException;
import art.library.model.devices.DeviceAction;
import art.library.model.devices.DeviceActionResult;
import art.library.model.devices.DeviceStatus;
import art.library.model.devices.lighting.lightstuds.LightStuds;
import art.library.model.devices.lighting.lightstuds.LightStudsCommands;
import art.library.model.devices.lighting.lightstuds.alarms.LightStudsAlarms_BUSVAO;
import art.library.model.devices.lighting.lightstuds.commands.LightStudsCommands_BUSVAO_Circuit;
import art.library.model.devices.lighting.lightstuds.information.LightStudsInformation_BUSVAO_Circuit;
import art.library.model.devices.lighting.lightstuds.status.LightStudsStatus_BUSVAO;
import art.library.model.devices.lighting.lightstuds.status.LightStudsStatus_BUSVAO_Circuit;
import art.library.model.devices.lighting.lightstuds.status.LightStudsStatus_BUSVAO_Circuit_Order;
import art.library.model.devices.signalsboard.information.SignalInformation;
import art.library.model.devices.signalsboard.information.SignalInformation_MODBUSTCP;
import art.library.model.devices.signalsboard.information.SignalsInformation_MODBUSTCP;
import art.library.net.modbus.ReaderModbus;
import art.library.net.modbus.WriterModbus;
import art.library.utils.synchro.Mutex;
import art.servers.ServerException;
import art.servers.Shared;
import art.servers.lighting.lightstudsserver.configuration.Configuration;
import art.servers.lighting.lightstudsserver.configuration.ConfigurationDetail;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;


public class ControllerLigthStuds_BUSVAO extends ControllerLigthStuds
{
    private String name = null;
    private Mutex mutex = new Mutex();


    public ControllerLigthStuds_BUSVAO(LightStuds studs)
    {
        super(studs);
        this.name = Shared.getMessage("Controller light studs") + " " + studs.toString();
        this.setName(name);
    }
    
    
    
    
    public void run()
    {
        Shared.traceInformation(name, "Starting");

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

            try
            {
                if (art.servers.Shared.isServerEnabled() == true)
                {
                    update();
                }
            }
            catch (Exception e)
            {
            }

            // Wait
            
            long timetowait = (device.getDeviceInformation().BUSVAO.polling * 1000) - (System.currentTimeMillis() - startTimestamp);
            timetowait = Math.min(timetowait, (device.getDeviceInformation().BUSVAO.polling));

            if (timetowait > 0)
            {
                try
                {
                    sleep(timetowait);
                }
                catch (Exception e)
                {
                }
            }
            else
            {
                try{sleep(50);} catch (Exception e){};
            }

            if (Shared.model.existsDevice(device.getIdentifier()) == false)
            {
                Shared.println(name, Shared.getMessage("Device no longer exists"));
                exit = true;
            }
        }

        Shared.traceInformation(name, "Finishing");
    }



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


    public DeviceAction[] sendCommands(InteropParameters parameters) throws ServerException, SerializationException, Exception
    {
        try
        {
            List<DeviceAction> result = new ArrayList<DeviceAction>();

            LightStudsCommands commands = parameters.getBodyContentValue(LightStudsCommands.class);
            Shared.println(name, "\r\n\r\n" + Serialization.toPrettyString(commands));
            LightStuds clone = Serialization.clone(device);

            if ((commands.busvao != null) && (commands.busvao.circuits != null))
            {
                for (LightStudsCommands_BUSVAO_Circuit circuitCommand : commands.busvao.circuits)
                {
                    result.add(sendCommand(parameters, clone, circuitCommand));
                }

                Shared.model.updateDevice(device, clone); 

                // Return result

                return result.toArray(new DeviceAction[result.size()]);
            }

            return result.toArray(new DeviceAction[0]);
        }
        catch (ServerException e)
        {
            Shared.printstack(name, e);
            throw e;
        }
        catch (SerializationException e)
        {
            Shared.printstack(name, e);
            throw e;
        }
        catch (Exception e)
        {
            Shared.printstack(name, e);
            throw e;
        }
    }
    
    
    
    
    private DeviceAction sendCommand(InteropParameters parameters, LightStuds device, LightStudsCommands_BUSVAO_Circuit command)
    {
        String language = (String)parameters.getParameter("language").getValue();
        WriterModbus writer = null;
        DeviceAction action = new DeviceAction(device, parameters, command);
        action.actionName = command.getActionName();
        
        try
        {
            ConfigurationDetail detail = ((Configuration)Shared.configuration).detail;

            Shared.println(name, "1.SendCommand: C" + command.number + " - L" + command.brightnessLevel);
            SignalsInformation_MODBUSTCP signals = (SignalsInformation_MODBUSTCP)device.getDeviceInformation().BUSVAO.signals;
            Shared.println(name, "2.SendCommand: C" + command.number + " - L" + command.brightnessLevel + " - Signals null: " + (signals==null));
            writer = new WriterModbus(signals.address, signals.port, signals.timeout, signals.retries);
            Shared.println(name, "3.SendCommand: C" + command.number + " - L" + command.brightnessLevel + " - " + signals.address + ":" + signals.port + " - " + signals.timeout + " - " + signals.retries);

            if (command.brightnessLevel == 0)
            {
                SignalInformation_MODBUSTCP signalCircuit = (SignalInformation_MODBUSTCP)device.getDeviceInformation().BUSVAO.signals.getOutput("circuit " + command.number);
                SignalInformation_MODBUSTCP signalOn = (SignalInformation_MODBUSTCP)device.getDeviceInformation().BUSVAO.signals.getOutput("on");
                SignalInformation_MODBUSTCP signalOff = (SignalInformation_MODBUSTCP)device.getDeviceInformation().BUSVAO.signals.getOutput("off");
                if ((signalCircuit.address == signalOn.address) && (signalOn.address == signalOff.address))
                {
                    int value = 0;
                    value += (int)Math.pow(2, signalOff.bit);
                    value += (int)Math.pow(2, signalCircuit.bit);
                    write(writer, signalOff, value);
                }
                else if ((signalCircuit.address != signalOn.address) && (signalOn.address == signalOff.address))
                {
                    int value = 0;
                    value += (int)Math.pow(2, signalOff.bit);
                    write(writer, signalOff, value);
                    value = 0;
                    value += (int)Math.pow(2, signalCircuit.bit);
                    write(writer, signalCircuit, value);
                }
                else
                {
                    write(writer, "circuit " + command.number, 0);
                    sleep(detail.timeBetweenOrders);
                    write(writer, "on", 0);
                    sleep(detail.timeBetweenOrders);
                    write(writer, "off", 1);
                }

                LightStudsStatus_BUSVAO_Circuit circuitStatus = (LightStudsStatus_BUSVAO_Circuit)device.getDeviceStatus().BUSVAO.getCircuit(command.number);
                circuitStatus.order = new LightStudsStatus_BUSVAO_Circuit_Order();
                circuitStatus.order.timestamp = System.currentTimeMillis();
                circuitStatus.order.brightnessLevel = 0;
                circuitStatus.order.status = LightStudsStatus_BUSVAO_Circuit.STATUS_OFF;
            }
            else
            {
                SignalInformation_MODBUSTCP signalCircuit = (SignalInformation_MODBUSTCP)device.getDeviceInformation().BUSVAO.signals.getOutput("circuit " + command.number);
                SignalInformation_MODBUSTCP signalOn = (SignalInformation_MODBUSTCP)device.getDeviceInformation().BUSVAO.signals.getOutput("on");
                SignalInformation_MODBUSTCP signalOff = (SignalInformation_MODBUSTCP)device.getDeviceInformation().BUSVAO.signals.getOutput("off");
                String brightnessLevelName = "-";
                if (command.brightnessLevel == 1) brightnessLevelName = "level 1";
                if (command.brightnessLevel == 2) brightnessLevelName = "level 2";
                if (command.brightnessLevel == 3) brightnessLevelName = "level 3";
                if (command.brightnessLevel == 4) brightnessLevelName = "level 4";
                if (command.brightnessLevel == 5) brightnessLevelName = "level 5";
                SignalInformation_MODBUSTCP signalBrightness = (SignalInformation_MODBUSTCP)device.getDeviceInformation().BUSVAO.signals.getOutput(brightnessLevelName);
                Shared.println(name, "4.SendCommand: Circuit: " + signalCircuit.address + "." + signalCircuit.bit + " - On: " + signalOn.address + "." + signalOn.bit + " - Off: " + signalOff.address + "." + signalOff.bit + " - Brightness: " + signalBrightness.address + "." + signalBrightness.bit);
                if ((signalCircuit.address == signalOn.address) && (signalOn.address == signalOff.address) && (signalOff.address == signalBrightness.address))
                {
                    int value = 0;
                    value += (int)Math.pow(2, signalOff.bit);
                    value += (int)Math.pow(2, signalCircuit.bit);
                    write(writer, signalOff, value);
                    sleep(detail.timeBetweenOrders);
                    value = 0;
                    value += (int)Math.pow(2, signalOn.bit);
                    value += (int)Math.pow(2, signalCircuit.bit);
                    value += (int)Math.pow(2, signalBrightness.bit);
                    write(writer, signalOn, value);
                }
                else if ((signalCircuit.address != signalOn.address) && (signalOn.address == signalOff.address))
                {
                    int value = 0;
                    value += (int)Math.pow(2, signalOff.bit);
                    write(writer, signalOff, value);
                    value = 0;
                    value += (int)Math.pow(2, signalCircuit.bit);
                    write(writer, signalCircuit, value);
                    sleep(detail.timeBetweenOrders);

                    value = 0;
                    value += (int)Math.pow(2, signalOn.bit);
                    if (signalBrightness.address == signalOn.address)
                    {
                        value += (int)Math.pow(2, signalBrightness.bit);
                    }
                    write(writer, signalOn, value);

                    value = 0;
                    value += (int)Math.pow(2, signalCircuit.bit);
                    if (signalBrightness.address == signalCircuit.address)
                    {
                        value += (int)Math.pow(2, signalBrightness.bit);
                    }
                    write(writer, signalCircuit, value);
                }
                else
                {
                    write(writer, signalOff, 1);
                    sleep(detail.timeBetweenOrders);
                    if (command.brightnessLevel == 1) write(writer, "level 1", 1);
                    if (command.brightnessLevel == 2) write(writer, "level 2", 1);
                    if (command.brightnessLevel == 3) write(writer, "level 3", 1);
                    if (command.brightnessLevel == 4) write(writer, "level 4", 1);
                    if (command.brightnessLevel == 5) write(writer, "level 5", 1);
                    sleep(detail.timeBetweenOrders);
                    write(writer, "circuit " + command.number, 1);
                    sleep(detail.timeBetweenOrders);
                    write(writer, "off", 0);
                    sleep(detail.timeBetweenOrders);
                    write(writer, "on", 1);
                }

                LightStudsStatus_BUSVAO_Circuit circuitStatus = (LightStudsStatus_BUSVAO_Circuit)device.getDeviceStatus().BUSVAO.getCircuit(command.number);
                circuitStatus.order = new LightStudsStatus_BUSVAO_Circuit_Order();
                circuitStatus.order.timestamp = System.currentTimeMillis();
                circuitStatus.order.brightnessLevel = command.brightnessLevel;
                circuitStatus.order.status = LightStudsStatus_BUSVAO_Circuit.STATUS_ON;
            }

            DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_CORRECT);
            action.setResult(actionResult);
            Shared.model.addAction(action);
            return action;
            
        }
        catch (Exception exception)
        {
            DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, Shared.getMessage(language, "Error sending lightstuds order") + ": " + exception.toString());
            action.setResult(actionResult);
            Shared.model.addAction(action);
            return action;
        }
        finally
        {
            if (writer != null) writer.close();
        }
    }

    // </editor-fold>
    
    
    
    
    

    private void update() throws Exception
    {
        ReaderModbus reader = null;
        LightStuds studs = (LightStuds)getDevice();
        
        // Clon initialitation
        
        LightStuds clone = Serialization.clone(studs);
        
        
        
            clone.getDeviceStatus().status = DeviceStatus.STATUS_ONLINE;
            clone.setAlarm("alarm_offline", false);
            
           boolean pair = true;
            
            for(LightStudsStatus_BUSVAO_Circuit circuit : clone.getDeviceStatus().BUSVAO.circuits)
            {
                circuit.brightnessLevel = pair ? 7 : 4;
                circuit.status = pair ? LightStudsStatus_BUSVAO_Circuit.STATUS_ON : LightStudsStatus_BUSVAO_Circuit.STATUS_OFF;
                circuit.alarmBrightnessLevel = System.currentTimeMillis();
                pair = !pair;
            }
        
        
        Shared.model.updateDevice(studs, clone);
        
        if(true)
            return;
        
        clone.getDeviceStatus().BUSVAO = new LightStudsStatus_BUSVAO();
        if (clone.getDeviceAlarms().busvao == null) clone.getDeviceAlarms().busvao = new LightStudsAlarms_BUSVAO();
        
        for (LightStudsInformation_BUSVAO_Circuit circuitInformation : studs.getDeviceInformation().BUSVAO.circuits)
        {
            if (clone.getDeviceStatus().BUSVAO.circuits == null)
            {
                clone.getDeviceStatus().BUSVAO.circuits = new ArrayList<LightStudsStatus_BUSVAO_Circuit>();
            }

            LightStudsStatus_BUSVAO_Circuit circuitStatus = clone.getDeviceStatus().BUSVAO.getCircuit(circuitInformation.number);
            
            if (circuitStatus == null)
            {
                circuitStatus = new LightStudsStatus_BUSVAO_Circuit();
                circuitStatus.number = circuitInformation.number;
                clone.getDeviceStatus().BUSVAO.circuits.add(circuitStatus);
            }

            circuitStatus.status = LightStudsStatus_BUSVAO_Circuit.STATUS_UNKNOWN; 
        }

        
       
        
        // Read MODBUS TCP
        
        HashMap mapvalues = new HashMap<String, Integer>();
        
        SignalsInformation_MODBUSTCP signals = (SignalsInformation_MODBUSTCP)studs.getDeviceInformation().BUSVAO.signals;
                
        reader = new ReaderModbus(signals.address, signals.port, signals.timeout, signals.retries);
        
        for (SignalInformation signal :  studs.getDeviceInformation().BUSVAO.signals.inputs)
        {
            read(reader, (SignalInformation_MODBUSTCP)signal, mapvalues);
        }
        
        reader.close();
        
        
        // Read data to update status
        
        long timestamp = System.currentTimeMillis();
        
        try
        {
            // Read modbus tcp and update state

            int brightnessLevel = 0;
            boolean automatic_value = read(mapvalues, "Automatic");
            boolean level1_value = read(mapvalues, "level 1"); if (level1_value == true) brightnessLevel = 1;
            boolean level2_value = read(mapvalues, "level 2"); if (level2_value == true) brightnessLevel = 2;
            boolean level3_value = read(mapvalues, "level 3"); if (level3_value == true) brightnessLevel = 3;
            boolean level4_value = read(mapvalues, "level 4"); if (level4_value == true) brightnessLevel = 4;
            boolean level5_value = read(mapvalues, "level 5"); if (level5_value == true) brightnessLevel = 5;
            boolean alarm_open_circuit = read(mapvalues, "Open circuit");
            boolean alarm_overcurrent = read(mapvalues, "Overcurrent");
            boolean alarm_overheat = read(mapvalues, "Overheat");
            boolean alarm_LFD_warning = read(mapvalues, "LFD warning");
            boolean alarm_LFD_alarm = read(mapvalues, "LFD alarm");
            for (LightStudsStatus_BUSVAO_Circuit circuitStatus : clone.getDeviceStatus().BUSVAO.circuits)
            {
                boolean circuit_value = read(mapvalues, "circuit " + circuitStatus.number);
                
                if ((circuit_value == true) && (brightnessLevel > 0))
                {
                    circuitStatus.status = LightStudsStatus_BUSVAO_Circuit.STATUS_ON;
                    circuitStatus.brightnessLevel = brightnessLevel;
                }
                else 
                {
                    circuitStatus.status = LightStudsStatus_BUSVAO_Circuit.STATUS_OFF;
                    circuitStatus.brightnessLevel = 0;
                }

                if ((circuitStatus.order != null) && (circuitStatus.status == circuitStatus.order.status) && (circuitStatus.brightnessLevel == circuitStatus.order.brightnessLevel))
                {
                    circuitStatus.alarmBrightnessLevel = 0;
                    clone.setAlarm("alarm_brightness_level", false);
                }
                else
                {
                    if (circuitStatus.order == null)
                    {
                        circuitStatus.alarmBrightnessLevel = 0;
                        clone.setAlarm("alarm_brightness_level", false);
                    }
                    else if ((System.currentTimeMillis() - circuitStatus.order.timestamp) < (device.getDeviceInformation().BUSVAO.polling * 2))
                    {
                        circuitStatus.alarmBrightnessLevel = 0;
                        clone.setAlarm("alarm_brightness_level", false);
                    }
                    else
                    {
                        clone.setAlarm("alarm_brightness_level", true, timestamp);

                        if (circuitStatus.alarmBrightnessLevel == 0)
                        {
                            circuitStatus.alarmBrightnessLevel = timestamp;
                        }
                        else
                        {
                            circuitStatus.alarmBrightnessLevel = Math.min(circuitStatus.alarmBrightnessLevel, System.currentTimeMillis());
                        }
                    }
                }
            }

            if (automatic_value == true)
            {
                clone.getDeviceStatus().BUSVAO.status = LightStudsStatus_BUSVAO.STATUS_AUTOMATIC;
            }
            else
            {
                clone.getDeviceStatus().BUSVAO.status = LightStudsStatus_BUSVAO.STATUS_MANUAL;
            }
            
            clone.setAlarm("alarm_open_circuit", alarm_open_circuit, timestamp);
            clone.setAlarm("alarm_overcurrent", alarm_overcurrent, timestamp);
            clone.setAlarm("alarm_overheat", alarm_overheat, timestamp);
            clone.setAlarm("alarm_LFD_warning", alarm_LFD_warning, timestamp);
            clone.setAlarm("alarm_LFD_alarm", alarm_LFD_alarm, timestamp);
            clone.setAlarm("alarm_invalid", false);
            clone.setAlarm("alarm_offline", false);
            if (this.device.getAlarm("alarm_offline") > 0)
            {
                Shared.println(name, "Online");
            }

        }
        catch (Exception exception)
        {
            if (this.device.getAlarm("alarm_offline") <= 0)
            {
                Shared.println(name, "Offline: " + exception);
            }

            clone.setAlarm("alarm_offline", timestamp);
        }
        finally
        {
            if (reader != null) reader.close();
        }
 
        
            
         
    }

    private void read(ReaderModbus reader, SignalInformation_MODBUSTCP signal, HashMap mapvalues) throws Exception
    {
        try
        {
            for (int i=signal.address; i<(signal.address + signal.words); i++)
            {
                if (mapvalues.containsKey("" + i) == false)
                {
                    Shared.println(name, "Reading: @" + signal.address + " - Words: " + signal.words);
                    reader.loadRegisters(signal.address, signal.words);
                    Shared.println(name, "Read: @" + signal.address + " - Words: " + signal.words);

                    for (int j=0; j<signal.words; j++)
                    {
                        int value = reader.readInt16();
                        Shared.println(name, "Get Value: " + value + " - J: " + j + " - " + ("" + (signal.address + j)));
                        mapvalues.put("" + (signal.address + j), value);
                    }

                    return;
                }
            }
        }
        catch (Exception exception)
        {

        }
    }

    
    

    
    private boolean read(HashMap mapvalues, String name) throws Exception
    {
        SignalInformation_MODBUSTCP signal = (SignalInformation_MODBUSTCP)device.getDeviceInformation().BUSVAO.signals.getInput(name);
        int value = (Integer)mapvalues.get("" + signal.address);
        return ((value & (1 << signal.bit)) > 0);
    }
    
    
    
    
    private void write(WriterModbus writer, String name, int value) throws Exception
    {
         Shared.println(name, "1.Write: " + name + " - " + value);
         SignalInformation_MODBUSTCP signal = (SignalInformation_MODBUSTCP)device.getDeviceInformation().BUSVAO.signals.getOutput(name);
         Shared.println(name, "2.Write: " + name + " - " + value + " - " + signal);
         writer.setCoil(signal.bit, value);
         Shared.println(name, "3.Write: " + name + " - " + value + " - " + signal.bit);
    }
    
    
    
    
    private void write(WriterModbus writer, SignalInformation_MODBUSTCP signal, int value) throws Exception
    {
        Shared.println(name, "1.Write: " + signal.name + " - V: " + value + " - AddresS: " + signal.address);
        writer.setRegister(signal.address, value);
        Shared.println(name, "2.Write: " + signal.name + " - V: " + value + " - Address: " + signal.address);
    }

}