package art.servers.rtzserver.controller.RTZ32;

import art.library.model.devices.colors.controller.RTZ32.RTZ32_ControllerCommands;
import art.library.model.devices.colors.controller.RTZ32.commands.RTZ32_Commands_Computer;
import art.library.model.devices.colors.controller.RTZ32.commands.RTZ32_Commands_Plan;
import art.library.model.devices.colors.controller.RTZ32.configuration.tables.RTZ32_Configuration_Table;
import art.library.utils.synchro.Mutex;
import art.servers.Shared;
import java.io.DataOutputStream;
import java.net.Socket;
import java.util.Calendar;




public class RTZ32_Talker_Writer 
{
     private RTZ32_Talker talker = null; 
     private DataOutputStream dosData = null;
     private DataOutputStream dosControl = null;
     private Writer writer = null;
     private Mutex mutexData = new Mutex();
     private Mutex mutexControl = new Mutex();
     private String name = null;
     
     
     public RTZ32_Talker_Writer(RTZ32_Talker talker, Socket socketData, Socket socketControl) throws Exception
     {
         this.talker = talker;
         this.dosData = new DataOutputStream(socketData.getOutputStream());
         this.dosControl = new DataOutputStream(socketControl.getOutputStream());
         this.writer = new Writer();
         this.name = this.talker.name + " (Writer)";
     }

     
    
    //<editor-fold desc="Control">
    

     public void CTRL_DC1() throws Exception
     {
         Shared.println(this.name, "> DC1");
         dosControl.write(0x11);
         dosControl.flush();
     }
    
     public void CTRL_ACK() throws Exception
     {
         Shared.println(this.name, "> ACK");
         dosControl.write(0x06);
         dosControl.flush();
     }
    
     public void CTRL_NACK() throws Exception
     {
         Shared.println(this.name, "> NACK");
         dosControl.write(0x15);
         dosControl.flush();
     }
    
     public void CTRL_DET() throws Exception
     {
         Shared.println(this.name, "> DET");
         dosControl.write(0x20);
         dosControl.flush();
     }

     public void CTRL_HTR() throws Exception
     {
         Shared.println(this.name, "> HTR");
         dosControl.write(0x33);
         dosControl.flush();
     }
    
     public void CTRL_SYNC() throws Exception
     {
         Shared.println(this.name, "> SYN");
         dosControl.write(0x40);
         dosControl.flush();
     }
    
     
    

    //</editor-fold>
    
    
    
    //<editor-fold desc="Orders">

     public void ORD_LOCAL_ORDENADOR(Integer control) throws Exception
     {
         mutexData.lockWrite();
         
         try
         {
            if (control == RTZ32_ControllerCommands.CONTROL_LOCAL)
            {
               writer.initialise(0x31);
               writer.flush(dosData);
            }
            else if (control == RTZ32_ControllerCommands.CONTROL_COMPUTER)
            {
               writer.initialise(0x32);
               writer.flush(dosData);
            }
         }
         finally
         {
            mutexData.releaseWrite();
         }
     }
     

     
     public void ORD_GRABACION(boolean value) throws Exception
     {
         mutexData.lockWrite();
         
         try
         {
            // TODO:
            // Por donde llega la respuesta a esta orden?
            talker.mutex_ORD_GRABACION = new Mutex();
            talker.mutex_ORD_GRABACION.lockWrite();
            if (value == true)
            {
               writer.initialise(0x34);
               writer.flush(dosData);
            }
            else
            {
               writer.initialise(0x35);
               writer.flush(dosData);
            }
            talker.mutex_ORD_GRABACION.lockWrite(talker.rtz32.getDeviceInformation().connection.readTimeout);
         }
         finally
         {
            mutexData.releaseWrite();
         }
     }


     

     public void ORD_FH(long timestamp) throws Exception
     {
         mutexData.lockWrite();
         
         try
         {
            writer.initialise(0x39);
            Calendar calendar = Calendar.getInstance();
            calendar.setTimeInMillis(timestamp);
            writer.write(calendar.get(Calendar.SECOND));
            writer.write(calendar.get(Calendar.MINUTE));
            writer.write(calendar.get(Calendar.HOUR_OF_DAY));
            writer.write(calendar.get(Calendar.DAY_OF_WEEK));
            writer.write(calendar.get(Calendar.DATE));
            writer.write(calendar.get(Calendar.MONTH + 1));
            writer.write(calendar.get(Calendar.YEAR) - 2000);
            writer.flush(dosData);
         }
         finally
         {
            mutexData.releaseWrite();
         }
     }
     

     public void ORD_DETECTORES(boolean value) throws Exception
     {
         mutexData.lockWrite();
         
         try
         {
            if (value == true)
            {
                // TODO
   //            for (RTZ32_Configuration_Detector detector : talker.controller.getController().getDeviceConfiguration().rtz32.detectors)
   //            {
   //                writer.initialise(0x3A);
   //                writer.write(detector.number);
   //                writer.flush(dosData);
   //            }
            }
            else
            {
               writer.initialise(0x3B);
               writer.flush(dosData);
            }
         }
         finally
         {
            mutexData.releaseWrite();
         }
         
     }          


     
     public void ORD_PLAN(RTZ32_Commands_Plan plan) throws Exception
     {
         mutexData.lockWrite();
         
         try
         {
            Shared.println(this.name, "> ORD PLAN " + plan.number + ", offset " + plan.offset);
            writer.initialise(0x41);
            writer.write(plan.number);
            writer.write(plan.offset);
            writer.flush(dosData);
         }
         finally
         {
            mutexData.releaseWrite();
         }
     }
     
     
     public void ORD_COLORES(int value) throws Exception
     {
         mutexData.lockWrite();
         
         try
         {
            switch (value)
            {
                case RTZ32_ControllerCommands.COLORS_MODE_COLORS:
                     writer.initialise(0x44);
                     writer.flush(dosData);
                     break;

                case RTZ32_ControllerCommands.COLORS_MODE_FLASHING:
                     writer.initialise(0x43);
                     writer.flush(dosData);
                     break;
            }
         }
         finally
         {
            mutexData.releaseWrite();
         }
     }
     
     
     
     public void ORD_BORRADO_ALARMAS(boolean value) throws Exception
     {
         mutexData.lockWrite();
         
         try
         {
            if (value == true)
            {
               writer.initialise(0x45);
               writer.flush(dosData);
            }
         }
         finally
         {
            mutexData.releaseWrite();
         }
     }
     
          
     public void ORD_COMMS(boolean value) throws Exception
     {
         mutexData.lockWrite();
         
         try
         {
            if (value == true)
            {
               writer.initialise(0x4C);
               writer.flush(dosData);
            }
            else
            {
               writer.initialise(0x4B);
               writer.flush(dosData);
            }
         }
         finally
         {
            mutexData.releaseWrite();
         }
     }
     
     
     
     public void ORD_TIEMPO_REAL_CRUCE(boolean value) throws Exception
     {
         mutexData.lockWrite();
         
         try
         {
            if (value == true)
            {
               writer.initialise(0x52);
               writer.flush(dosData);
            }
            else
            {
               writer.initialise(0x53);
               writer.flush(dosData);
            }

           talker.rtz32.getDeviceRealtime().rtz32.junctionRealtime = value;
           talker.listener.realtimeUpdate();
         }
         finally
         {
            mutexData.releaseWrite();
         }
     }
     
     
     
     
     public void ORD_ORDENADOR(RTZ32_Commands_Computer computer) throws Exception
     {
         mutexData.lockWrite();
         
         try
         {
            writer.initialise(0x55);
            int value = computer.synchronism;
            if (computer.semiactuated == true) value = value + 0x08;
            if (computer.actuated == true) value = value + 0x10;
            value = computer.trolleyDemands << 6;
            writer.write(value);
            writer.flush(dosData);
         }
         finally
         {
            mutexData.releaseWrite();
         }
     }

     

     public void ORD_TABLA(RTZ32_Configuration_Table table, byte[] data) throws Exception
     {
         mutexData.lockWrite();
         
         try
         {
            talker.mutex_ORD_TABLA = new Mutex();
            talker.mutex_ORD_TABLA.lockWrite();
            writer.initialise(0x3E);
            writer.write(table.number);
            writer.write(data);
            writer.flush(dosData);
            talker.mutex_ORD_TABLA.lockWrite(talker.rtz32.getDeviceInformation().connection.readTimeout);
         }
         finally
         {
            mutexData.releaseWrite();
         }
     }     
               
     

     //</editor-fold>

     
     

     //<editor-fold desc="Requests">

     public void PET_DETECTORES() throws Exception
     {
         mutexData.lockWrite();
         
         try
         {
            talker.mutex_PET_DETECTORES = new Mutex();
            talker.mutex_PET_DETECTORES.lockWrite();
            writer.initialise(0x33);
            writer.flush(dosData);
            talker.mutex_PET_DETECTORES.lockWrite(talker.rtz32.getDeviceInformation().connection.readTimeout);
         }
         finally
         {
            mutexData.releaseWrite();
         }
     }
          

     public void PET_PLAN_DESFASE() throws Exception
     {
         mutexData.lockWrite();
         
         try
         {
            talker.mutex_PET_PLAN_DESFASE = new Mutex();
            talker.mutex_PET_PLAN_DESFASE.lockWrite();
            writer.initialise(0x36);
            writer.flush(dosData);
            talker.mutex_PET_PLAN_DESFASE.lockWrite(talker.rtz32.getDeviceInformation().connection.readTimeout);
         }
         finally
         {
            mutexData.releaseWrite();
         }
     }     
     
     
     public void PET_ESTADO() throws Exception
     {
         mutexData.lockWrite();
         
         try
         {
            talker.mutex_PET_ESTADO = new Mutex();
            talker.mutex_PET_ESTADO.lockWrite();
            writer.initialise(0x37);
            writer.flush(dosData);
            talker.mutex_PET_ESTADO.lockWrite(talker.rtz32.getDeviceInformation().connection.readTimeout);
         }
         finally
         {
            mutexData.releaseWrite();
         }
     }     
     

     public void PET_ALARMAS(int code) throws Exception
     {        
         mutexData.lockWrite();
         
         try
         {
            Shared.println(this.name, "> PET_ALARMAS " + code); 
            talker.mutex_PET_ALARMAS = new Mutex();
            talker.mutex_PET_ALARMAS.lockWrite();
            writer.initialise(0x5A);
            writer.write(code);
            writer.flush(dosData);
            talker.mutex_PET_ALARMAS.lockWrite(talker.rtz32.getDeviceInformation().connection.readTimeout);
         }
         finally
         {
            mutexData.releaseWrite();
         }
     }          
     
     
     public void PET_FH() throws Exception
     {
         mutexData.lockWrite();
         
         try
         {
            talker.mutex_PET_FH = new Mutex();
            talker.mutex_PET_FH.lockWrite();
            writer.initialise(0x38);
            writer.flush(dosData);
            talker.mutex_PET_FH.lockWrite(talker.rtz32.getDeviceInformation().connection.readTimeout);
         }
         finally
         {
            mutexData.releaseWrite();
         }
     }
     

     public void PET_TABLA(int tabla) throws Exception
     {
         mutexData.lockWrite();
         
         try
         {
            talker.mutex_PET_TABLA = new Mutex();
            talker.mutex_PET_TABLA.lockWrite();
            writer.initialise(0x3C);
            writer.write(tabla);
            writer.flush(dosData);
            talker.mutex_PET_TABLA.lockWrite(talker.rtz32.getDeviceInformation().connection.readTimeout);
         }
         finally
         {
            mutexData.releaseWrite();
         }     
     }     
          
     

     public void PET_VERSION() throws Exception
     {
         mutexData.lockWrite();
         
         try
         {
            talker.mutex_PET_VERSION = new Mutex();
            talker.mutex_PET_VERSION.lockWrite();
            writer.initialise(0x3F);
            writer.flush(dosData);
            talker.mutex_PET_VERSION.lockWrite(talker.rtz32.getDeviceInformation().connection.readTimeout);
         }
         finally
         {
            mutexData.releaseWrite();
         }     
     }


     
     public void PET_CONTADORES() throws Exception
     {
         mutexData.lockWrite();
         
         try
         {
            talker.mutex_PET_CONTADORES = new Mutex();
            talker.mutex_PET_CONTADORES.lockWrite();
            writer.initialise(0x4F);
            writer.flush(dosData);
            talker.mutex_PET_CONTADORES.lockWrite(talker.rtz32.getDeviceInformation().connection.readTimeout);
         }
         finally
         {
            mutexData.releaseWrite();
         }     
     }
          
     
     public void PET_GRUPOS() throws Exception
     {
         mutexData.lockWrite();
         
         try
         {
            talker.mutex_PET_GRUPO = new Mutex();
            talker.mutex_PET_GRUPO.lockWrite();
            writer.initialise(0x50);
            writer.flush(dosData);
            talker.mutex_PET_GRUPO.lockWrite(talker.rtz32.getDeviceInformation().connection.readTimeout);
         }
         finally
         {
            mutexData.releaseWrite();
         }     
     }
          
     
     
     public void PET_GRUPO(int grupo) throws Exception
     {
         mutexData.lockWrite();
         
         try
         {
            talker.mutex_PET_GRUPO = new Mutex();
            talker.mutex_PET_GRUPO.lockWrite();
            writer.initialise(0x50);
            writer.write(grupo);
            writer.flush(dosData);
            talker.mutex_PET_GRUPO.lockWrite(talker.rtz32.getDeviceInformation().connection.readTimeout);
         }
         finally
         {
            mutexData.releaseWrite();
         }     
     }
          
     
     //</editor-fold>

     
     
     
     
     private class Writer
     {
         private byte[] data = new byte[8192];
         private int position = 0;
         private int CRC = 0;
         
         
         public Writer()
         {
         }
         
         public void initialise(int method)
         {
             position = 0;
             CRC = method;
             data[position++] = RTZ32_Talker.STX;
             data[position++] = (byte)(method + 0x80);
         }
         
         
         public void write(int value) throws Exception
         {
            CRC = CRC ^ value;
            data[position++] = (byte)(0x80 + value);
         }
         
         public void write(int[] value) throws Exception
         {
            for (int i=0; i<value.length; i++)
            {
                write(value[i]);
            }
         }
         

         public void write(byte[] value) throws Exception
         {
            for (int i=0; i<value.length; i++)
            {
                write(value[i]);
            }
         }
                  
         
         public void flush(DataOutputStream dosData) throws Exception
         {
             try
             {
                data[position++] = (byte)(CRC  + 0x80);
                data[position++] = RTZ32_Talker.ETX;

                String message = "> ";

                for (int i=0; i<position; i++)
                {
                    //(message = message + String.format("%02X", data[i] & 0x7F) + " ";
                    message = message + String.format("%02X", data[i]) + " ";
                }

                Shared.println(name, message);
                dosData.write(data, 0, position);
                dosData.flush();
             }
             catch (Exception exception)
             {
                 talker.disconnect(7);
                 throw exception;
             }
         }
     }

     
     
     

}