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_SNMP;
import art.library.model.devices.signalsboard.information.SignalInformation;
import art.library.model.devices.signalsboard.information.SignalInformation_SNMP;
import art.library.model.devices.signalsboard.information.SignalsInformation_SNMP;
import art.library.model.devices.signalsboard.status.SignalStatus;
import art.library.model.devices.signalsboard.status.SignalStatusGroup;
import art.library.net.snmp.SNMPReader;
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;
import org.snmp4j.smi.SMIConstants;
import org.snmp4j.smi.TimeTicks;
import org.snmp4j.smi.VariableBinding;


public class PollerSNMP extends Thread
{
    private SignalsBoard device = null;
    private SignalsInformation_SNMP signalsInformation_SNMP = null;
    private ConfigurationDetail_Model model = null;
    private ScriptEngineManager factory = new ScriptEngineManager();
    private ScriptEngine engine = factory.getEngineByName("JavaScript");
    private String name = null;
    private SNMPReader reader = null;


    public PollerSNMP(String name, ConfigurationDetail_Model model, SignalsBoard device, SignalsInformation_SNMP signalsInformation_SNMP)
    {
        this.name  = name;
        this.model = model;
        this.device = device;
        this.signalsInformation_SNMP = signalsInformation_SNMP;
        this.reader = new SNMPReader(signalsInformation_SNMP.address, signalsInformation_SNMP.port, signalsInformation_SNMP.version, signalsInformation_SNMP.publicCommunity, signalsInformation_SNMP.timeout, signalsInformation_SNMP.retries);
    }
    
    
    
    public void run()
    {
        try
        {
            update();
        }
        catch (Exception exception)
        {
        }
    }
    
    
    
    public boolean update() throws Exception
    {
        try
        {
            SignalsBoardStatus status = device.getDeviceStatus();

            boolean result = true;

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

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

                    status.inputs.addAll(groups);
                }
            }

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

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

                    status.inouts.addAll(groups);
                }
            }

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

            // Update values with definitions
            updateDefinitions(status);

            return result;
            
        }
        catch (Exception exception)
        {
            Shared.traceError(name + ", " + this.signalsInformation_SNMP.address, Shared.getMessage("Update"), exception);
            return false;
        }
        finally
        {
            if (reader != null)
            {
                reader.disconnect();
            }
        }
    }
    
    
    
    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_SNMP.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
        {
            for (SignalInformation signal : signalsInformation)
            {
                if (signal instanceof SignalInformation_SNMP)
                {
                    SignalInformation_SNMP signalInformation = (SignalInformation_SNMP)signal;
                    SignalStatus signalStatus = mapSignalsStatus.get(signalInformation.name);
                    read(signalInformation, signalStatus);
                }
            }
            
            return true;
        }
        catch (Exception exception)
        {
            return false;
        }
    }
    
    
    
    

    
    private boolean read(List<SignalAlarm> signalsAlarm, SignalsBoardStatus status)
    {
        try
        {
            for (SignalAlarm signalAlarm : signalsAlarm)
            {
                if (signalAlarm instanceof SignalAlarm_SNMP)
                {
                    read(reader, (SignalAlarm_SNMP)signalAlarm);
                }
                else if (signalAlarm instanceof SignalAlarm)
                {
                    read(signalAlarm, status);
                }
            }
            
            return true;
        }
        catch (Exception exception)
        {
            return false;
        }
        finally
        {
            if (reader != null) reader.disconnect();
        }
    }
    
        
    
    
    
    
    
    
    private void read(SignalInformation_SNMP signalInformation, SignalStatus signalStatus) throws Exception
    {
        try
        {
            VariableBinding variable = reader.getVariableBinding(signalInformation.oid);

            try
            {
                if (signalInformation.oid.substring(1).equalsIgnoreCase(variable.getOid().toDottedString()) == false)
                {
                    Shared.println(name, "Info: " + signalInformation.name + " - " + signalInformation.oid);
                    Shared.println(name, "Var: " + variable.getOid().toDottedString());
                }
            }
            catch (Exception e)
            {

            }

            switch(variable.getSyntax())
            {
                case SMIConstants.EXCEPTION_END_OF_MIB_VIEW:
                case SMIConstants.EXCEPTION_NO_SUCH_INSTANCE:
                case SMIConstants.EXCEPTION_NO_SUCH_OBJECT:
                case SMIConstants.SYNTAX_NULL:
                     signalStatus.format = SignalStatus.FORMAT_UNKNOWN;
                     signalStatus.value = null;
                     break;

                case SMIConstants.SYNTAX_COUNTER32:
                case SMIConstants.SYNTAX_UNSIGNED_INTEGER32:
                case SMIConstants.SYNTAX_COUNTER64:
                case SMIConstants.SYNTAX_INTEGER:


                     if (signalInformation.factor != 1.0)
                     {
                         signalStatus.format = SignalStatus.FORMAT_DOUBLE;
                         double value = (Double.parseDouble(variable.toValueString()) * signalInformation.factor);
                         int valueInt = (int)(value * 100d);
                         value = (double)((double)valueInt / 100d);
                         signalStatus.value = "" + value;
                     }
                     else
                     {
                         signalStatus.format = SignalStatus.FORMAT_LONG;
                         signalStatus.value = variable.toValueString();
                     }

                     break;

                case SMIConstants.SYNTAX_TIMETICKS:
                     TimeTicks ticks = (TimeTicks)variable.getVariable();
                     signalStatus.format = SignalStatus.FORMAT_DURATION;
                     signalStatus.value = "" + ticks.toMilliseconds();
                     break;

                case SMIConstants.SYNTAX_OCTET_STRING:
                case SMIConstants.SYNTAX_OBJECT_IDENTIFIER:
                case SMIConstants.SYNTAX_IPADDRESS:
                case SMIConstants.SYNTAX_OPAQUE:
                     signalStatus.format = SignalStatus.FORMAT_STRING;
                     signalStatus.value = variable.toValueString();
                     break;

                default:
                     signalStatus.format = SignalStatus.FORMAT_UNKNOWN;
                     signalStatus.value = null;

            }
        }
        catch (Exception exception)
        {
            Shared.println(name, "Group: " + signalInformation.group + " Name: " + signalInformation.name + " Oid: " + signalInformation.oid + " - " + exception);
            signalStatus.format = SignalStatus.FORMAT_UNKNOWN;
            signalStatus.value = null;
        }
    }
    
    
    

    
    
    private void read(SNMPReader reader, SignalAlarm_SNMP signalAlarm) throws Exception
    {
        VariableBinding variable = reader.getVariableBinding(signalAlarm.oid);
        
        switch(variable.getSyntax())
        {
            case SMIConstants.EXCEPTION_END_OF_MIB_VIEW:
            case SMIConstants.EXCEPTION_NO_SUCH_INSTANCE:
            case SMIConstants.EXCEPTION_NO_SUCH_OBJECT:
            case SMIConstants.SYNTAX_NULL:
                 device.setAlarm(signalAlarm.name, 0);
                 return;

            case SMIConstants.SYNTAX_COUNTER32:
            case SMIConstants.SYNTAX_UNSIGNED_INTEGER32:
            case SMIConstants.SYNTAX_COUNTER64:
            case SMIConstants.SYNTAX_INTEGER:                
                 if (signalAlarm.eval != null)   
                 {
                    String assignment = Double.parseDouble(variable.toValueString()) + " " + signalAlarm.eval;
                    device.setAlarm(signalAlarm.name, (Boolean)engine.eval(assignment));
                 }
                 else
                 {
                    device.setAlarm(signalAlarm.name, Double.parseDouble(variable.toValueString()) > 0); 
                 }
                 
                 return;

            case SMIConstants.SYNTAX_TIMETICKS:
                 
                TimeTicks ticks = (TimeTicks)variable.getVariable();

                 if (signalAlarm.eval != null)   
                 {
                    String assignment = Double.parseDouble(variable.toValueString()) + " " + ticks.toMilliseconds();
                    boolean result = (Boolean)engine.eval(assignment);
                    device.setAlarm(signalAlarm.name, result);
                 }
                 else
                 {
                    device.setAlarm(signalAlarm.name, ticks.toMilliseconds() > 0); 
                 }
                 return;

            case SMIConstants.SYNTAX_OCTET_STRING:
            case SMIConstants.SYNTAX_OBJECT_IDENTIFIER:
            case SMIConstants.SYNTAX_IPADDRESS:
            case SMIConstants.SYNTAX_OPAQUE:
                 if (signalAlarm.eval != null)   
                 {
                    String assignment = variable.toValueString() + " " + signalAlarm.eval;
                    device.setAlarm(signalAlarm.name, (Boolean)engine.eval(assignment));
                    return;
                 }
                 break;
        }

        device.setAlarm(signalAlarm.name, 0);
        
    }    
    
    
    private void read(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;
           Boolean b = (Boolean)engine.eval(assignment);
           device.setAlarm(signalAlarm.name, b);
        }
        else
        {
           device.setAlarm(signalAlarm.name, Double.parseDouble(signalStatus.value) > 0); 
        }
    }

}