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.servers.etdserver.Shared;
import java.io.InputStream;
import java.io.OutputStream;
import static java.lang.Thread.sleep;
import java.net.Socket;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import javax.xml.datatype.DatatypeFactory;
import javax.xml.datatype.XMLGregorianCalendar;
import javax.xml.ws.BindingProvider;
import trax.skp5.CheckSkpDataRequest;
import trax.skp5.CheckSkpDataResponse;
import trax.skp5.CheckSkpStatusRequest;
import trax.skp5.CheckSkpStatusResponse;
import trax.skp5.Response;
import trax.skp5.SkpAlarmRequest;
import trax.skp5.SkpData;
import trax.skp5.SkpPortType;
import trax.skp5.SkpPortTypeService;
import trax.skp5.SkpStatus;

public class ControllerSKP5 extends ControllerEtd
{
    private DatatypeFactory datatypeFactory = null;
    private SkpPortTypeService skpService = null;
    private SkpPortType skpPort = null;
    private boolean connected = false;

    
    
    private SimpleDateFormat sdh = new SimpleDateFormat("HH:mm");
    private Socket socket = null;
    private InputStream is = null;
    private OutputStream os = null;
    private long lastTimestamp = 0;
    private int status = DeviceStatus.STATUS_ALARM;


    public ControllerSKP5(Etd etd)
    {
        super(etd);
        this.device = etd;
        this.name = Shared.getMessage("Controller etd") + " " + etd.information.name;
    }
    
    
    public Etd getEtd()
    {
        return device;
    }
    
    
    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)
                {
                }
            }
           
            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 void connect()
    {
        try
        {
            EtdInformation etdInformation = (EtdInformation)device.getDeviceInformation();

            DatatypeFactory datatypeFactory = DatatypeFactory.newInstance();
            SkpPortTypeService skpService = new SkpPortTypeService();
            SkpPortType etdPort = skpService.getSkpPortType();
            String endpointURL = "http://" + etdInformation.connection.address + ":" + etdInformation.connection.port;
            BindingProvider bindingProvider = (BindingProvider)etdPort;
            bindingProvider.getRequestContext().put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, endpointURL);
            this.skpService = skpService;
            this.skpPort = etdPort;  // skpPort;
            this.datatypeFactory = datatypeFactory;
            this.connected = true;
        }
        catch (Exception exception)
        {
            String message = art.servers.Shared.getMessage("Skp offline");
            art.servers.Shared.println(name, exception);
            this.connected = false;
        }
    }


    
    

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

            // Status
            {
                CheckSkpStatusRequest request = new CheckSkpStatusRequest();
                request.setDateTime(getCalendar());
                request.setUserName(etdInformation.connection.user);
                request.setPassword(etdInformation.connection.password);
                request.setOperationCode("StatusRequest");
                request.setDateTime(getCalendar());
                request.setDeviceId(art.servers.Shared.getApplicationName());
                CheckSkpStatusResponse response = skpPort.checkSkpStatus(request);
                status(etdclone, response.getSkpStatus());
            }
            
            
            // Alarms
            {
                SkpAlarmRequest request = new SkpAlarmRequest();
                request.setDateTime(getCalendar());
                request.setUserName(etdInformation.connection.user);
                request.setPassword(etdInformation.connection.password);
                request.setOperationCode("AlarmRequest");
                request.setDateTime(getCalendar());
                request.setDeviceId(art.servers.Shared.getApplicationName());
                Response response = skpPort.skpAlarmEvent(request);
                /// TODO diria que es un error (no hay alarm event request)
            }
            
            // Data
            {
                CheckSkpDataRequest request = new CheckSkpDataRequest();
                request.setDateFrom(getCalendar(0));
                request.setDateTo(getCalendar(0));
                request.setUserName(etdInformation.connection.user);
                request.setPassword(etdInformation.connection.password);
                request.setOperationCode("DataRequest");
                request.setDateTime(getCalendar());
                request.setDeviceId(art.servers.Shared.getApplicationName());
                CheckSkpDataResponse response = skpPort.checkSkpData(request);
                data(device, response.getSkpData());
            }
            
            
            etdclone.setAlarm("alarm_offline", false);
            etdclone.setAlarm("alarm_invalid", false);
            art.servers.Shared.model.updateDevice(device, etdclone);
            return;
        }
        catch (Exception exception)
        {
            exception.printStackTrace();
            String message = art.servers.Shared.getMessage("Etd offline");
            art.servers.Shared.println(name, exception);
            this.connected = false;
        }
        
        
        if (etdclone.getAlarm("alarm_offline") <= 0)
        {
            etdclone.getDeviceAlarms().clear();
        }
        etdclone.setAlarm("alarm_offline", true); 
        art.servers.Shared.model.updateDevice(device, etdclone);
   }
    

    
    private void status(Etd etd, SkpStatus status)
    {
        // TODO
        
    }
    
    
    private void alarms(Etd etd, SkpData data)
    {
        // TODO
    }
    
    
    private void data(Etd etd, SkpData data)
    {
        // TODO 
        // Mirar si ha cambiado el periodo y si no lo tenemos actualizar
        // Si el periodo en information no coivide actualizamos el atributo
    }
    
    

    
   private XMLGregorianCalendar getCalendar()
   {
       return getCalendar(System.currentTimeMillis());
   }

   
   
   private XMLGregorianCalendar getCalendar(long timestamp)
   {
        XMLGregorianCalendar xmlGregorianCalendar = datatypeFactory.newXMLGregorianCalendar();
        {
            Calendar calendar = Calendar.getInstance();
            calendar.setTimeInMillis(timestamp);
            xmlGregorianCalendar.setYear(calendar.get(Calendar.YEAR));
            xmlGregorianCalendar.setMonth(calendar.get(Calendar.MONTH) + 1);
            xmlGregorianCalendar.setDay(calendar.get(Calendar.DAY_OF_MONTH));
            xmlGregorianCalendar.setHour(calendar.get(Calendar.HOUR_OF_DAY));
            xmlGregorianCalendar.setMinute(calendar.get(Calendar.MINUTE));
            xmlGregorianCalendar.setSecond(calendar.get(Calendar.SECOND));
            xmlGregorianCalendar.setMillisecond(0);
            xmlGregorianCalendar.setTimezone(0);
        }
        
        return xmlGregorianCalendar;
   }
    
    

        

}