package art.servers.colorsserver.controller;

import art.library.model.devices.Device;
import art.library.utils.synchro.Mutex;
import art.servers.ColorsServer;
import art.servers.ServerException;
import art.servers.colorsserver.Shared;
import art.servers.colorsserver.M.protocol.M_Message;
import static art.servers.colorsserver.M.protocol.M_ProtocolWriter.*;
import art.servers.colorsserver.M.protocol.M_Request;
import art.servers.controller.Controller;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.SocketException;
import java.net.SocketTimeoutException;
import java.util.ArrayList;
import java.util.List;


public class ControllerConnection extends Controller
{
    private String name = "";
    public String address = null;
    private int port = 0;
    private int timeout = 0;
    private boolean hasCRC = false;
    public Socket socket = null;
    private InputStream is = null;
    private OutputStream os = null;
    private boolean connected = false;
    private Mutex mutexListRequest = new Mutex();
    private List<M_Request> lrequest = new ArrayList<M_Request>();
    private int timeouts = 0;
    private int maxtimeouts = 50;
    private int reconnections = 0;
    private boolean print = false;
    private boolean trace = false;
    private boolean execute = true;


    public ControllerConnection (String address, int port, int timeout, boolean hasCRC)
    {
        this.address = address;
        this.port = port;
        this.timeout = timeout;
        this.hasCRC = hasCRC;
        this.name = Shared.getMessage("Controller connection") + " " + this.address + ":" + this.port + "," + this.timeout + "," + this.hasCRC;
        this.setName(name);
        print = (this.address.equalsIgnoreCase(Shared.ipcontrollerlog) && (this.port == Shared.portcontrollerlog));
        trace = (this.address.equalsIgnoreCase(Shared.ipcontrollerlog) && (this.port == Shared.portcontrollerlog) && (ColorsServer.LOG_TRACE == true));
    }




    public void run ()
    {
        // <editor-fold defaultstate="collapsed" desc="Trace">
        Shared.traceInformation(name, Shared.getMessage("Starting"));
        // </editor-fold>      

        while ((isInterrupted() == false) && (exit == false))
        {
            try
            {
                if (this.execute == true)
                {
                    connect();

                    long millis = System.currentTimeMillis();
                    clearM_Request();
                    if (lrequest.size() > 10)
                    {
                        Shared.println(name, Device.getDate(System.currentTimeMillis()) + " - " + address + ":" + port + " - 0.RCV: " + (System.currentTimeMillis()-millis) + " - " + lrequest.size());
                    }

                    if (this.connected == true)
                    {
                        M_Message response = receive();
                        ack();

                        M_Request request = getM_Request(response);
                        if (request != null)
                        {
                            if (print == true)
                            {
                                Shared.println(name, Device.getDate(System.currentTimeMillis()) + " - " + this.address + ":" + this.port + " - Received message Request: " + response);
                                if (trace == true)
                                {
                                    Shared.traceInformation(name, "Received message Response", response.toString());
                                }
                            }
                            removeM_Request(request, response);
                        }
                        else
                        {
                            // Notification
                            if (print == true)
                            {
                                Shared.println(name, Device.getDate(System.currentTimeMillis()) + " - " + this.address + ":" + this.port + " - Received message Notification: " + response);
                                if (trace == true)
                                {
                                    Shared.traceInformation(name, "Received message Notification", response.toString());
                                }
                            }
                        }
                    }
                    else
                    {
                        String message = "DISCON.Run " + address + ":" + port + " - " + this.connected;
                        Shared.println(this.getName(), message);
                    }
                }
            }
            catch (Exception e)
            {
                if (e.toString().toUpperCase().indexOf("NULLPOINTER") < 0)
                {
                    Shared.println(this.getName(), e);
                }
            }
            finally
            {
                try{sleep(50);} catch (Exception exception){};
            }
        }

        // <editor-fold defaultstate="collapsed" desc="Trace">
        Shared.traceInformation(name, Shared.getMessage("Finishing"));
        // </editor-fold>      
    }


    public void stopConnection ()
    {
        try
        {
            execute = false;
            disconnect();
        }
        catch (Exception e)
        {
            
        }
    }


    public void resumeconnection ()
    {
        try
        {
            execute = true;
        }
        catch (Exception e)
        {
            
        }
    }


    public void setTimeout (int timeout)
    {
        try
        {
            socket.setSoTimeout(timeout);
        }
        catch (Exception e)
        {
            
        }
    }


    private void clearM_Request ()
    {
        try
        {
            mutexListRequest.lockWrite();
            List<M_Request> lremove = new ArrayList<M_Request>();
            for (M_Request request : lrequest)
            {
                if (request.finishedByTimeout == true)
                {
                    lremove.add(request);
                }
            }

            if (lremove.size() > 0)
            {
                lrequest.removeAll(lremove);
            }
        }
        catch (Exception e)
        {

        }
        finally
        {
            mutexListRequest.releaseWrite();
        }
    }


    public void addM_Request (M_Request request)
    {
        try
        {
            mutexListRequest.lockWrite();
            send(request.request.toByteArray());
            request.send(timeout);
            lrequest.add(request);
        }
        catch (Exception e)
        {

        }
        finally
        {
            mutexListRequest.releaseWrite();
        }
    }


    private void removeM_Request (M_Request request, M_Message response)
    {
        try
        {
            mutexListRequest.lockWrite();
            if (response != null) request.receive(response);
            lrequest.remove(request);
        }
        catch (Exception e)
        {

        }
        finally
        {
            mutexListRequest.releaseWrite();
        }
    }


    private M_Request getM_Request (M_Message response)
    {
        try
        {
            mutexListRequest.lockRead();
//            if ((response.isAck == true) || (response.isNack == true) || (response.isTrcam == true))
//                return null;
            if ((response.isNack == true) || (response.isTrcam == true))
                return null;

            if (print == true)
            {
                Shared.println(name, Device.getDate(System.currentTimeMillis()) + " - " + this.address + ":" + this.port + " - " + response.controller + " - " + response.table + " - Analyzing message reception: " + response);
            }

            for (M_Request request : lrequest)
            {
                if (response.isAck == true)
                {
                    if (request.finishedByTimeout == false)
                    {
                        switch(request.request.directive)
                        {
                            case M_WRITE_TABLE_FULL:
                            {
                                if (print == true)
                                {
                                    Shared.println(name, "Received write full table, ACK: " + request.request.directive + " - " + request.request.controller + " - " + request.request.table);
                                }

                                // There is a request pending
                                return(request);
                            }
                        }
                    }
                }
                else
                {
                    if ((request.finishedByTimeout == false) && 
                        (request.request.controller == response.controller) &&
                        (request.request.table == response.table))
                    {
                        if (request.request.isCountingDetectorQuery() == true)
                        {
                            if (response.directive == M_CURRENT_COUNTING_DETECTORS)
                            {
                                return(request);
                            }
                        }

                        if (request.request.isPRHQuery()== true)
                        {
                            if (response.directive == M_CURRENT_TIME_QUERY)
                            {
                                return(request);
                            }
                        }

                        switch(request.request.directive)
                        {
                            case M_RECORDABLE_PLAN_QUERY:
                            {
                                if ((request.request.directive == response.directive) &&
                                    (request.request.controller == response.controller))
                                {
                                    // There is a request pending
                                    return(request);
                                }
                            }
                            break;

                            case M_CURRENT_PLAN_QUERY:
                            {
                                if ((request.request.directive == response.directive) &&
                                    (request.request.controller == response.controller))
                                {
                                    // There is a request pending
                                    return(request);
                                }
                            }
                            break;

                            case M_CURRENT_TIME_QUERY:
                            {
                                if ((request.request.directive == response.directive) &&
                                    (request.request.controller == response.controller))
                                {
                                    // There is a request pending
                                    return(request);
                                }
                            }
                            break;

                            case M_CURRENT_SUBCONTROLLER_STATE_QUERY:
                            {
                                if ((request.request.directive == response.directive) &&
                                    (request.request.controller == response.controller))
                                {
                                    // There is a request pending
                                    return(request);
                                }
                            }
                            break;

                            case M_CURRENT_PRESENCE_DETECTORS:
                            {
                                if ((request.request.directive == response.directive) &&
                                    (request.request.controller == response.controller))
                                {
                                    // There is a request pending
                                    return(request);
                                }
                            }
                            break;

                            case M_CURRENT_COUNTING_DETECTORS_DATETIME:
                            {
                            }
                            break;

                            case M_CURRENT_COUNTING_DETECTORS:
                            {
                                if (request.request.isCountingDetectorQuery() == true)
                                {
                                    // There is a request pending
                                    return(request);
                                }
                            }
                            break;

                            case M_ALARMS_QUERY:
                            {
                                if ((request.request.directive == response.directive) &&
                                    (request.request.controller == response.controller))
                                {
                                    // There is a request pending
                                    return(request);
                                }
                            }
                            break;

                            case M_BLOWN_LAMPS_ALARMS_QUERY:
                            {
                                if ((request.request.directive == response.directive) &&
                                    (request.request.controller == response.controller))
                                {
                                    // There is a request pending
                                    return(request);
                                }
                            }
                            break;

                            case M_DAMAGED_GROUP_ALARMS_QUERY:
                            {
                                if ((request.request.directive == response.directive) &&
                                    (request.request.controller == response.controller))
                                {
                                    // There is a request pending
                                    return(request);
                                }
                            }
                            break;

                            case M_INCOMPATIBILITY_ALARMS_QUERY:
                            {
                                if ((request.request.directive == response.directive) &&
                                    (request.request.controller == response.controller))
                                {
                                    // There is a request pending
                                    return(request);
                                }
                            }
                            break;

                            case M_CURRENT_STATUS_GROUPS_QUERY:
                            {
                                if ((request.request.directive == response.directive) &&
                                    (request.request.controller == response.controller))
                                {
                                    // There is a request pending
                                    return(request);
                                }
                            }
                            break;

                            case M_READ_TABLE_FULL:
                            {
                                if (print == true)
                                {
                                    Shared.println(name, "Received read full table: " + request.request.directive + " - " + response.directive + " - " + request.request.controller + " - " + response.controller + " - " + request.request.table + " - " + response.table);
                                }
                                if ((request.request.directive == response.directive) &&
                                    (request.request.controller == response.controller) &&
                                    (request.request.table == response.table))
                                {
                                    // There is a request pending
                                    return(request);
                                }
                            }
                            break;

                            case M_WRITE_TABLE_FULL:
                            {
                                if (print == true)
                                {
                                    Shared.println(name, "Received write full table: " + request.request.directive + " - " + response.directive + " - " + request.request.controller + " - " + response.controller + " - " + request.request.table + " - " + response.table);
                                }
                                if ((request.request.directive == response.directive) &&
                                    (request.request.controller == response.controller) &&
                                    (request.request.table == response.table))
                                {
                                    // There is a request pending
                                    return(request);
                                }
                            }
                            break;

                            case M_START_RECORDING:
                            {
                                if (print == true)
                                {
                                    Shared.println(name, "Received start recording tables: " + request.request.directive + " - " + response.directive + " - " + request.request.controller + " - " + response.controller + " - " + request.request.table + " - " + response.table);
                                }
                                if ((response.directive == M_START_RECORDING_RESPONSE) &&
                                    (request.request.controller == response.controller))
                                {
                                    // There is a request pending
                                    return(request);
                                }
                            }
                            break;

                            case M_END_RECORDING:
                            {
                                if (print == true)
                                {
                                    Shared.println(name, "Received end recording tables: " + request.request.directive + " - " + response.directive + " - " + request.request.controller + " - " + response.controller + " - " + request.request.table + " - " + response.table);
                                }
                                if ((response.directive == M_END_RECORDING_RESPONSE) &&
                                    (request.request.controller == response.controller))
                                {
                                    // There is a request pending
                                    return(request);
                                }
                            }
                            break;
                        }
                    }
                }
            }
        }
        catch (Exception e)
        {
            Shared.printstack(name, e); 
        }
        finally
        {
            mutexListRequest.releaseRead();
        }

        return(null);
    }




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

            socket = new Socket(address, port);
            socket.setSoTimeout(timeout);
            is = socket.getInputStream();
            os = socket.getOutputStream();

            if (this.connected == true)
            {
                String message = "Connected " + address + ":" + port + " - " + this.timeout;
                Shared.println(this.getName(), message);
            }

            this.connected = true;
            this.reconnections = this.reconnections + 1;
        }
        catch (Exception e)
        {
            Shared.println(name, Device.getDate(System.currentTimeMillis()) + " - " + address + ":" + port + " " + timeout + " - Exception : " + e.toString());
            Shared.println(this.getName(), e);
            try{disconnect();} catch (Exception ex){};
        }
    }




    public void disconnect() throws ServerException, 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;

        if (this.connected == true)
        {
            String message = "Disconnected " + address + ":" + port + " - " + this.timeout;
            Shared.println(this.getName(), message);
        }

        this.connected = false;
    }
    

        
    public M_Message read(byte[] command) throws ServerException, Exception
    {
        try
        {
            send(command);
            M_Message message = receive();
            if (print == true)
            {
                String s = this.address + ":" + this.port + " << ";
                Shared.println(name, Device.getDate(System.currentTimeMillis()) + " - " + s + message);
                if (trace == true)
                {
                    Shared.traceInformation(name, message.toString());
                }
            }
            return message;
        }
        catch (SocketException e)
        {
            if (print == true)
            {
                Shared.printstack(name, e);
                if (trace == true)
                {
                    Shared.traceError(name, "Read", e);
                }
            }

            disconnect();
            throw e;
        }
        catch (Exception e)
        {
            throw e;
        }
    }
     
    
    
    public void send(byte[] command) throws ServerException, Exception
    {
        if (print == true)
        {
            String s = this.address + ":" + this.port + " >>>>> ";
            String scommand = " >> ";
            for (int i=0; i<command.length; i++)
            {
                s += String.format("$%02X", command[i]);
                scommand += String.format("$%02X", command[i]);
            }
            Shared.println(name, Device.getDate(System.currentTimeMillis()) + " - " + s);
            if (trace == true)
            {
                Shared.traceInformation(name, scommand);
            }
        }
        socket.getOutputStream().write(command);
        socket.getOutputStream().flush();
    }
    
    
    
    public M_Message receive() throws ServerException, Exception
    {
       boolean salir = false;
       int res = 0;
       byte[] trama = null;

       int longitud = 0;

       try
       {
          while ((res = is.read()) == 0){sleep(10);};
    
          if (res != -1)
          {
               if (res == 0x11)
               {
                   while (res == 0x11)
                   {
                        res = is.read();
                   }
               }

               if (res == 0x06)
               {
                   M_Message message = new M_Message();
                   message.isAck = true;
                   int[] data = new int[1];
                   data[0] = res;
                   message.setData(data);
                   return(message);
               }

               if (res == 0x15)
               {
                   M_Message message = new M_Message();
                   message.isNack = true;
                   int[] data = new int[1];
                   data[0] = res;
                   message.setData(data);
                   return(message);
               }

               if ((res >= 0x30) && (res <= 0x3F))
               {
                   M_Message message = new M_Message();
                   message.isTrcam = true;
                   int[] data = new int[1];
                   data[0] = res;
                   message.setData(data);
                   return(message);
               }

               if (res == 0x02)
               {
                   int apuntador = 0;
                   trama = new byte[4096];
                   trama[apuntador] = (byte)res;
                   apuntador++;

                   // Obtenemos todos los datos disponibles
                   while (res != 0x03)
                   {
                        res = is.read();
                        trama[apuntador] = (byte)res;
                        apuntador++;
                   }

                   longitud = apuntador;
               }
          }
       }
       catch (SocketTimeoutException e)
       {
          this.timeouts = this.timeouts + 1;
          if (this.timeouts >= this.maxtimeouts)
          {
              Shared.println(name, Device.getDate(System.currentTimeMillis()) + " - " + this.address + ":" + this.port + " - 1.TIMEOUTS: " + this.timeouts + " - " + e.bytesTransferred + " - RES: " + res);
              this.timeouts = 0;
              Shared.printstack(name, e); 
              disconnect();
              throw new Exception(Shared.getMessage("Timeout Error"));
          }
       }
       catch (Exception e)
       {
          Shared.printstack(name, e);
          disconnect();
          throw e;
       }

       if (res == -1)
       {
          this.timeouts = this.timeouts + 1;
          if (this.timeouts >= this.maxtimeouts)
          {
              Shared.println(name, Device.getDate(System.currentTimeMillis()) + " - " + this.address + ":" + this.port + " - 2.TIMEOUTS: " + this.timeouts);
              this.timeouts = 0;
              disconnect();
          }

          throw new Exception(Shared.getMessage("Timeout Error"));
       }

       this.timeouts = 0;

       // Enviamos el resultado
       byte[] resultado = new byte[longitud];
       System.arraycopy(trama, 0, resultado, 0, longitud);
       M_Message message = new M_Message();
       message.setData(resultado);
       message.fillInformation();
       return(message);
    }    


    public void ack()
    {
        if (this.hasCRC == true)
        {
            byte[] ack = {0x06};
            try{send(ack);} catch (Exception e){};
        }
    }

}