package art.servers.colorsserver.controller;

import art.library.model.devices.Device;
import art.library.model.devices.colors.controller.M.M_Controller;
import art.library.utils.synchro.Mutex;
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 address = null;
    private int port = 0;
    private int timeout = 0;
    private boolean hasCRC = false;
    private 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>();


    public ControllerConnection (String address, int port, int timeout, boolean hasCRC)
    {
        this.address = address;
        this.port = port;
        this.timeout = this.timeout;
        this.hasCRC = hasCRC;
        this.setName(Shared.getMessage("Controller connection") + " " + address + ":" + port + "," + timeout + "," + hasCRC);
    }




    public void run ()
    {
        while ((isInterrupted() == false) && (exit == false))
        {
            try
            {
                connect();

                long millis = System.currentTimeMillis();
                clearM_Request();
                if (lrequest.size() > 10)
                {
                    System.out.println(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)
                    {
                        removeM_Request(request, response);
                    }
                    else
                    {
                        // Notification

                    }
                }
            }
            catch (Exception e)
            {
                
            }
            finally
            {
                try{sleep(50);} catch (Exception exception){};
            }
        }
    }


    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();
            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;

            for (M_Request request : lrequest)
            {
                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);
                        }
                    }

                    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;
                    }
                }
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        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();
            this.connected = true;
            // System.out.println(Device.getDate(System.currentTimeMillis()) + " - " + m_controller.getIdentifier() + " - Connected");
        }
        catch (Exception 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)
        {
            // System.out.println(Device.getDate(System.currentTimeMillis()) + " - " + m_controller.getIdentifier() + " - Disconnected");
        }

        this.connected = false;
    }
    

        
    public M_Message read(byte[] command) throws ServerException, Exception
    {
        try
        {
            send(command);
            return receive();
        }
        catch (SocketException e)
        {
            System.out.println(this.getName() + " Socket.EX.read: " + e.toString());
            disconnect();
            throw e;
        }
        catch (Exception e)
        {
            System.out.println(this.getName() + " EX.read: " + e.toString());
            e.printStackTrace();
            throw e;
        }
    }
     
    
    
    public void send(byte[] command) throws ServerException, Exception
    {
        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)
       {
          System.out.println(this.getName() + " Timeout.EX.rcv: " + e.toString());
       }
       catch (Exception e)
       {
          System.out.println(this.getName() + " EX.rcv: " + e.toString());
          e.printStackTrace();
          disconnect();
          throw e;
       }

       if (res == -1)
          throw new Exception(Shared.getMessage("Timeout Error"));

       // 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){};
        }
    }

}