package art.servers.controller;

import art.library.persistence.Persistence;
import art.library.persistence.PersistenceDatabase;
import art.library.persistence.PersistenceDatabaseParameters;
import art.library.utils.licence.Licence;
import art.library.utils.resources.Resources;
import art.servers.Shared;
import art.servers.configuration.Configuration;
import java.io.File;
import java.nio.file.Files;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.util.ArrayList;
import java.util.List;


public class ControllerDatabase extends Controller
{
    private List<Persistence> lpersistenceTimeless = new ArrayList<Persistence>();
    private List<Persistence> lpersistenceHistorical = new ArrayList<Persistence>();
    private List<Persistence> lpersistence = new ArrayList<Persistence>();
    private String name = null;
    
    
    public ControllerDatabase(Configuration configuration) throws Exception
    {
        this.name = Shared.getMessage("Controller database");
        this.setName(name);
        for (PersistenceDatabaseParameters persistenceDatabaseParameters : configuration.database)
        {
            if (persistenceDatabaseParameters.area.equalsIgnoreCase("Timeless"))
            {
                PersistenceDatabase persistenceTimeless = new PersistenceDatabase(persistenceDatabaseParameters);
                lpersistenceTimeless.add(persistenceTimeless);
                lpersistence.add(persistenceTimeless);
            }
            else if (persistenceDatabaseParameters.area.equalsIgnoreCase("Historical"))
            {
                PersistenceDatabase persistenceHistorical = new PersistenceDatabase(persistenceDatabaseParameters);
                lpersistenceHistorical.add(persistenceHistorical);
                lpersistence.add(persistenceHistorical);
            }
        }
        
        reloadPLSQL();
        
        start();
    }
    
    
    public ControllerDatabase(List<PersistenceDatabaseParameters> lparameters) throws Exception
    {
        this.setName(this.getClass().getName() + " : " + this.getName());
        
        for (PersistenceDatabaseParameters persistenceDatabaseParameters : lparameters)
        {
            if (persistenceDatabaseParameters.area.equalsIgnoreCase("Timeless"))
            {
                PersistenceDatabase persistenceTimeless = new PersistenceDatabase(persistenceDatabaseParameters);
                lpersistenceTimeless.add(persistenceTimeless);
                lpersistence.add(persistenceTimeless);
            }
            else if (persistenceDatabaseParameters.area.equalsIgnoreCase("Historical"))
            {
                PersistenceDatabase persistenceHistorical = new PersistenceDatabase(persistenceDatabaseParameters);
                lpersistenceHistorical.add(persistenceHistorical);
                lpersistence.add(persistenceHistorical);
            }
        }
        
        reloadPLSQL();
        
        start();
    }

    
    
    public List<Persistence> getTimelessPersistance()
    {
        return lpersistenceTimeless;
    }
    
    
    public List<Persistence> getHistoricalPersistance()
    {
        return lpersistenceHistorical;
    }
   
    
    

    public void run()
    {
        long lastTimestamp = System.currentTimeMillis();
        
        for (Persistence persistence : lpersistence)
        {
            Shared.traceInformation(name, "Disconnecting",  persistence.getName());
        }
        
        
        while ((isInterrupted() == false) && (exit == false))
        {
            lastTimestamp = System.currentTimeMillis();
            {            
                for (Persistence persistence : lpersistence)
                {
                    status(persistence);
                }
            }
            
            
            long timetowait = 5000 -(System.currentTimeMillis() - lastTimestamp);
                    
            if (timetowait > 0)
            {
                try
                {
                    sleep(timetowait);
                }
                catch (Exception e)
                {
                }
            }
            
            try
            {
                reloadPLSQL();
            }
            catch (Exception e)
            {
            }
        }
        
        for (Persistence persistence : lpersistence) 
        {
            persistence.close();
            Shared.traceInformation(name, "Finishing");
        }
        
    }
    
    
   
    
    private void reloadPLSQL()
    {
        for (Persistence persistence : lpersistence)
        {
            PersistenceDatabaseParameters persistenceDatabaseParameters = persistence.parameters;
            
            if (persistenceDatabaseParameters.PLSQL != null)
            {
                for (String path : persistenceDatabaseParameters.PLSQL)
                {
                    Connection connection = null;
                    PreparedStatement statement = null;

                    try
                    {
                        String superUser = Licence.decrypt(persistenceDatabaseParameters.superUser);
                        String superPassword = Licence.decrypt(persistenceDatabaseParameters.superPassword);
                        File file = new File(path);

                        if (file.exists() == false)
                        {
                            try
                            {
                                String plsql = new String(Resources.getResourceBytes(path));

                                if (persistenceDatabaseParameters.lastTimestampPlsqlUpdate == 0)
                                {
                                    connection = (Connection)DriverManager.getConnection(persistenceDatabaseParameters.connectionString, superUser, superPassword);
                                    connection.setAutoCommit(true);
                                    statement = connection.prepareStatement(plsql);
                                    statement.executeUpdate();
                                    persistenceDatabaseParameters.lastTimestampPlsqlUpdate = file.lastModified();
                                }

                            }
                            catch (Exception e)
                            {
                            }
                        }
                        else
                        {
                            try
                            {
                                if (file.lastModified() > persistenceDatabaseParameters.lastTimestampPlsqlUpdate)
                                {
                                    String plsql = new String(Files.readAllBytes(file.toPath()));
                                    connection = (Connection)DriverManager.getConnection(persistenceDatabaseParameters.connectionString, superUser, superPassword);
                                    connection.setAutoCommit(true);
                                    statement = connection.prepareStatement(plsql);
                                    statement.executeUpdate();
                                    persistenceDatabaseParameters.lastTimestampPlsqlUpdate = file.lastModified();
                                }
                            }
                            catch (Exception e)
                            {
                            }
                        }                    
                    }
                    catch (Exception e)
                    {
                    }
                    
                    try { statement.close(); } catch (Exception e) { }
                    try { connection.close(); } catch (Exception e) { }
                }
            }
        }
    }



    
    
    
    private void status(Persistence persistence)
    {
        try
        {
            persistence.isConnected();
        }
        catch (Exception exception)
        {
            Shared.traceError(name, "Connecting", persistence.getName(), exception);
        }
    }
    
    
    
    
    
    /***************************************************************************
    /* 
    /* Timeless
    /* 
    ***************************************************************************/

    
    public boolean timeless_existObject(Object object) throws Exception
    {
        Exception exception = null;
        
        for (Persistence persistence : lpersistenceTimeless)
        {
            try
            {
                return persistence.existObject(object);
            }
            catch (Exception e)
            {
                exception = e;
            }
        }
        
        throw exception;
    }
    
    
    
    public boolean timeless_existObject(String className, String where) throws Exception
    {
        Exception exception = null;
        
        for (Persistence persistence : lpersistenceTimeless)
        {
            try
            {
                return persistence.existObject(className, where);
            }
            catch (Exception e)
            {
                exception = e;
            }
        }
        
        throw exception;
    }
    
    
    

    public void timeless_addObject(Object object) throws Exception
    {
        Exception exception = null;
        
        for (Persistence persistence : lpersistenceTimeless)
        {
            try
            {
                persistence.addObject(object);
            }
            catch (Exception e)
            {
                exception = e;
            }
        }
        
        if (exception != null) throw exception;
    }
    
    
    
    public void timeless_updateObject(Object object) throws Exception
    {
        for (Persistence persistence : lpersistenceTimeless)
        {
            persistence.updateObject(object);
        }
    }

    
    
    public void timeless_updateOrAddObject(Object object) throws Exception
    {
        for (Persistence persistence : lpersistenceTimeless)
        {
            persistence.updateOrAddObject(object);
        }
    }
    

    
    public List<Object> timeless_getObject(String className) throws Exception
    {
        Exception exception = null;
        
        for (Persistence persistence : lpersistenceTimeless)
        {
            try
            {
                return persistence.getObject(className);
            }
            catch (Exception e)
            {
                exception = e;
            }
        }
        
        throw exception;
    }

    
    public List<Object> timeless_getObject(String className, String where) throws Exception
    {
        Exception exception = null;
        
        for (Persistence persistence : lpersistenceTimeless)
        {
            try
            {
                return persistence.getObject(className, where);
            }
            catch (Exception e)
            {
                e.printStackTrace();
                exception = e;
            }
        }
        
        throw exception;
    }
    
    

    public void timeless_deleteObject(Object object) throws Exception
    {
        for (Persistence persistence : lpersistenceTimeless)
        {
            persistence.deleteObject(object);
        }
    }
    
    

    public void timeless_deleteObject(String className, String where) throws Exception
    {
        for (Persistence persistence : lpersistenceTimeless)
        {
            persistence.deleteObject(className, where);
        }
    }

    public void timeless_update(String sql) throws Exception
    {
        for (Persistence persistence : lpersistenceTimeless)
        {
            persistence.update(sql);
        }
    }

   
    public void timeless_addObject_asynchronous(Object object) throws Exception
    {
        for (Persistence persistence : lpersistenceTimeless)
        {
            persistence.addObject_asynchronous(object);
        }
    }

    
    public void timeless_updateObject_asynchronous(Object object) throws Exception
    {
        for (Persistence persistence : lpersistenceTimeless)
        {
            persistence.updateObject_asynchronous(object);
        }
    }
    

    public void timeless_updateOrAddObject_asynchronous(Object object) throws Exception
    {
        for (Persistence persistence : lpersistenceTimeless)
        {
            persistence.updateOrAddObject_asynchronous(object);
        }
    }

    
    public void timeless_update_asynchronous(String sql) throws Exception
    {
        for (Persistence persistence : lpersistenceTimeless)
        {
            persistence.update_asynchronous(sql);
        }
    }

    
    
    

    /***************************************************************************
    /* 
    /* Historical
    /* 
    ***************************************************************************/

    
    public boolean historical_existObject(Object object) throws Exception
    {
        Exception exception = null;
        
        for (Persistence persistence : lpersistenceHistorical)
        {
            try
            {
                return persistence.existObject(object);
            }
            catch (Exception e)
            {
                exception = e;
            }
        }
        
        throw exception;
    }
    
    
    
    public boolean historical_existObject(String className, String where) throws Exception
    {
        Exception exception = null;
        
        for (Persistence persistence : lpersistenceHistorical)
        {
            try
            {
                return persistence.existObject(className, where);
            }
            catch (Exception e)
            {
                exception = e;
            }
        }
        
        throw exception;
    }
    
    
    

    public void historical_addObject(Object object) throws Exception
    {
        Exception exception = null;
        
        for (Persistence persistence : lpersistenceHistorical)
        {
            try
            {
                persistence.addObject(object);
            }
            catch (Exception e)
            {
                exception = e;
            }
        }
        
        if (exception != null) throw exception;
    }
    
    
    
    public void historical_updateObject(Object object) throws Exception
    {
        for (Persistence persistence : lpersistenceHistorical)
        {
            persistence.updateObject(object);
        }
    }

    

    public void historical_addOrUpdateObject(Object object) throws Exception
    {
        for (Persistence persistence : lpersistenceHistorical)
        {
            persistence.addOrUpdateObject(object);
        }
    }

    
    public void historical_updateOrAddObject(Object object) throws Exception
    {
        for (Persistence persistence : lpersistenceHistorical)
        {
            persistence.updateOrAddObject(object);
        }
    }

    
    public List<Object> historical_getObject(String className) throws Exception
    {
        Exception exception = null;
        
        for (Persistence persistence : lpersistenceHistorical)
        {
            try
            {
                return persistence.getObject(className);
            }
            catch (Exception e)
            {
                exception = e;
            }
        }
        
        throw exception;
    }

    
    
    public List<Object> historical_getObject(String className, String where) throws Exception
    {
        return historical_getObject(className, where, 0);
    }
    
    

    public List<Object> historical_getObject(String className, String where, int top) throws Exception
    {
        Exception exception = null;
        
        for (Persistence persistence : lpersistenceHistorical)
        {
            try
            {
                return persistence.getObject(className, where);
            }
            catch (Exception e)
            {
                exception = e;
            }
        }
        
        throw exception;
    }
        
    

    public List<Object> historical_getObject_Summary(String className, String where) throws Exception
    {
        return historical_getObject_Summary(className, where, 0);
    }
    
    

    public List<Object> historical_getObject_Summary(String className, String where, int top) throws Exception
    {
        Exception exception = null;
        
        for (Persistence persistence : lpersistenceHistorical)
        {
            try
            {
                return persistence.getObjectSummary(className, where);
            }
            catch (Exception e)
            {
                exception = e;
            }
        }
        
        throw exception;
    }
           

    public void historical_deleteObject(Object object) throws Exception
    {
        for (Persistence persistence : lpersistenceHistorical)
        {
            persistence.deleteObject(object);
        }
    }
    
    

    public void historical_deleteObject(String className, String where) throws Exception
    {
        for (Persistence persistence : lpersistenceHistorical)
        {
            persistence.deleteObject(className, where);
        }
    }

    public void historical_update(String sql) throws Exception
    {
        for (Persistence persistence : lpersistenceHistorical)
        {
            persistence.update(sql);
        }
    }

   
    public void historical_addObject_asynchronous(Object object) throws Exception
    {
        for (Persistence persistence : lpersistenceHistorical)
        {
            persistence.addObject_asynchronous(object);
        }
    }

    
    public void historical_updateObject_asynchronous(Object object) throws Exception
    {
        for (Persistence persistence : lpersistenceHistorical)
        {
            persistence.updateObject_asynchronous(object);
        }
    }
    
                
    public void historical_addOrUpdateObject_asynchronous(Object object) throws Exception
    {
        for (Persistence persistence : lpersistenceHistorical)
        {
            persistence.addOrUpdateObject_asynchronous(object);
        }
    }

    
    public void historical_updateOrAddObject_asynchronous(Object object) throws Exception
    {
        for (Persistence persistence : lpersistenceHistorical)
        {
            persistence.updateOrAddObject_asynchronous(object);
        }
    }

    
    public void historical_update_asynchronous(String sql) throws Exception
    {
        for (Persistence persistence : lpersistenceHistorical)
        {
            persistence.update_asynchronous(sql);
        }
    }


    
    

}