package art.servers.etdserver.controller;


import art.library.model.devices.DeviceStatus;
import art.library.model.devices.etd.Etd;
import art.library.model.devices.etd.EtdInformation;
import art.library.interop.serialization.Serialization;
import art.library.model.transactions.traces.Trace;
import art.library.utils.synchro.Mutex;
import art.servers.etdserver.Shared;
import art.servers.etdserver.protocols.skp3.SKP3_Message;
import art.servers.etdserver.protocols.skp3.SKP3_ProtocolAnalyser;
import art.servers.etdserver.protocols.skp3.SKP3_ProtocolConstructor;
import art.servers.etdserver.protocols.skp3.SKP3_ProtocolWriter;
import java.io.InputStream;
import java.io.OutputStream;
import static java.lang.Thread.sleep;
import java.net.Socket;
import java.text.SimpleDateFormat;


public class ControllerSKP3 extends ControllerEtd
{
    private SimpleDateFormat sdh = new SimpleDateFormat("HH:mm");
    private boolean connected = false;
    private Socket socket = null;
    private InputStream is = null;
    private OutputStream os = null;
    private long lastTimestamp = 0;
    private int status = DeviceStatus.STATUS_ALARM;
    private boolean firstTime = true;
    private Mutex mutexPort = new Mutex();


    public ControllerSKP3(Etd etd)
    {
        super(etd);
        this.device = etd;
        this.name = Shared.getMessage("Controller etd") + " " + etd.information.name;
        super.setName(this.name);
    }
    
    
    
    
    public void run()
    {
        // <editor-fold defaultstate="collapsed" desc="Trace">
        art.servers.Shared.println(Trace.getTraceInformation(art.servers.Shared.getApplicationName(), name, art.servers.Shared.getMessage("Starting"), art.servers.Shared.getMessage("Success")), true);
        // </editor-fold>      

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

            try
            {
                if (art.servers.Shared.isServerEnabled() == true)
                {
//                    if (connected == false) 
//                    {
//                        connect();
//                    }

                    update();
                }
            }
            catch (Exception e)
            {
            }

            if (startTimestamp > System.currentTimeMillis())
            {
                startTimestamp = System.currentTimeMillis();
            }

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

            while ((System.currentTimeMillis() < stopTimestamp) && (exit == false))
            {
                try
                {
                    sleep(50);
                }
                catch (Exception e)
                {
                }
            }
           
            try
            {
                sleep(1000);
            }
            catch (Exception e)
            {
            }

            if (art.servers.Shared.model.existsDevice(device.getIdentifier()) == false)
            {
                art.servers.Shared.println(name, art.servers.Shared.getMessage("Device no longer exists"));
                exit = true;
            }
        }
        
        // <editor-fold defaultstate="collapsed" desc="Trace">
        art.servers.Shared.println(Trace.getTraceInformation(art.servers.Shared.getApplicationName(), name, art.servers.Shared.getMessage("Finishing"), art.servers.Shared.getMessage("Success")), true);
        // </editor-fold>      
    }




    /*
        Private controller functions
    */

    private void update() throws Exception
    {
        Etd etdclone = (Etd)Serialization.clone(device);

        try
        {
            sleep(5000);

            EtdInformation etdInformation = (EtdInformation)etdclone.getDeviceInformation();

            // Update serial number
            {
                readSerialNumber(etdclone);
            }

            // Status / Alarms
            {
                readStatus(etdclone);
            }

            // Data
            {
                readCurrentTrafficDataPeriod(etdclone);
            }

            online(etdclone);
            return;
        }
        catch (Exception exception)
        {
            if ((etdclone.alarms.alarm_offline <= 0) || (firstTime == true))
            {
                firstTime = false;
                String message = art.servers.Shared.getMessage("Etd offline");
                art.servers.Shared.println(name, exception);
            }

            offline(etdclone);
            try{disconnect();} catch (Exception ex){};
        }
    }




    private boolean isError()
    {
        errorsNumber = errorsNumber + 1;
        if (errorsNumber >= maxErrorsNumber)
            return(true);
        return(false);
    }


    

    private void offline(Etd etdclone)throws Exception
    {
        if (isError() == true)
        {
            if (etdclone.getAlarm("alarm_offline") <= 0)
            {
                if (etdclone.getAlarm("alarm_offline") <= 0)
                {
                    etdclone.getDeviceAlarms().clear();
                }
                etdclone.setAlarm("alarm_offline", true);
            }
            Shared.model.updateDevice(device, etdclone);
        }
    }
    

    private void online(Etd etdclone) throws Exception
    {
        errorsNumber = 0;
        if ((etdclone.alarms.alarm_offline > 0) || (firstTime == true))
        {
            firstTime = false;
            String message = art.servers.Shared.getMessage("Etd online");
            art.servers.Shared.println(name, message);
        }

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



    private void readSerialNumber (Etd etdclone) throws Exception
    {
        byte[] command = SKP3_ProtocolConstructor.readSerialNumber(0x00);
        SKP3_Message response = read(command);
        int serialNumber = SKP3_ProtocolAnalyser.analyseReadSerialNumberResponse(response);
        if (etdclone.getDeviceInformation().serialNumber.equalsIgnoreCase(""+serialNumber) == false)
        {
            etdclone.getDeviceInformation().serialNumber = ""+serialNumber;
        }
    }


    private void readStatus (Etd etdclone) throws Exception
    {
        byte[] command = SKP3_ProtocolConstructor.readStatus(Integer.parseInt(etdclone.getDeviceInformation().serialNumber));
        SKP3_Message response = read(command);
        SKP3_ProtocolAnalyser.analyseReadStatusResponse(etdclone, response);
    }


    private void readCurrentTrafficDataPeriod (Etd etdclone) throws Exception
    {
        byte[] command = SKP3_ProtocolConstructor.readCurrentTrafficData(Integer.parseInt(etdclone.getDeviceInformation().serialNumber), 0, 1);
        SKP3_Message response = read(command);
        SKP3_ProtocolAnalyser.analyseReadCurrentTrafficDataPeriodResponse(etdclone, response);
    }





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

            this.socket = new Socket(this.device.getDeviceInformation().connection.address, this.device.getDeviceInformation().connection.port);
            this.socket.setSoTimeout(this.device.getDeviceInformation().connection.timeout);
            this.is = this.socket.getInputStream();
            this.os = this.socket.getOutputStream();
            this.connected = true;

            if (status != DeviceStatus.STATUS_ONLINE)
            {
                String message = Shared.getMessage("Connected, address = %1, port = %2, timeout = %3");
                message = message.replace("%1", device.getDeviceInformation().connection.address);
                message = message.replace("%2", "" +device.getDeviceInformation().connection.port);
                message = message.replace("%3", "" + device.getDeviceInformation().connection.timeout);
                Shared.println(device.information.name, message);
                status = DeviceStatus.STATUS_ONLINE;
            }
            
        }
        catch (Exception e)
        {
            try{disconnect();} catch (Exception ex){};
        }
        
    }
    
    
    

    private void disconnect() throws Exception
    {
        try { is.close(); }catch (Exception e) {}
        try { os.close(); }catch (Exception e) {}
        try { socket.close(); }catch (Exception e) {}
        is = null;
        os = null;
        socket = null;
        this.connected = false;
    }
    

        
    private SKP3_Message read(byte[] command) throws Exception
    {
        try
        {
            //send(command);
            //return receive();
            mutexPort.lockWrite();

            try
            {
                connect();
                send(command);
                return receive();
            }
            catch (Exception e)
            {
                throw e;
            }
            finally
            {
                disconnect();
                mutexPort.releaseWrite();
            }
        }
        catch (Exception e)
        {
            throw e;
        }
    }
     
    
    
    private void send(byte[] command) throws Exception
    {
        socket.getOutputStream().write(command);
        socket.getOutputStream().flush();
    }



    private SKP3_Message receive() throws Exception
    {
       boolean salir = false;
       int res = 0;
       byte[] trama = null;

       int longitud = 0;
       long ts = System.currentTimeMillis();

       try
       {
          while ((res = is.read()) == 0){sleep(10);};

          if (res != SKP3_ProtocolWriter.STX)
          {
               while ((res != SKP3_ProtocolWriter.STX) && (res != -1) && ((System.currentTimeMillis()-ts) <= device.getDeviceInformation().connection.timeout))
               {
                    res = is.read();
               }
          }

          if (res == SKP3_ProtocolWriter.STX)
          {
               ts = System.currentTimeMillis();
               int apuntador = 0;
               trama = new byte[65535];
               trama[apuntador] = (byte)res;
               apuntador++;

               res = is.read();

               while ((res != SKP3_ProtocolWriter.STX) && (res != -1) && ((System.currentTimeMillis()-ts) <= device.getDeviceInformation().connection.timeout))
               {
                    trama[apuntador] = (byte)res;
                    apuntador++;
                    res = is.read();
               }

               trama[apuntador] = (byte)res;
               apuntador++;
               longitud = apuntador;
          }
       }
       catch (Exception e)
       {
          throw e;
       }

       if ((res == -1) || (longitud == 0))
          throw new Exception("Timeout-Error");

       byte[] resultado = new byte[longitud];
       System.arraycopy(trama, 0, resultado, 0, longitud);

       SKP3_Message message = new SKP3_Message();
       message.setData(resultado);
       return(message);
    }    

}