package art.servers;

import art.library.gui.FlatGUI;
import art.library.gui.flat.FlatDialog;
import art.library.interop.serialization.Serialization;
import art.library.model.devices.application.Application;
import art.library.model.devices.application.ApplicationAlarms;
import art.library.model.devices.application.ApplicationRealtime;
import art.library.model.devices.application.ApplicationStatus;
import art.library.persistence.PersistenceDatabaseParameters;
import art.library.utils.ArticProcesses;
import art.library.utils.licence.Licence;
import art.library.utils.resources.Resources;
import art.library.utils.windows.SystemProcess;
import art.servers.configuration.Configuration;
import art.servers.controller.ControllerDatabase;
import art.servers.controller.ControllerListener;
import art.servers.controller.ControllerListenerDebug;
import art.servers.controller.ControllerListenerHttp;
import art.servers.controller.ControllerListenerHttps;
import art.servers.controller.ControllerNtpHttp;
import art.servers.controller.ControllerProcessInformation;
import art.servers.controller.ControllerStatus;
import art.servers.controller.ControllerTransactions;
import art.servers.controller.ControllerUserPermissions;
import art.servers.gui.ArticWindow;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import java.awt.Toolkit;
import java.awt.datatransfer.Clipboard;
import java.awt.datatransfer.StringSelection;
import java.io.File;
import java.io.FileOutputStream;
import java.net.InetAddress;
import java.security.cert.X509Certificate;
import java.util.Properties;
import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import javax.swing.JOptionPane;
import javax.swing.UIManager;



public class Server 
{
    public static void preinitialise(String[] args) throws Exception
    {
        preinitialise(args, Configuration.class);
    }
            
    public static void preinitialise(String[] args, Class configurationClass) throws Exception
    {
        Shared.debug = existParameter(args, "-debug");
        Shared.reloadDevices = existParameter(args, "--reload");
        Shared.restoreDevices = existParameter(args, "--restore");
                
        // Look and feel
        UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());

        
        // SSL accept key
        
        TrustManager[] trustAllCerts = new TrustManager[] {new MyTrustManager()};
        SSLContext sc = SSLContext.getInstance("SSL");
        sc.init(null, trustAllCerts, new java.security.SecureRandom());
        HostnameVerifier allHostsValid = new HostnameVerifier() 
        {
            public boolean verify(String hostname, SSLSession session) 
            {
                return true;
            }
        };
        HttpsURLConnection.setDefaultHostnameVerifier(allHostsValid);
        HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());


        // Configuration

        String configurationFile = getParameter(args, "-config");

        if (configurationFile != null)
        {
            Shared.configuration = (Configuration)Serialization.deserialize(configurationClass, new File(configurationFile));
        }
        else if (new File(Shared.getApplicationName() + ".json").exists())
        {
            Shared.configuration = (Configuration)Serialization.deserialize(configurationClass, new File(Shared.getApplicationName() + ".json"));
        }
        else
        {
            Shared.configuration = (Configuration)Serialization.deserialize(configurationClass, Resources.getResourceStream("data/" + Shared.getApplicationName() + ".json"));
        }

        if (existParameter(args, "-nogui") == false)
        {
            FlatGUI.initialise(Shared.configuration.general.language);
        }


        // Properties

        if (Shared.configuration.general.mproperties != null)
        {
            Properties properties = System.getProperties();

            for (String key : Shared.configuration.general.mproperties.keySet()) 
            {
                String value = Shared.configuration.general.mproperties.get(key);
                properties.setProperty(key, value);
            }

            System.setProperties(properties);
        }
        

        // License

        boolean license = true;

        if (existParameter(args, "-code") == true)
        {
            license = getParameter(args, "-code").equals(Shared.getApplicationCode());
        }
        
        
        if (existParameter(args, "--license") == true)
        {
            String password = getParameter(args, "--license");
            
            if ((password.equalsIgnoreCase("¡¡register!!") == true) || (password.equalsIgnoreCase("**register**") == true))
            {
                FileOutputStream fos = new FileOutputStream(new File(Shared.getApplicationName() + ".license"));
                fos.write(Licence.licenceGeneration(Licence.codeGeneration(Shared.getApplicationCode())).getBytes());
                fos.close();
            }
        }

        if (license == false)
        {
            if (Licence.hasLicence(Shared.getApplicationCode(), new File(Shared.getApplicationName() + ".license")) == false)
            {
                codeGeneration();
            }
        }

        
        // User and password database desencryption
        
        if (Shared.configuration.database != null)
        {
            for (PersistenceDatabaseParameters parameters : Shared.configuration.database)
            {
                parameters.user = Licence.decrypt(parameters.user);
                parameters.password = Licence.decrypt(parameters.password);
            }
        }


        // Application device, status

        Application application = new Application(Shared.configuration.application);
        application.status = new ApplicationStatus();
        application.alarms = new ApplicationAlarms();
        
        if (Shared.configuration.listener != null)
        {
            application.information.serverAddressExternal = Shared.configuration.listener.addressExternal;
            application.information.serverPortExternal = Shared.configuration.listener.portExternal;        
        }

        Shared.controllerStatus = new ControllerStatus(application);
        Shared.lcontroller.add(Shared.controllerStatus);
        
        if (Shared.configuration.listener != null)
        {
            application.getDeviceInformation().serverAddress = Shared.configuration.listener.address;
            application.getDeviceInformation().serverPort = Shared.configuration.listener.port;
        }
        else
        {
            application.getDeviceInformation().serverAddress = InetAddress.getLocalHost().getHostAddress();
            application.getDeviceInformation().serverPort = 0;
        }

        

        // Is already running

        if (Shared.configuration.general.executableName != null)
        {
            long pid = ArticProcesses.getPID();
            
            for (SystemProcess process : ArticProcesses.getProcesses(Shared.configuration.general.executableName))
            {
                if (process.pid != pid)
                {
                    if (existParameter(args, "-nogui") == false)
                    {
                        JOptionPane.showMessageDialog(null, Shared.getMessage("Process %1 already opened").replace("%1", Shared.configuration.general.executableName), Shared.getMessage("Error"), JOptionPane.ERROR_MESSAGE);
                    }
                    else
                    {
                        System.out.println(Shared.getMessage("Process %1 already opened").replace("%1", Shared.configuration.general.executableName));
                    }

                    System.exit(0);
                }
            }
        }

        
        // Controller database

        if (Shared.configuration.database != null)
        {
            Shared.controllerDatabase = new ControllerDatabase(Shared.configuration);
            Shared.lcontroller.add(Shared.controllerDatabase);
        }
        
        // Controller user permissions
     
        Shared.controllerUserPermissions = new ControllerUserPermissions();
        
        // Controller process information

        Shared.controllerProcessInformation = new ControllerProcessInformation();
        
        
                
        // Controller transactions

        if (Shared.configuration.transactions != null)
        {
            Shared.controllerTransactions = new ControllerTransactions(Shared.configuration.transactions);
            Shared.lcontroller.add(Shared.controllerTransactions);
        }
        
        
        // Controller NTP HTTP
        
        if (Shared.configuration.controllerNTPHTTP != null)
        {
            Shared.controllerNtpHttp = new ControllerNtpHttp(Shared.configuration.controllerNTPHTTP);
            Shared.lcontroller.add(Shared.controllerNtpHttp);
        }

    }
    
    
    
    
    public static void postinitialise(String[] args) throws Exception
    {

        // Graphical interface

        if (existParameter(args, "-nogui") == false)
        {
            GraphicsDevice gd = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice();
            int screenWidth = gd.getDisplayMode().getWidth();
            int screenHeight = gd.getDisplayMode().getHeight();
            Shared.window = new ArticWindow();
            Shared.window.setLocation(Shared.configuration.general.windowX, Shared.configuration.general.windowY);
            Shared.window.setSize(Math.min(Shared.configuration.general.windowW, screenWidth), Math.min(Shared.configuration.general.windowH, screenHeight));
        }


        // Controller listener aluvisa

        if (Shared.configuration.listener != null)
        {
            Shared.controllerListener = new ControllerListener(Shared.configuration.listener);
            Shared.lcontroller.add(Shared.controllerListener);
        }

        
        // Controller listener http

        if (Shared.configuration.listenerHttp != null)
        {
            if (Shared.configuration.listenerHttp.readUser != null) Shared.configuration.listenerHttp.readUser = Licence.decrypt(Shared.configuration.listenerHttp.readUser);
            if (Shared.configuration.listenerHttp.readPassword != null) Shared.configuration.listenerHttp.readPassword = Licence.decrypt(Shared.configuration.listenerHttp.readPassword);
            if (Shared.configuration.listenerHttp.writeUser != null) Shared.configuration.listenerHttp.writeUser = Licence.decrypt(Shared.configuration.listenerHttp.writeUser);
            if (Shared.configuration.listenerHttp.writePassword != null) Shared.configuration.listenerHttp.writePassword = Licence.decrypt(Shared.configuration.listenerHttp.writePassword);
            Shared.controllerListenerHttp = new ControllerListenerHttp(Shared.configuration.listenerHttp);
            Shared.lcontroller.add(Shared.controllerListenerHttp);
        }

        // Controller listener https

        if (Shared.configuration.listenerHttps != null)
        {
            if (Shared.configuration.listenerHttps.readUser != null) Shared.configuration.listenerHttps.readUser = Licence.decrypt(Shared.configuration.listenerHttps.readUser);
            if (Shared.configuration.listenerHttps.readPassword != null) Shared.configuration.listenerHttps.readPassword = Licence.decrypt(Shared.configuration.listenerHttps.readPassword);
            if (Shared.configuration.listenerHttps.writeUser != null) Shared.configuration.listenerHttps.writeUser = Licence.decrypt(Shared.configuration.listenerHttps.writeUser);
            if (Shared.configuration.listenerHttps.writePassword != null) Shared.configuration.listenerHttps.writePassword = Licence.decrypt(Shared.configuration.listenerHttps.writePassword);
            if (Shared.configuration.listenerHttps.keystorePassword != null) Shared.configuration.listenerHttps.keystorePassword = Licence.decrypt(Shared.configuration.listenerHttps.keystorePassword);
            Shared.controllerListenerHttps = new ControllerListenerHttps(Shared.configuration.listenerHttps);
            Shared.lcontroller.add(Shared.controllerListenerHttps);
        }
            


        // Controller listener debug

        if (Shared.configuration.debug != null)
        {
            Shared.controllerListenerDEBUG = new ControllerListenerDebug(Shared.configuration.debug);
            Shared.controllerListenerDEBUG.start();
        }
        else if (Shared.configuration.logger != null)
        {
            Shared.controllerListenerDEBUG = new ControllerListenerDebug(Shared.configuration.logger);
            Shared.controllerListenerDEBUG.start();
        }
        
        
        // Start controller status

        Shared.controllerStatus.start();
       
        try
        {
            Application application = Shared.controllerStatus.getApplication();
            ApplicationRealtime realtime = (ApplicationRealtime)application.getDeviceRealtime();
            realtime.traces = Shared.model.getLastTraces(Shared.getLanguage(), Shared.getApplicationName(), ApplicationRealtime.MAX_TRACES);
        }
        catch (Exception exception)
        {
        }
        
        // Version

        System.out.println(Shared.getApplicationName() + ", version " + Shared.version());
        Shared.printVersion("art.library.adf", "adf.version.properties");
        Shared.printVersion("art.library.andigo", "andigo.version.properties");
        Shared.printVersion("art.library.flatgui", "flatgui.version.properties");
        Shared.printVersion("art.library.interop", "interop.version.properties");
        Shared.printVersion("art.library.model", "model.version.properties");
        Shared.printVersion("art.library.net", "net.version.properties");
        Shared.printVersion("art.library.osm", "osm.version.properties");
        Shared.printVersion("art.library.persistence", "persistence.version.properties");
        Shared.printVersion("art.library.server", "server.version.properties");           
        Shared.printVersion("art.library.utils", "utils.version.properties");
        
    }
    
    
    
    public static String getParameter(String arguments[], String parameter)
    {
        try
        {
            for (int i=0; i<arguments.length; i++)
            {
               if (arguments[i].equalsIgnoreCase(parameter))
               {
                   return arguments[i+1];
               }
            }
        }
        catch (Exception e)
        {
        }
        
        return  null;
        
    }


    
    public static boolean existParameter(String arguments[], String parameter)
    {
        try
        {
            for (int i=0; i<arguments.length; i++)
            {
               if (arguments[i].equalsIgnoreCase(parameter))
               {
                   return true;
               }
            }
        }
        catch (Exception e)
        {
        }
        
        return  false;
    }
        
    
    

    public static void codeGeneration()
    {
        try            
        {
            String code = Licence.codeGeneration(Shared.getApplicationCode());
            StringSelection stringSelection = new StringSelection(code);
            Clipboard clpbrd = Toolkit.getDefaultToolkit().getSystemClipboard();
            clpbrd.setContents(stringSelection, null);
            String message = Shared.getMessage("Copy below code and send to provider to activate product");
            message = message + "\n\n" + code + "\n\n";
            System.out.println(message);
            FlatDialog.showDialog(null, Shared.getMessage("License code"), message, true, FlatDialog.DIALOG_INFORMATION);
        }
        catch (Exception e)
        {
            try            
            {
                String message = Shared.getMessage("Error in licence generation");
                message = message + "\n";
                message = message + Shared.getMessage("Contact provider to solve the problem");
                System.out.println(message);
                FlatDialog.showDialog(null, Shared.getMessage("Error"), message, true, FlatDialog.DIALOG_ERROR);
            }
            catch (Exception exception)
            {
            }
        }
        
        System.exit(0);
    }
        

    
    
    private static class MyTrustManager implements X509TrustManager 
    {
        public java.security.cert.X509Certificate[] getAcceptedIssuers() 
        {
            return null;
        }

        public void checkClientTrusted(X509Certificate[] certs, String authType) 
        {
        }

        public void checkServerTrusted(X509Certificate[] certs, String authType) 
        {
        }
    }
    
        
    
}