package art.servers.tickermachineserver.controller;

import art.library.interop.InteropParameter;
import art.library.interop.InteropParameters;
import art.library.interop.InteropResponse;
import art.library.interop.serialization.Serialization;
import art.library.interop.serialization.SerializationException;
import art.library.model.devices.Device;
import art.library.model.devices.DeviceAction;
import art.library.model.devices.DeviceRealtime;
import art.library.model.devices.DeviceStatus;
import art.library.model.devices.ticketmachine.TicketMachine;
import art.library.model.devices.ticketmachine.TicketMachineAlarms;
import art.library.model.devices.ticketmachine.TicketMachineRealtime;
import art.library.model.devices.ticketmachine.information.TickeMachineInformationConnection;
import art.servers.Shared;
import art.servers.controller.ControllerDevice;
import java.net.Socket;
import java.util.Arrays;
import java.util.Date;


public class ControllerTicketMachine extends ControllerDevice
{
    private Socket socket = null;
    private TicketMachine device = null;
    private String name = null;
    private long lastUpdateTimestampDevices = 0;
    private long lastUpdateTimestampDevicesRealtime = 0;
    private boolean connected = false;
    private boolean firstTime = false;


    public ControllerTicketMachine(Device device)
    {
        super(device);
        this.device = (TicketMachine)device;
        this.name = Shared.getMessage("Controller ticketmachine") + " " + device.information.name;
    }
    

    public TicketMachine getTicketMachine()
    {
        return device;
    }
    

    public void run()
    {
        art.servers.Shared.traceInformation(name, "Starting");
        
        while ((isInterrupted() == false) && (exit == false))
        {            
            long startTimestamp = System.currentTimeMillis();

            lastUpdateTimestampDevices = updateStatus(lastUpdateTimestampDevices);

            long stopTimestamp = startTimestamp + (device.getDeviceInformation().polling * 1000);

            while ((System.currentTimeMillis() < stopTimestamp) && (exit == false))
            {
                try
                {
                    sleep(50);
                }
                catch (Exception e)
                {
                }
            }
           
            if (Shared.model.existsDevice(device.getIdentifier()) == false)
            {
                Shared.println(name, Shared.getMessage("Device no longer exists"));
                exit = true;
            }
        }
        
        art.servers.Shared.traceInformation(name, "Finishing");
    }
        
    
    
    
    // <editor-fold defaultstate="collapsed" desc="Actions">

    public DeviceAction[] sendCommands(InteropParameters parameters) throws SerializationException
    {
        return new DeviceAction[0];
    }
    
    
    
     // </editor-fold>  
    
    
    


    private void connect() throws Exception
    {
        try
        {
            if (socket != null)
            {
                if (this.connected == true)
                {
                    return;
                }
            }

            TickeMachineInformationConnection connection =  device.getDeviceInformation().connection;
            socket = new Socket(connection.address, connection.port);
            socket.setSoTimeout(connection.timeout);
            this.connected = true;
        }
        catch (Exception e)
        {
            e.printStackTrace();
            try{disconnect();} catch (Exception ex){};
            throw e;
        }
    }
    
    
    
    private void disconnect()
    {
        try { socket.close(); }catch (Exception e) {}
        socket = null;
        this.connected = false;
    }    
    
    
    
    
    
    private long updateStatus(long timestamp)
    {
        TicketMachine deviceclone = (TicketMachine)Shared.model.cloneDevice(device.getIdentifier());

        try
        {
            System.out.println(new Date().toString() + " - 1.UpdateStatus: " + device.getIdentifier());
            connect();

            InteropParameters parameters = new InteropParameters();
            parameters.addParameter(new InteropParameter("service", name));
            parameters.addParameter(new InteropParameter("operation", "getDevices"));
            parameters.addParameter(new InteropParameter("language", Shared.configuration.general.language));
            parameters.addParameter(new InteropParameter("timestamp", String.valueOf(timestamp)));
            InteropResponse response = (InteropResponse)Serialization.invoke("get", parameters, socket);

            System.out.println(new Date().toString() + " - 2.UpdateStatus: " + device.getIdentifier());

            Device[] devices = Arrays.copyOf(response.getValue(), response.getValue().length, Device[].class);

            System.out.println(new Date().toString() + " - 3.UpdateStatus: " + device.getIdentifier() + " - " + devices.length);

            long lastTimestampUpdate = timestamp;
            for (Device device : devices)
            {
                lastTimestampUpdate = Math.max(lastTimestampUpdate, device.getLastTimestampUpdate());

                TicketMachine ticketmachine = (TicketMachine)device;
                TicketMachineAlarms alarms = ticketmachine.getDeviceAlarms();

                deviceclone.setAlarm("alarm_printer_offline", ticketmachine.getDeviceAlarms().alarm_printer_offline);
                deviceclone.setAlarm("alarm_printer_paper_warning", ticketmachine.getDeviceAlarms().alarm_printer_paper_warning);
                deviceclone.setAlarm("alarm_printer_paper_alarm", ticketmachine.getDeviceAlarms().alarm_printer_paper_alarm);
                deviceclone.setAlarm("alarm_printer_paper_drag_motor", ticketmachine.getDeviceAlarms().alarm_printer_paper_drag_motor);
                deviceclone.setAlarm("alarm_printer_paper_drag_motor", ticketmachine.getDeviceAlarms().alarm_printer_emitter_motor);
                deviceclone.setAlarm("alarm_printer_cover", ticketmachine.getDeviceAlarms().alarm_printer_cover);
                deviceclone.setAlarm("alarm_printer_notch_place_over_sensor", ticketmachine.getDeviceAlarms().alarm_printer_notch_place_over_sensor);
                deviceclone.setAlarm("alarm_printer_spooling", ticketmachine.getDeviceAlarms().alarm_printer_spooling);
                deviceclone.setAlarm("alarm_printer_head_temperature", ticketmachine.getDeviceAlarms().alarm_printer_head_temperature);
                deviceclone.setAlarm("alarm_printer_power_supply_voltage", ticketmachine.getDeviceAlarms().alarm_printer_power_supply_voltage);
                deviceclone.setAlarm("alarm_printer_paper_jam", ticketmachine.getDeviceAlarms().alarm_printer_paper_jam);
                deviceclone.setAlarm("alarm_printer_notch_search", ticketmachine.getDeviceAlarms().alarm_printer_notch_search);
                deviceclone.setAlarm("alarm_printer_cutter", ticketmachine.getDeviceAlarms().alarm_printer_cutter);
                deviceclone.setAlarm("alarm_printer_bulkhead_paper_path", ticketmachine.getDeviceAlarms().alarm_printer_bulkhead_paper_path);
                deviceclone.setAlarm("alarm_printer_ram", ticketmachine.getDeviceAlarms().alarm_printer_ram);
                deviceclone.setAlarm("alarm_printer_eprom", ticketmachine.getDeviceAlarms().alarm_printer_eprom);
                deviceclone.setAlarm("alarm_printer_emitter", ticketmachine.getDeviceAlarms().alarm_printer_emitter);

                if ((alarms.alarm_printer_paper_alarm > 0) ||
                    (alarms.alarm_printer_paper_warning > 0) ||
                    (alarms.alarm_printer_paper_jam > 0))
                {
                    deviceclone.getDeviceStatus().paper = DeviceStatus.STATE_YES;
                }
                else
                {
                    deviceclone.getDeviceStatus().paper = DeviceStatus.STATE_NONE;
                }

                if ((alarms.alarm_printer_paper_drag_motor > 0) ||
                    (alarms.alarm_printer_emitter_motor > 0))
                {
                    deviceclone.getDeviceStatus().hardware = DeviceStatus.STATE_YES;
                }
                else
                {
                    deviceclone.getDeviceStatus().hardware = DeviceStatus.STATE_NONE;
                }

                if ((alarms.alarm_printer_offline > 0) ||
                    (alarms.alarm_printer_cover > 0) ||
                    (alarms.alarm_printer_notch_place_over_sensor > 0) ||
                    (alarms.alarm_printer_spooling > 0) ||
                    (alarms.alarm_printer_head_temperature > 0) ||
                    (alarms.alarm_printer_power_supply_voltage > 0) ||
                    (alarms.alarm_printer_notch_search > 0) ||
                    (alarms.alarm_printer_cutter > 0) ||
                    (alarms.alarm_printer_bulkhead_paper_path > 0) ||
                    (alarms.alarm_printer_ram > 0) ||
                    (alarms.alarm_printer_eprom > 0) ||
                    (alarms.alarm_printer_emitter > 0))
                {
                    deviceclone.getDeviceStatus().printer = DeviceStatus.STATE_YES;
                }
                else
                {
                    deviceclone.getDeviceStatus().printer = DeviceStatus.STATE_NONE;
                }
            }

            // Update realtime
            lastUpdateTimestampDevicesRealtime = getDeviceRealtime(deviceclone, lastUpdateTimestampDevicesRealtime);

            online(deviceclone);
            return lastTimestampUpdate;
        }
        catch (Exception exception)
        {
            exception.printStackTrace();
            disconnect();
            try{offline(deviceclone);} catch (Exception e){};
        }

        return(timestamp);
    }
    
    
    private long getDeviceRealtime(TicketMachine deviceclone, long timestamp)
    {
        try
        {
            InteropParameters parameters = new InteropParameters();
            parameters.addParameter(new InteropParameter("service", name));
            parameters.addParameter(new InteropParameter("operation", "getDeviceRealtime"));
            parameters.addParameter(new InteropParameter("language", Shared.configuration.general.language));
            parameters.addParameter(new InteropParameter("identifier", deviceclone.getIdentifier()));
            parameters.addParameter(new InteropParameter("timestamp", String.valueOf(timestamp)));
            InteropResponse response = (InteropResponse)Serialization.invoke("get", parameters, socket);

            System.out.println(new Date().toString() + " - 1.UpdateRealtime: " + device.getIdentifier());

            DeviceRealtime[] devices = Arrays.copyOf(response.getValue(), response.getValue().length, DeviceRealtime[].class);

            System.out.println(new Date().toString() + " - 2.UpdateRealtime: " + device.getIdentifier() + " - " + devices.length);

            long lastTimestampUpdate = timestamp;
            for (DeviceRealtime device : devices)
            {
                TicketMachineRealtime ticketmachine = (TicketMachineRealtime)device;
                lastTimestampUpdate = Math.max(lastTimestampUpdate, ticketmachine.paper.timestampLastChange);
                deviceclone.realtime = ticketmachine;
            }

            return lastTimestampUpdate;
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }

        return(timestamp);
    }
    

    private void offline(TicketMachine deviceclone) throws SerializationException
    {
        if ((device.alarms.alarm_offline <= 0) || (firstTime == true))
        {
            firstTime = false;
            String message = art.servers.Shared.getMessage("TicketMachine offline");
            art.servers.Shared.println(name, message);
        }

        deviceclone.setAlarm("alarm_offline", System.currentTimeMillis());
        Shared.model.updateDevice(device, deviceclone);
    }


    private void online(TicketMachine deviceclone) throws SerializationException
    {
        if ((device.alarms.alarm_offline > 0) || (firstTime == true))
        {
            firstTime = false;
            String message = art.servers.Shared.getMessage("TicketMachine online");
            art.servers.Shared.println(name, message);
        }

        deviceclone.setAlarm("alarm_offline", false);
        deviceclone.setAlarm("alarm_invalid", false);
        Shared.model.updateDevice(device, deviceclone);
    }

}