package art.servers.signalsboardserver.controller.pollers;

import art.library.interop.InteropParameter;
import art.library.interop.InteropParameters;
import art.library.interop.InteropResponse;
import art.library.interop.serialization.Serialization;
import art.library.model.devices.Device;
import art.library.model.devices.eru.status.inout.InputStatus;
import art.library.model.devices.signalsboard.SignalsBoard;
import art.library.model.devices.signalsboard.SignalsBoardStatus;
import art.library.model.devices.signalsboard.alarms.SignalAlarm;
import art.library.model.devices.signalsboard.alarms.SignalAlarm_ERU;
import art.library.model.devices.signalsboard.alarms.SignalAlarm_SNMP;
import art.library.model.devices.signalsboard.information.SignalInformation;
import art.library.model.devices.signalsboard.information.SignalInformation_ERU;
import art.library.model.devices.signalsboard.information.SignalsInformation_ERU;
import art.library.model.devices.signalsboard.status.SignalStatus;
import art.library.model.devices.signalsboard.status.SignalStatusGroup;
import art.servers.Shared;
import art.servers.signalsboardserver.configuration.ConfigurationDetail_Definition;
import art.servers.signalsboardserver.configuration.ConfigurationDetail_Model;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;


public class PollerERU extends Thread
{
    private SignalsBoard device = null;
    private SignalsInformation_ERU signalsInformation_ERU = null;
    private ConfigurationDetail_Model model = null;
    private ScriptEngineManager factory = new ScriptEngineManager();
    private ScriptEngine engine = factory.getEngineByName("JavaScript");
    private String name = null;


    public PollerERU(String name, ConfigurationDetail_Model model, SignalsBoard device, SignalsInformation_ERU signalsInformation_ERU)
    {
        this.name  = name;
        this.model = model;
        this.device = device;
        this.signalsInformation_ERU = signalsInformation_ERU;
    }
    
    
    
    public void run()
    {
        try
        {
            update();
        }
        catch (Exception exception)
        {
        }
    }
    
    
    
    public boolean update() throws Exception
    {
        try
        {
            SignalsBoardStatus status = device.getDeviceStatus();

            boolean result = true;

            // Inputs
            Device eru = Shared.model.getDeviceExternal(signalsInformation_ERU.eru);
            
            if (signalsInformation_ERU.inputs != null)
            {
                List<SignalStatusGroup> groups = new ArrayList<SignalStatusGroup>();
                result = result & read(eru, groups, signalsInformation_ERU.inputs);

                if (groups.size() > 0)
                {
                    if (status.inputs == null)
                    {
                        status.inputs = new ArrayList<SignalStatusGroup>();
                    }

                    status.inputs.addAll(groups);
                }
            }

            // Inouts
            
            if (signalsInformation_ERU.inouts != null)
            {
                List<SignalStatusGroup> groups = new ArrayList<SignalStatusGroup>();
                result = result & read(eru, groups, signalsInformation_ERU.inouts);

                if (groups.size() > 0)
                {
                    if (status.inouts == null)
                    {
                        status.inouts = new ArrayList<SignalStatusGroup>();
                    }

                    status.inouts.addAll(groups);
                }
            }

            // Alarms
            
            if (signalsInformation_ERU.alarms != null)
            {
                result = result & read(eru, signalsInformation_ERU.alarms, status);
            }

            return result;
            
        }
        catch (Exception exception)
        {
            Shared.traceError(name + ", " + this.signalsInformation_ERU.eru, Shared.getMessage("Update"), exception);
            return false;
        }
        finally
        {
        }
    }
    
    
    
    
    
    private boolean read(Device eru, List<SignalStatusGroup> groups, List<SignalInformation> signalsInformation)
    {
        HashMap<String, SignalStatusGroup> mapGroups =  new HashMap<String, SignalStatusGroup>();
        HashMap<String, SignalStatus> mapSignalsStatus = new HashMap<String, SignalStatus>();
        
        // Initialise all status signals
        
        for (SignalInformation signalInformation : signalsInformation)
        {
            SignalStatus signalStatus = new SignalStatus();
            signalStatus.name = signalInformation.name;
            signalStatus.units = signalInformation.units;
            signalStatus.description = signalInformation.description;
            mapSignalsStatus.put(signalStatus.name, signalStatus);
            
            SignalStatusGroup group = mapGroups.get(signalInformation.group);
            
            if (group == null) 
            {
                group = new SignalStatusGroup();
                group.name = signalInformation.group;
                group.signals = new ArrayList<SignalStatus>();
                groups.add(group);
                mapGroups.put(group.name, group);
            }
            
            group.signals.add(signalStatus);
        }
        
        
        // Read all signals
        
        try
        {
            for (SignalInformation signal : signalsInformation)
            {
                if (signal instanceof SignalInformation_ERU)
                {
                    SignalInformation_ERU signalInformation = (SignalInformation_ERU)signal;
                    SignalStatus signalStatus = mapSignalsStatus.get(signalInformation.name);
                    read(eru, signalInformation, signalStatus);
                }
            }
            
            return true;
        }
        catch (Exception exception)
        {
            return false;
        }
    }
    
    
    
    

    
    private boolean read(Device eru, List<SignalAlarm> signalsAlarm, SignalsBoardStatus status)
    {
        try
        {
            for (SignalAlarm signalAlarm : signalsAlarm)
            {
                if (signalAlarm instanceof SignalAlarm_ERU)
                {
                    read(eru, (SignalAlarm_ERU)signalAlarm);
                }
                else if (signalAlarm instanceof SignalAlarm)
                {
                    read(eru, signalAlarm, status);
                }
            }
            
            return true;
        }
        catch (Exception exception)
        {
            return false;
        }
        finally
        {
        }
    }
    
        
    
    
    
    
    
    
    private void read(Device eru, SignalInformation_ERU signalInformation, SignalStatus signalStatus) throws Exception
    {
        try
        {
            InteropParameters parameters = new InteropParameters();
            parameters.addParameter(new InteropParameter("operation", "getInput"));
            parameters.addParameter(new InteropParameter("device", eru.getIdentifier()));
            parameters.addParameter(new InteropParameter("inputs", "" + signalInformation.number));
            InteropResponse response = (InteropResponse)Serialization.invoke("get", parameters, eru.getDeviceInformation().serverAddress, eru.getDeviceInformation().serverPort, 15000);
            InputStatus inputStatus = (InputStatus)response.getValue()[0];

            ConfigurationDetail_Definition definition = model.getDefinition(signalInformation.name);

            if (definition != null)
            {
                signalStatus.format = SignalStatus.FORMAT_STRING;
                signalStatus.value = definition.values.get(Integer.parseInt(inputStatus.value));
                if (signalStatus.value == null) signalStatus.value = inputStatus.value;
                return;
            }

            if (signalInformation.format == SignalInformation.FORMAT_DOUBLE)
            {
                if (signalInformation.conversion != null)
                {
                    double receivedFactor = (signalInformation.conversion.maximumReceivedValue-signalInformation.conversion.minimumReceivedValue);
                    double signalFactor = (signalInformation.conversion.maximumSignalValue-signalInformation.conversion.minimumSignalValue);
                    double factor = (signalFactor / receivedFactor);
                    double value = Double.parseDouble(inputStatus.value) - signalInformation.conversion.minimumReceivedValue;
                    value = (value * factor);
                    int v = (int)value * 100;
                    value = (double)v / 100d;
                    signalStatus.value = "" + value;
                }
                else if (signalInformation.factor != 1.0d)
                {
                    signalStatus.value = "" + Double.parseDouble(inputStatus.value) * signalInformation.factor;
                }
                else
                {
                    signalStatus.value = inputStatus.value;
                }
            }
            else
            {
                signalStatus.value = inputStatus.value;
            }
        }
        catch (Exception exception)
        {
            Shared.printstack(name, exception);
            Shared.println(name, "Group: " + signalInformation.group + " Name: " + signalInformation.name + " Eru: " + eru.getIdentifier() + " Number: " + signalInformation.number);
        }
    }
    
    
    
    
    private void read(Device eru, SignalAlarm_ERU signalAlarm) throws Exception
    {
        InteropParameters parameters = new InteropParameters();
        parameters.addParameter(new InteropParameter("operation", "getInput"));
        parameters.addParameter(new InteropParameter("device", eru.getIdentifier()));
        parameters.addParameter(new InteropParameter("inputs", "" + signalAlarm.number));
        InteropResponse response = (InteropResponse)Serialization.invoke("get", parameters, eru.getDeviceInformation().serverAddress, eru.getDeviceInformation().serverPort, 15000);
        InputStatus inputStatus = (InputStatus)response.getValue()[0];

        if (signalAlarm.eval != null)   
        {
           String assignment = Double.parseDouble(inputStatus.value) + " " + signalAlarm.eval;
           device.setAlarm(signalAlarm.name, (Boolean)engine.eval(assignment));
        }
        else
        {
           device.setAlarm(signalAlarm.name, Double.parseDouble(inputStatus.value) > 0); 
        }
    }
    

    
    
    private void read(Device eru, SignalAlarm signalAlarm, SignalsBoardStatus status) throws Exception
    {
        SignalStatus signalStatus = status.getSignal(signalAlarm.signal);
        if (signalStatus.value == null) device.setAlarm(signalAlarm.name, true);

        if (signalAlarm.eval != null)   
        {
           String assignment = Double.parseDouble(signalStatus.value) + " " + signalAlarm.eval;
           device.setAlarm(signalAlarm.name, (Boolean)engine.eval(assignment));
        }
        else
        {
           device.setAlarm(signalAlarm.name, Double.parseDouble(signalStatus.value) > 0);
        }
    }

}