package art.servers.colorsserver.M.protocol;


import art.library.interop.serialization.Serialization;
import art.library.model.devices.colors.controller.M.M_Controller;
import art.library.model.devices.colors.controller.M.M_ControllerInformation;
import art.library.model.devices.colors.controller.M.configuration.SPTP.M_SPTP_Configuration;
import art.library.model.devices.colors.controller.M.configuration.SPTP.M_SPTP_ConfigurationBusLocalPreferenceOperation;
import art.library.model.devices.colors.controller.M.configuration.SPTP.M_SPTP_ConfigurationTimetableLocalPreferenceOperation;
import art.library.model.devices.colors.controller.M.configuration.SPTP.M_SPTP_Configuration_BusLineAreaConfiguration;
import art.library.model.devices.colors.controller.M.tables.M_Table;
import art.library.model.devices.colors.controller.M.tables.M_TableWriter;
import art.library.model.devices.colors.controller.M.tables.subcontroller.SPTP.M_Table_SPTP_BusLineAreaConfiguration;
import art.library.model.devices.colors.controller.M.tables.subcontroller.SPTP.M_Table_SPTP_BusLocalPreferenceOperation;
import art.library.model.devices.colors.controller.M.tables.subcontroller.SPTP.M_Table_SPTP_GeneralParameters;
import art.library.model.devices.colors.controller.M.tables.subcontroller.SPTP.M_Table_SPTP_TimetableLocalPreferenceOperation;
import art.servers.ColorsServer;
import art.servers.colorsserver.Shared;
import art.servers.colorsserver.controller.ControllerController;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;


public class M_ControllerComunicator extends Thread
{
//    private Socket socket = null;
//    private InputStream is = null;
//    private OutputStream os = null;
    private boolean hasCRC = false;
    private M_Controller m_controller = null;
    private ControllerController controllerController = null;


    public M_ControllerComunicator(M_Controller m_controller, ControllerController controllerController)
    {
        this.m_controller = m_controller;
        this.controllerController = controllerController;
//        this.socket = socket;
//        try{this.socket.setSoTimeout(15000);} catch (Exception e){};
//        try{this.is = socket.getInputStream();} catch (Exception e){};
//        try{this.os = socket.getOutputStream();} catch (Exception e){};
        this.hasCRC = controllerController.hasCRC;
    }




    public void run()
    {
    }
    


    public void writeSPTPTables(int subcontroller, String configurationCode, String controllerNumber, M_SPTP_Configuration configuration) throws Exception
    {
        try
        {
            startRecordingTables(configurationCode, controllerNumber);

            if (this.m_controller.getDeviceInformation().type == M_ControllerInformation.TYPE_DYNAMIC)
            {
                writeTable(subcontroller, configuration, 0x4A);
                writeTable(subcontroller, configuration, 0x4B);
                writeTable(subcontroller, configuration, 0x4C);
                writeTable(subcontroller, configuration, 0x4D);
            }
            else
            {
                writeTable(subcontroller, configuration, M_Table.M_TABLE_SPTP_GENERAL_PARAMETERS);
                writeTable(subcontroller, configuration, M_Table.M_TABLE_SPTP_BUS_LINE_AREA_CONFIGURATION);
                writeTable(subcontroller, configuration, M_Table.M_TABLE_SPTP_BUS_LOCAL_PREFERENCE_OPERATION);
                writeTable(subcontroller, configuration, M_Table.M_TABLE_SPTP_TIMETABLE_LOCAL_PREFERENCE_OPERATION);
            }

        }
        catch (Exception e)
        {
            Shared.printstack("Comunicator", e);
            throw e;
        }
        finally
        {
            endRecordingTables();
        }
    }


    public void writeTable(int subcontroller, M_SPTP_Configuration configuration, int tableCode) throws Exception
    {
        List<Byte> lTableContent = new ArrayList<Byte>();
        switch (tableCode)
        {
            case M_Table.M_TABLE_SPTP_GENERAL_PARAMETERS:
            {
                M_Table_SPTP_GeneralParameters m_table = new M_Table_SPTP_GeneralParameters();
                byte[] data = m_table.serialize(subcontroller, configuration);
                for (int i=0; i<data.length; i++) lTableContent.add(new Byte(data[i]));
            }
            break;

            case M_Table.M_TABLE_SPTP_BUS_LINE_AREA_CONFIGURATION:
            {
                M_Table_SPTP_BusLineAreaConfiguration m_table = new M_Table_SPTP_BusLineAreaConfiguration();
                byte[] data = m_table.serialize(subcontroller, configuration);
                for (int i=0; i<data.length; i++) lTableContent.add(new Byte(data[i]));

                if (ColorsServer.TEST_SPTP == true)
                {
                    byte[] res = new byte[data.length-4];
                    System.arraycopy(data, 3, res, 0, res.length);
                    List<M_SPTP_Configuration_BusLineAreaConfiguration> l = new M_Table_SPTP_BusLineAreaConfiguration().deserialize(res);
                    Shared.println("Comunicator", ">>>>>>>>>>>>>>>>>>>>>>>> " + Serialization.toPrettyString(l));
                }
            }
            break;

            case M_Table.M_TABLE_SPTP_BUS_LOCAL_PREFERENCE_OPERATION:
            {
                M_Table_SPTP_BusLocalPreferenceOperation m_table = new M_Table_SPTP_BusLocalPreferenceOperation();
                byte[] data = m_table.serialize(subcontroller, configuration);
                for (int i=0; i<data.length; i++) lTableContent.add(new Byte(data[i]));

                if (ColorsServer.TEST_SPTP == true)
                {
                    byte[] res = new byte[data.length-4];
                    System.arraycopy(data, 3, res, 0, res.length);
                    List<M_SPTP_ConfigurationBusLocalPreferenceOperation> l = new M_Table_SPTP_BusLocalPreferenceOperation().deserialize(res);
                    Shared.println("Comunicator", ">>>>>>>>>>>>>>>>>>>>>>>> " + Serialization.toPrettyString(l));
                }
            }
            break;

            case M_Table.M_TABLE_SPTP_TIMETABLE_LOCAL_PREFERENCE_OPERATION:
            {
                M_Table_SPTP_TimetableLocalPreferenceOperation m_table = new M_Table_SPTP_TimetableLocalPreferenceOperation();
                byte[] data = m_table.serialize(subcontroller, configuration);
                for (int i=0; i<data.length; i++) lTableContent.add(new Byte(data[i]));

                if (ColorsServer.TEST_SPTP == true)
                {
                    byte[] res = new byte[data.length-4];
                    System.arraycopy(data, 3, res, 0, res.length);
                    List<M_SPTP_ConfigurationTimetableLocalPreferenceOperation> l = new M_Table_SPTP_TimetableLocalPreferenceOperation().deserialize(res);
                    Shared.println("Comunicator", ">>>>>>>>>>>>>>>>>>>>>>>> " + Serialization.toPrettyString(l));
                }
            }
            break;

            case 0x4A:
            {
                M_Table_SPTP_GeneralParameters m_table = new M_Table_SPTP_GeneralParameters();
                byte[] data = m_table.serialize(subcontroller, configuration);
                data[2] = (byte)(0xCA);
                for (int i=0; i<data.length; i++) lTableContent.add(new Byte(data[i]));
            }
            break;

            case 0x4B:
            {
                M_Table_SPTP_BusLineAreaConfiguration m_table = new M_Table_SPTP_BusLineAreaConfiguration();
                byte[] data = m_table.serialize(subcontroller, configuration);
                data[2] = (byte)(0xCB);
                for (int i=0; i<data.length; i++) lTableContent.add(new Byte(data[i]));
            }
            break;

            case 0x4C:
            {
                M_Table_SPTP_BusLocalPreferenceOperation m_table = new M_Table_SPTP_BusLocalPreferenceOperation();
                byte[] data = m_table.serialize(subcontroller, configuration);
                data[2] = (byte)(0xCC);
                for (int i=0; i<data.length; i++) lTableContent.add(new Byte(data[i]));
            }
            break;

            case 0x4D:
            {
                M_Table_SPTP_TimetableLocalPreferenceOperation m_table = new M_Table_SPTP_TimetableLocalPreferenceOperation();
                byte[] data = m_table.serialize(subcontroller, configuration);
                data[2] = (byte)(0xCD);
                for (int i=0; i<data.length; i++) lTableContent.add(new Byte(data[i]));
            }
            break;
        }

        if (lTableContent.size() <= 0) return;

        M_Message message = M_ProtocolConstructor.writeTableMessage(subcontroller, lTableContent, hasCRC);
        byte[] cmd = message.toByteArray();
        String s = "Write table (" + tableCode + ") >> ";
        for (int i=0; i<cmd.length; i++)
        {
            s += String.format(" %02X", cmd[i]);
        }
        Shared.traceInformation("Comunicator", s);

        if (ColorsServer.TEST_SPTP == false)
        {
            // M_Message response = read(command);
            M_Request request = new M_Request();
            request.controller = this.controllerController;
            request.request = message;

            this.controllerController.getControllerConnection().addM_Request(request);
            request.waitResponse(this.m_controller.getDeviceInformation().timeout);
            M_Message response = request.response;

            boolean salir = false;
            while (salir == false)
            {
                if (M_ProtocolAnalyser.isACKMessage(response) == true)
                {
                    salir = true;
                }
                else if (M_ProtocolAnalyser.isNACKMessage(response) == true)
                {
                    throw new Exception(Shared.getMessage("Error sending table %1 (nack)").replaceAll("%1", "" + tableCode));
                }
                else
                {
                    // response = read(new byte[0]);
                    request = new M_Request();
                    request.controller = this.controllerController;
                    request.request = message;

                    this.controllerController.getControllerConnection().addM_Request(request);
                    request.waitResponse(this.m_controller.getDeviceInformation().timeout);
                    response = request.response;
                }
            }
        }
    }
    

    public void writeEmptyTable(int controller, int tableCode) throws Exception
    {
        List<Byte> lTableContent = new ArrayList<Byte>();
        M_TableWriter writer = new M_TableWriter();
        writer.STX();
        writer.write(controller);
        writer.write(tableCode);
        writer.EOB12();
        writer.ETX();
        byte[] content = writer.toByteArray();
        for (int i=0; i<content.length; i++)
            lTableContent.add(new Byte(content[i]));

        M_Message message = M_ProtocolConstructor.writeTableMessage(controller, lTableContent, hasCRC);
        // M_Message response = read(command);
        M_Request request = new M_Request();
        request.controller = this.controllerController;
        request.request = message;

        this.controllerController.getControllerConnection().addM_Request(request);
        request.waitResponse(this.m_controller.getDeviceInformation().timeout);
        M_Message response = request.response;

        boolean salir = false;
        while (salir == false)
        {
            if (M_ProtocolAnalyser.isACKMessage(response) == true)
            {
                salir = true;
            }
            else if (M_ProtocolAnalyser.isNACKMessage(response) == true)
            {
                throw new Exception(Shared.getMessage("Error sending table %1 (nack)").replaceAll("%1", "" + tableCode));
            }
            else
            {
                // response = read(new byte[0]);
                request = new M_Request();
                request.controller = this.controllerController;
                request.request = message;

                this.controllerController.getControllerConnection().addM_Request(request);
                request.waitResponse(this.m_controller.getDeviceInformation().timeout);
                response = request.response;
            }
        }
    }



    
    private void startRecordingTables(String configurationCode, String controllerNumber) throws Exception
    {
        M_Message message = M_ProtocolConstructor.startRecordingTablesMessage(0x00, configurationCode, controllerNumber, hasCRC);
        byte[] cmd = message.toByteArray();
        String s = "Start recording >> ";
        for (int i=0; i<cmd.length; i++)
        {
            s += String.format(" %02X", cmd[i]);
        }
        Shared.traceInformation("Comunicator", s);

        if (ColorsServer.TEST_SPTP == false)
        {
            // M_Message response = read(command);
            M_Request request = new M_Request();
            request.controller = this.controllerController;
            request.request = message;

            this.controllerController.getControllerConnection().addM_Request(request);
            request.waitResponse(this.m_controller.getDeviceInformation().timeout);
            M_Message response = request.response;

            boolean salir = false;
            while (salir == false)
            {
                if (M_ProtocolAnalyser.isStartRecordingResponse(response) == true)
                {
                    salir = true;
                }
                else if (M_ProtocolAnalyser.isNACKMessage(response) == true)
                {
                    throw new Exception(Shared.getMessage("Error starting recording (nack)"));
                }
                else
                {
                    // response = read(new byte[0]);
                    request = new M_Request();
                    request.controller = this.controllerController;
                    request.request = message;

                    this.controllerController.getControllerConnection().addM_Request(request);
                    request.waitResponse(this.m_controller.getDeviceInformation().timeout);
                    response = request.response;
                }
            }
        }
    }


    private void endRecordingTables() throws Exception
    {
        M_Message message = M_ProtocolConstructor.endRecordingTablesMessage(0x00, hasCRC);
        byte[] cmd = message.toByteArray();
        controllerController.getControllerConnection().socket.setSoTimeout(60000);
        String s = "End recording >> ";
        for (int i=0; i<cmd.length; i++)
        {
            s += String.format(" %02X", cmd[i]);
        }
        Shared.traceInformation("Comunicator", s);

        if (ColorsServer.TEST_SPTP == false)
        {
            // M_Message response = read(command);
            M_Request request = new M_Request();
            request.controller = this.controllerController;
            request.request = message;

            this.controllerController.getControllerConnection().addM_Request(request);
            request.waitResponse(this.m_controller.getDeviceInformation().timeout);
            M_Message response = request.response;

            boolean salir = false;
            while (salir == false)
            {
                if (M_ProtocolAnalyser.isEndRecordingResponse(response) == true)
                {
                    M_ProtocolAnalyser.analyseEndRecordingResponse(response);
                    salir = true;
                }
                else if (M_ProtocolAnalyser.isNACKMessage(response) == true)
                {
                    throw new Exception(Shared.getMessage("End recording response is NACK"));
                }
                else
                {
                    // response = read(new byte[0]);
                    request = new M_Request();
                    request.controller = this.controllerController;
                    request.request = message;

                    this.controllerController.getControllerConnection().addM_Request(request);
                    request.waitResponse(this.m_controller.getDeviceInformation().timeout);
                    response = request.response;
                }
            }
        }
    }


//    private M_Message read(byte[] command) throws Exception
//    {
//        try
//        {
//            if (command.length > 0)
//                send(command);
//            return receive();
//        }
//        catch (Exception e)
//        {
//            throw e;
//        }
//    }
//     
//    
//    
//    private void send(byte[] command) throws Exception
//    {
//        socket.getOutputStream().write(command);
//        socket.getOutputStream().flush();
//    }
//    
//    
//    
//    private M_Message receive() throws 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 == 0x06) || (res == 0x15) || ((res >= 0x30) && (res <= 0x3F)))
//               {
//                   M_Message message = new M_Message();
//                   int[] result = new int[1];
//                   result[0] = res;
//                   message.setData(result);
//                   return(message);
//               }
//
//               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 (Exception e)
//       {
//          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);
//       return(message);
//    }    

}