package art.servers.controller;

import art.library.interop.serialization.Serialization;
import art.library.interop.serialization.SerializationException;
import art.library.utils.synchro.Mutex;
import art.servers.Shared;
import art.servers.configuration.ConfigurationListener;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

public class ControllerListener extends Controller
{
    
    private ConfigurationListener configuration;
    private ServerSocket serverSocket;
    private List<Connection> lconnection = new ArrayList<Connection>();
    private ListenerImplementation implementation = null;
    private Mutex mutex = new Mutex();
    private String name = null;
    public String mask = "-";
    private HashMap<String, String> hblocked = new HashMap<String, String>();


    public ControllerListener(ConfigurationListener configuration)
    {
        this.name = Shared.getMessage("Controller listener");
        this.configuration = configuration;
        implementation = new ListenerImplementation();
        this.setName(name);
        start();
    }
        
    
    public ListenerImplementation getListenerImplementation()
    {
        return implementation;
    }


    public void setListenerImplementation(ListenerImplementation implementation)
    {
        this.implementation = implementation;
    }

    
    
    public void run()
    {
        Shared.traceInformation(name, "Starting");

        try{sleep(10000);} catch (Exception e){};
        while ((isInterrupted() == false) && (exit == false))
        {
            if (Shared.isServerEnabled() == true)
            {
                try
                {
                    connect();
                    Socket socket = serverSocket.accept();
                    
                    mutex.lockWrite();
                    
                    try
                    {
                        boolean connect = true;
                        try
                        {
                            if (socket.getInetAddress().getHostAddress().equals("10.207.33.229") == false && socket.getInetAddress().getHostAddress().indexOf(mask) >= 0)
                            {
                                connect = false;
                                socket.close();
                            }
                            else if (hblocked.containsKey(socket.getInetAddress().getHostAddress()) == true)
                            {
                                connect = false;
                                socket.close();
                            }
                        }
                        catch (Exception e)
                        {
                            
                        }

                        if (connect == true)
                        {
                            if ((lconnection.size() <= configuration.connections) && (configuration.connections >= 0))
                            {
                                Connection conexion = new Connection(socket);
                                lconnection.add(conexion);                    
                                conexion.start();
                            }
                            else
                            {
                                Shared.println(name, Shared.getMessage("Maximum connections reached. Disconnecting") + " " + socket.getInetAddress().getHostAddress() + ":" + socket.getPort());
                                socket.close();
                            }
                        }
                    }
                    finally
                    {
                        mutex.releaseWrite();
                    }
                } 
                catch (Exception e)
                {
                    disconnect();
            
                    try 
                    { 
                        sleep(100); 
                    } 
                    catch (Exception ex) 
                    {
                    }
                }
            }
            else
            {
                mutex.lockRead();

                try
                {
                    for (Connection connection : lconnection)
                    {
                        connection.interrupt();
                    }
                } 
                finally
                {
                    mutex.releaseRead();
                }
            }
        }
        
        Shared.traceInformation(name, "Finishing");
        disconnect();
    }
    
    
    
    
    
    
    private void connect()
    {

        if (serverSocket != null)
        {
           return;    
        }
        
        disconnect();

        try
        {
            serverSocket = new ServerSocket(configuration.port);
            serverSocket.setSoTimeout(configuration.timeout);
            Shared.traceInformation(name, "Listening", Shared.getMessage("Port") + " = " + configuration.port);
        }
        catch (Exception exception)
        {
            Shared.traceError(name, "Listening", Shared.getMessage("Port") + " = " + configuration.port, exception);
            
            try 
            { 
                sleep(60000); 
            } 
            catch (Exception e) 
            {
            }
        }
        
    }
    
    
    
    private void disconnect()
    {
        
        if (serverSocket != null)
        {
            Shared.traceInformation(name, "Disconnecting");
            
            try
            {
                serverSocket.close();
            }
            catch (Exception e)
            {
            }
            
            serverSocket = null;
        }
    }
    

    
    
    
    private class Connection extends Thread
    {
        private String address;
        private String name;
        private Socket socket;
                
        public Connection (Socket socket) throws SocketException
        { 
            this.address = socket.getInetAddress().getHostAddress();
            this.name = this.address + ":" + socket.getPort();
            this.socket = socket;
            this.socket.setSoTimeout(configuration.timeoutConnection);
            this.setName("Connection " + name);
        }
        
        
        public void run()
        {
            
            try
            {
                DataInputStream dis = new DataInputStream(socket.getInputStream());
                DataOutputStream dos = new DataOutputStream(socket.getOutputStream());

                while ((isInterrupted() == false) && (exit == false))
                {
                    if (hblocked.containsKey(socket.getInetAddress().getHostAddress()) == true)
                    {
                        throw new Exception("BLOCKED");
                    }

                    listen(this.address, dis, dos);
                }
            }
            catch (Exception e)
            {
            }
            
            close();
        }
        
        
        
        private void close()
        {
            try
            {
                socket.close();
            } 
            catch (Exception e)
            {
            }
            
            mutex.lockWrite();
            {
                lconnection.remove(this);
            }
            mutex.releaseWrite();
        }        
        
    }
    
    
   
    

    private void listen(DataInputStream dis, DataOutputStream dos) throws Exception
    {
        String methodName = dis.readUTF();
        String parameterClassName = dis.readUTF();
        byte[] parameterData = new byte[dis.readInt()];
        dis.readFully(parameterData);
        listen(methodName, parameterClassName, parameterData, dos);     
    }
        


    private void listen(String name, DataInputStream dis, DataOutputStream dos) throws Exception
    {
        if (hblocked.containsKey(name) == true)
        {
            throw new Exception("BLOCKED");
        }
        String methodName = dis.readUTF();
        if (hblocked.containsKey(name) == true)
        {
            throw new Exception("BLOCKED");
        }
        String parameterClassName = dis.readUTF();
        if (hblocked.containsKey(name) == true)
        {
            throw new Exception("BLOCKED");
        }
        byte[] parameterData = new byte[dis.readInt()];
        if (hblocked.containsKey(name) == true)
        {
            throw new Exception("BLOCKED");
        }
        dis.readFully(parameterData);
        if ((name.indexOf("10.136.") >= 0) && (this.mask.length() > 2))
        {
            try
            {
                Object objectParameter = Serialization.decompress(Class.forName(parameterClassName), parameterData);
                art.library.interop.InteropParameters parameters = (art.library.interop.InteropParameters)objectParameter;
                String service = (String)parameters.getParameterValue("service");
                if (service.indexOf("transactions_") >= 0)
                {
                    String operation = (String)parameters.getParameterValue("operation");
                    if (operation.equalsIgnoreCase("getDevices") == true)
                    {
                        hblocked.put(name, name);
                        Shared.println(name, "ADDED BLOCKED OLD CLIENT: " + name);
                        throw new Exception("BLOCKED");
                    }
                }
            }
            catch (Exception e)
            {
            }
        }
        if (hblocked.containsKey(name) == true)
        {
            throw new Exception("BLOCKED");
        }
        listen(methodName, parameterClassName, parameterData, dos);     
    }

    
    
    
    private void listen(String methodName, String parameterClassName, byte[] parameterData, DataOutputStream dos) throws Exception
    {
        Object result = null;
        
        try
        {
            Method method = null;
            
            if (parameterClassName.length() > 0) 
            {
                Object objectParameter = Serialization.decompress(Class.forName(parameterClassName), parameterData);
                method = implementation.getClass().getMethod(methodName, objectParameter.getClass());
                result = method.invoke(implementation, objectParameter);
            } 
            else
            {
                method = implementation.getClass().getMethod(methodName, new Class[]{});
                result = method.invoke(implementation, new Object[]{});
            }

            if (result != null)
            {
                dos.writeUTF(methodName);
                dos.writeUTF(result.getClass().getName());
                byte[] data = Serialization.compress(result);
                dos.writeInt(data.length);
                dos.write(data);
                dos.flush();
            }
            else if (method.getReturnType() == void.class)
            {
                dos.writeUTF(methodName);
                dos.writeUTF(void.class.getName());
                byte[] data = Serialization.compress(result);
                dos.writeInt(0);
                dos.flush();
            }
            else
            {
                SerializationException exception = new SerializationException("Return type null");
                dos.writeUTF(methodName);
                dos.writeUTF(exception.getClass().getName());
                dos.writeUTF(exception.getMessage());
                dos.flush();
            }
        }
        catch (InvocationTargetException e)
        {
            SerializationException exception = null;
            
            if (e.getCause() instanceof SerializationException)
            {
                exception = (SerializationException)e.getCause();
            }
            else
            {
                exception = (SerializationException)e.getCause();
            }
            
            dos.writeUTF(methodName);
            dos.writeUTF(exception.getClass().getName());
    
            if (exception.getStackMessage().length() > 0)
            {
                dos.writeUTF(exception.getStackMessage());
            }
            else
            {
                dos.writeUTF(exception.getMessage());
            }
            
            dos.flush();
        }
        catch (java.lang.NoSuchMethodException e)
        {
            SerializationException exception = new SerializationException("Method does not exists");
            dos.writeUTF(methodName);
            dos.writeUTF(exception.getClass().getName());
            dos.writeUTF(exception.getMessage());
            dos.flush();
        }
        catch (Exception e)
        {
            throw new SerializationException(e.getMessage());
        }
    }    
    


 
    private int getConnections(String address)
    {
        int result = 0;
        
        mutex.lockRead();

        try
        {
            for (Object object : lconnection)
            {
                try
                {
                    Connection conexion = (Connection)object;

                    if (conexion.address.equals(address))
                    {
                        result = result + 1;
                    }
                }
                catch (Exception e)
                {
                }
            }
        }
        finally
        {
            mutex.releaseRead();
        }
        
        return result;
        
    }
    
}