package art.servers.controller;

import art.library.interop.InteropParameter;
import art.library.interop.InteropParameters;
import art.library.interop.InteropResponse;
import art.library.interop.serialization.Serialization;
import art.library.interop.serialization.SerializationException;
import art.library.model.devices.Device;
import art.library.model.devices.application.ApplicationInformation;
import art.servers.Shared;
import art.servers.configuration.ConfigurationTransactions;
import art.servers.configuration.ConfigurationTransactionsService;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ControllerTransactions extends Controller 
{
    private ConfigurationTransactions configuration = null;
    private ApplicationInformation[] lapplication = new ApplicationInformation[0];
    private ConfigurationTransactionsService currentTransactionsService = null;

    
    public ControllerTransactions(ConfigurationTransactions configuration)
    {
        this.configuration = configuration;
        this.setName("Controller transactions");
        start();
    }
    
    
    
    public ApplicationInformation[] getApplications()
    {
        return lapplication;
    }
    
    
    
    public ApplicationInformation[] getApplications(String service)
    {
        List<ApplicationInformation> result = new ArrayList<ApplicationInformation>();
        
        for (ApplicationInformation applicationInformation : lapplication)
        {
            if ((applicationInformation.serverServiceName != null)  && (applicationInformation.serverServiceName.equals(service)))
            {
                result.add(applicationInformation);
            }
        }
        
        return result.toArray(new ApplicationInformation[result.size()]);
    }
    
    
    
    
    
    public void run()
    {
        Shared.traceInformation(configuration.name, "Starting");
        
        long lastTimestamp = System.currentTimeMillis();
        
        while ((isInterrupted() == false) && (exit == false))
        {
            if (Shared.isServerEnabled() == true)
            {
                try
                {
                    // reload
                    
                    reload();
                    
                    // Wait 

                    long timesleep = (configuration.polling * 1000) - (System.currentTimeMillis() - lastTimestamp);

                    if ((timesleep > 0) && (timesleep < (configuration.polling * 1000)))
                    {
                        sleep(timesleep);
                    }

                    // Update devices

                    long currentTimestamp = System.currentTimeMillis();
                    lastTimestamp = currentTimestamp;
                }
                catch (Exception e)
                {
                }
            }
        }
        
        Shared.traceInformation(configuration.name, "Finishing");
    }


    
    
    
    
    
    private void reload()
    {
        for (ConfigurationTransactionsService configurationTransactionsService : configuration.lservicesTransactions)
        {
            try
            {
                InteropParameters parameters = new InteropParameters();
                parameters.addParameter(new InteropParameter("operation", "getApplicationsInformation"));
                parameters.addParameter(new InteropParameter("language", Shared.configuration.general.language));
                InteropResponse response = (InteropResponse)Serialization.invoke("get", parameters, configurationTransactionsService.address, configurationTransactionsService.port, configurationTransactionsService.timeout);
                ApplicationInformation[] lapplication = Arrays.copyOf(response.getValue(), response.getValue().length, ApplicationInformation[].class);
                
                if (lapplication.length > 0) 
                {
                    currentTransactionsService = configurationTransactionsService;
                    this.lapplication = lapplication;
                    return;
                }
            }
            catch (Exception exception)
            {
                exception.printStackTrace();
            }
        }
    }
    
    
    
    
    
    public InteropResponse set (InteropParameters parameters) throws  SerializationException
    {
        try
        {
            return (InteropResponse)Serialization.invoke("set", parameters, currentTransactionsService.address, currentTransactionsService.port, currentTransactionsService.timeout);
        }
        catch (Exception exception)
        {
        }
        
        throw new SerializationException("Operation error (transactions server)");
    }
    
    
    
    
    
    public InteropResponse get (InteropParameters parameters) throws  SerializationException
    {
        try
        {
            return (InteropResponse)Serialization.invoke("get", parameters, currentTransactionsService.address, currentTransactionsService.port, currentTransactionsService.timeout);
        }
        catch (Exception exception)
        {
        }
        
        throw new SerializationException("Operation error (transactions server)");
    }
    
    
    
    
    
    
    
    
    public Device getDevice(String service, String identifier) throws SerializationException
    {
        try
        {
            for (ApplicationInformation application : getApplications(service))
            {
                try
                {
                    InteropParameters parameters = new InteropParameters();
                    parameters.addParameter(new InteropParameter("service", application.serverServiceName));
                    parameters.addParameter(new InteropParameter("operation", "getDevice"));
                    parameters.addParameter(new InteropParameter("identifier", identifier));
                    parameters.addParameter(new InteropParameter("language", Shared.configuration.general.language));
                    InteropResponse response = (InteropResponse)Serialization.invoke("get", parameters, application.serverAddress, application.serverPort, 30000);
                    return (Device)response.getValue()[0];
                }
                catch (Exception exception)
                {
                }
            }
        }
        catch (Exception e)
        {
        }
        
        throw new SerializationException("Device not found");
    }
    
    
    
    public List<Device> getDevices(String service) throws SerializationException
    {
        List<Device> result = new ArrayList<Device>();
        ApplicationInformation[] applications = getApplications(service);

        for (ApplicationInformation application : applications)
        {
            if (service.equalsIgnoreCase(application.serverServiceName))
            {
                try
                {
                    InteropParameters parameters = new InteropParameters();
                    parameters.addParameter(new InteropParameter("service", application.serverServiceName));
                    parameters.addParameter(new InteropParameter("operation", "getDevices"));
                    parameters.addParameter(new InteropParameter("language", Shared.configuration.general.language));
                    InteropResponse response = (InteropResponse)Serialization.invoke("get", parameters, application.serverAddress, application.serverPort, 30000);
                    Device[] devices = Arrays.copyOf(response.getValue(), response.getValue().length, Device[].class);
                    result.addAll(Arrays.asList(devices));
                }
                catch (Exception exception)
                {
                }
            }
        }
        
        return result;
    }
    
    
    public List<Device> getDevices() throws SerializationException
    {
        List<Device> result = new ArrayList<Device>();
        
        for (ApplicationInformation application : getApplications())
        {
            try
            {
                InteropParameters parameters = new InteropParameters();
                parameters.addParameter(new InteropParameter("service", application.serverServiceName));
                parameters.addParameter(new InteropParameter("operation", "getDevices"));
                parameters.addParameter(new InteropParameter("language", Shared.configuration.general.language));
                InteropResponse response = (InteropResponse)Serialization.invoke("get", parameters, application.serverAddress, application.serverPort, 30000);
                Device[] devices = Arrays.copyOf(response.getValue(), response.getValue().length, Device[].class);
                result.addAll(Arrays.asList(devices));
            }
            catch (Exception exception)
            {
            }
        }
        
        return result;
    }
    
    
    
    
    
    public ApplicationInformation getApplication(String service) throws SerializationException
    {
        for (ApplicationInformation application : getApplications(service))
        {
            if (service.equalsIgnoreCase(application.serverServiceName))
            {
                return(application);
            }
        }
        
        throw new SerializationException("Application not found");
    }

}