package art.servers.signalsboardserver.controller.pollers;

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_MODBUSTCP;
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.model.devices.signalsboard.status.SignalStatus;
import art.library.model.devices.signalsboard.status.SignalStatusGroup;
import art.library.net.modbus.ReaderModbus;
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 PollerModbus extends Thread
{
    private SignalsBoard device = null;
    private SignalsInformation_MODBUSTCP signalsInformation_Modbus = null;
    private ConfigurationDetail_Model model = null;
    private ScriptEngineManager factory = new ScriptEngineManager();
    private ScriptEngine engine = factory.getEngineByName("JavaScript");
    private String name = null;


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

            boolean result = true;

            // Inputs
            
            if (signalsInformation_Modbus.inputs != null)
            {
                List<SignalStatusGroup> groups = new ArrayList<SignalStatusGroup>();
                result = result & read(groups, signalsInformation_Modbus.inputs);

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

                    status.inputs.addAll(groups);
                }
            }

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

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

                    status.inouts.addAll(groups);
                }
            }

            // Alarms
            
            if (signalsInformation_Modbus.alarms != null)
            {
                result = result & read(signalsInformation_Modbus.alarms);
            }

            // Update values with definitions
            updateDefinitions(status);

            return result;
            
        }
        catch (Exception exception)
        {
            Shared.traceError(name + ", " + this.signalsInformation_Modbus.address, Shared.getMessage("Update"), exception);
            return false;
        }
    }
    
    
    
    private void updateDefinitions(SignalsBoardStatus status) throws Exception
    {
        try
        {
            // Inputs
            
            if (status.inputs != null)
            {
                updateDefinitions(status.inputs);
            }

            // Inouts
            
            if (status.inouts != null)
            {
                updateDefinitions(status.inouts);
            }
        }
        catch (Exception exception)
        {
            Shared.traceError(name + ", " + this.signalsInformation_Modbus.address, Shared.getMessage("Update"), exception);
        }
    }
    
    
    
    
    
    private void updateDefinitions(List<SignalStatusGroup> signalStatusGroup)
    {
        for (SignalStatusGroup group : signalStatusGroup)
        {
            for (SignalStatus signalStatus : group.signals)
            {
                ConfigurationDetail_Definition definition = model.getDefinition(signalStatus.name);

                if (definition != null)
                {
                    signalStatus.format = SignalStatus.FORMAT_STRING;
                    String value = definition.values.get(signalStatus.value);
                    if (value != null) signalStatus.value = value;
                }
            }
        }
    }
    
    
    
    
    
    private boolean read(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
        {
            // Read data to update status
        
            long timestamp = System.currentTimeMillis();
        
            // Read modbus tcp and update state

            for (SignalInformation signal : signalsInformation)
            {
                if (signal instanceof SignalInformation_MODBUSTCP)
                {
                    SignalInformation_MODBUSTCP signalInformation = (SignalInformation_MODBUSTCP)signal;
                    read(mapSignalsStatus, signalInformation);
                }
            }
            
            return true;
        }
        catch (Exception exception)
        {
            return false;
        }
        finally
        {
        }
    }
    
    
    
    private void read(HashMap<String, SignalStatus> mapSignalsStatus, SignalInformation_MODBUSTCP signal) throws Exception
    {
        ReaderModbus reader = null;

        try
        {
            SignalStatus signalStatus = mapSignalsStatus.get(signal.name);
            reader = new ReaderModbus(signalsInformation_Modbus.address, signalsInformation_Modbus.port, signalsInformation_Modbus.timeout, signalsInformation_Modbus.retries);
            reader.loadRegisters(signal.address, signal.words);
            int valueRegister = 0;
            if (signal.words == 1)
            {
                valueRegister = reader.readInt16();
            }
            else if (signal.words == 2)
            {
                valueRegister = reader.readInt16();
            }

            double value = (double)valueRegister;
            int valueInteger = valueRegister;

            if (signal.conversion != null)
            {
                double receivedFactor = (signal.conversion.maximumReceivedValue-signal.conversion.minimumReceivedValue);
                double signalFactor = (signal.conversion.maximumSignalValue-signal.conversion.minimumSignalValue);
                double factor = (signalFactor / receivedFactor);
                value = (double)valueRegister - signal.conversion.minimumReceivedValue;
                value = (value * factor);
                int v = (int)value * 100;
                value = (double)v / 100d;
                valueInteger = (int)value;
            }

            if (signal.format == SignalInformation.FORMAT_DOUBLE)
            {
                if (signal.factor != 1.0d)
                {
                    signalStatus.value = "" + value * signal.factor;
                }
                else
                {
                    signalStatus.value = "" + value;
                }
            }
            else
            {
                if (signal.bit < 0)
                {
                    signalStatus.value = "" + valueInteger;
                }
                else
                {
                    double pow = Math.pow(2, signal.bit);
                    boolean active = ((valueInteger & (int)pow) > 0);
                    signalStatus.value = "" + active;
                }
            }
        }
        catch (Exception exception)
        {
            Shared.printstack(name, exception);
        }
        finally
        {
            try{reader.close();} catch (Exception exception){};
        }
    }




    private boolean read(List<SignalAlarm> signalsAlarm)
    {
        try
        {
            for (SignalAlarm signalAlarm : signalsAlarm)
            {
                if (signalAlarm instanceof SignalAlarm_MODBUSTCP)
                {
                    read((SignalAlarm_MODBUSTCP)signalAlarm);
                }
            }
            
            return true;
        }
        catch (Exception exception)
        {
            return false;
        }
    }
    
        
    
    
    
    
    
    
    private void read(SignalAlarm_MODBUSTCP signalAlarm) throws Exception
    {
        ReaderModbus reader = null;

        try
        {
            reader = new ReaderModbus(signalsInformation_Modbus.address, signalsInformation_Modbus.port, signalsInformation_Modbus.timeout, signalsInformation_Modbus.retries);
            reader.loadRegisters(signalAlarm.address, signalAlarm.words);
            int valueRegister = 0;
            if (signalAlarm.words == 1)
            {
                valueRegister = reader.readInt16();
            }
            else if (signalAlarm.words == 2)
            {
                valueRegister = reader.readInt16();
            }

            double value = (double)valueRegister;
            int valueInteger = valueRegister;

            if (signalAlarm.bit >= 0)
            {
                double pow = Math.pow(2, signalAlarm.bit);
                valueInteger = (int)((valueInteger & (int)pow));
            }

            if (signalAlarm.eval != null)   
            {
               String assignment = valueInteger + " " + signalAlarm.eval;
               device.setAlarm(signalAlarm.name, (Boolean)engine.eval(assignment));
            }
            else
            {
               device.setAlarm(signalAlarm.name, valueInteger > 0); 
            }
        
        }
        catch (Exception exception)
        {
            Shared.printstack(name, exception);
        }
        finally
        {
            try{reader.close();} catch (Exception exception){};
        }
    }    

}