package hardy.scl.communication;

import hardy.scl.interfaces.IAppManager;
import hardy.scl.interfaces.ISocketOperator;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.HttpURLConnection;
import java.net.InetAddress;
import java.net.MalformedURLException;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.URL;
import java.net.UnknownHostException;
import java.util.HashMap;
import java.util.Iterator;

import android.util.Log;


public class SocketOperator implements ISocketOperator
{
    private static final String AUTHENTICATION_SERVER_ADDRESS = "http://10.10.10.100/chippers/";

    private int listeningPort = 0;

    private static final String HTTP_REQUEST_FAILED = null;



    private HashMap<InetAddress, Socket> sockets = new HashMap<InetAddress, Socket>();

    private ServerSocket serverSocket = null;

    private boolean listening;

    private IAppManager appManager;

    public int filesize ;



    private class ReceiveFileConnection extends Thread {
        Socket clientSocket = null;
        Socket fileSocket=null;
        public ReceiveConnection(Socket socket)
        {
            this.fileSocket=socket;
            SocketOperator.this.sockets.put(socket.getInetAddress(), socket);
        }

        @Override
            public void run() {
            try {
                InputStream is=fileSocket.getInputStream();
                appManager.fileReceived(is);
                fileSocket.close();
            } catch (IOException e) {
                Log.e("ReceiveConnection.run: when receiving connection ","");
            }
        }
    }

    private class ReceiveMessageConnection extends Thread {
        Socket clientSocket = null;
        public ReceiveConnection(Socket socket)
        {
            this.clientSocket = socket;
            SocketOperator.this.sockets.put(socket.getInetAddress(), socket);
        }

        @Override
            public void run() {
            try {
                BufferedReader in = new BufferedReader(new InputStreamReader(
                            clientSocket.getInputStream()))
                String inputLine;
                while ((inputLine = in.readLine()) != null) {
                    appManager.messageReceived(inputLine);
                }
                clientSocket.close();
            } catch (IOException e) {
                Log.e("ReceiveConnection.run: when receiving connection ","");
            }
        }
    }


    public SocketOperator(IAppManager appManager) {
        this.appManager = appManager;
    }


    public String sendHttpRequest(String params)
    {
        URL url;
        String result = new String();
        try
            {
                url = new URL(AUTHENTICATION_SERVER_ADDRESS);
                HttpURLConnection connection;
                connection = (HttpURLConnection) url.openConnection();
                connection.setDoOutput(true);

                PrintWriter out = new PrintWriter(connection.getOutputStream());

                out.println(params);
                out.close();

                BufferedReader in = new BufferedReader(
                                                       new InputStreamReader(
                                                                             connection.getInputStream()));
                String inputLine;

                while ((inputLine = in.readLine()) != null) {
                    result = result.concat(inputLine);
                }
                in.close();
            }
        catch (MalformedURLException e) {
            e.printStackTrace();
        }
        catch (IOException e) {
            e.printStackTrace();
        }

        if (result.length() == 0) {
            result = HTTP_REQUEST_FAILED;
        }

        return result;


    }


    public boolean sendMessage(String message, String ip, int port)
    {
        try {


            String[] str = ip.split("\\.");

            byte[] IP = new byte[str.length];

            for (int i = 0; i < str.length; i++) {

                IP[i] = (byte) Integer.parseInt(str[i]);
            }
            Socket socket = getSocket(InetAddress.getByAddress(IP), port);
            if (socket == null) {
                return false;
            }

            PrintWriter out = null;
            out = new PrintWriter(socket.getOutputStream(), true);
            //OutputStreamWriter outputStream = new OutputStreamWriter(socket.getOutputStream());
            //outputStream.write("Text");
            // outputStream.flush();
            String flag = "Text";
            message = message+flag;
            out.println(message);
        } catch (UnknownHostException e) {
            return false;
            //e.printStackTrace();
        } catch (IOException e) {
            return false;
            //e.printStackTrace();
        }

        return true;
    }




    public int startListening(int portNo, boolean isMessageListening)
    {
        listening = true;

        try {
            serverSocket = new ServerSocket(portNo);
            this.listeningPort = portNo;
        } catch (IOException e) {

            //e.printStackTrace();
            this.listeningPort = 0;
            return 0;
        }

        while (listening) {
            try {
                if (isMessageListening) {
                    new ReceiveMessageConnection(serverSocket.accept()).start();
                } else {
                    new ReceiveFileConnectino(serverSocket.accept()).start();
                }

            } catch (IOException e) {
                //e.printStackTrace();
                return 2;
            }
        }

        try {
            serverSocket.close();
        } catch (IOException e) {
            Log.e("Exception server socket", "Exception when closing server socket");
            return 3;
        }


        return 1;
    }


    public void stopListening()
    {
        this.listening = false;
    }

    private Socket getSocket(InetAddress addr, int portNo)
    {
        Socket socket = null;
        if (sockets.containsKey(addr) == true)
            {
                socket = sockets.get(addr);
                // check the status of the socket
                if  ( socket.isConnected() == false ||
                      socket.isInputShutdown() == true ||
                      socket.isOutputShutdown() == true ||
                      socket.getPort() != portNo
                      )
                    {
                        // if socket is not suitable,  then create a new socket
                        sockets.remove(addr);
                        try {
                            socket.shutdownInput();
                            socket.shutdownOutput();
                            socket.close();
                            socket = new Socket(addr, portNo);
                            sockets.put(addr, socket);
                        }
                        catch (IOException e) {
                            Log.e("getSocket: when closing and removing", "");
                        }
                    }
            }
        else
            {
                try {
                    socket = new Socket(addr, portNo);
                    sockets.put(addr, socket);
                } catch (IOException e) {
                    Log.e("getSocket: when creating", "");
                }
            }
        return socket;
    }


    public void exit()
    {
        for (Iterator<Socket> iterator = sockets.values().iterator(); iterator.hasNext();)
            {
                Socket socket = (Socket) iterator.next();
                try {
                    socket.shutdownInput();
                    socket.shutdownOutput();
                    socket.close();
                } catch (IOException e)
                    {
                    }
            }

        sockets.clear();
        this.stopListening();
        appManager = null;
        //      timer.cancel();
    }


    public int getListeningPort() {

        return this.listeningPort;
    }


    @Override
        public boolean sendFile(String ip, int port) {
        // TODO Auto-generated method stub


        try {


            String[] str = ip.split("\\.");

            byte[] IP = new byte[str.length];

            for (int i = 0; i < str.length; i++) {

                IP[i] = (byte) Integer.parseInt(str[i]);


            }
            Socket socket = getSocket(InetAddress.getByAddress(IP), port);
            if (socket == null) {
                return false;
            }
            Log.i("SocketOP", "sendFILE-1");
            File  f = new File("/sdcard/chats/gas.jpg/");

            BufferedInputStream bis = new BufferedInputStream(new FileInputStream(f));
            int readData;
            byte[] buffer = new byte[1024];
            bis.read(buffer, 0,buffer.length);
            OutputStream os = socket.getOutputStream();

            while((readData=bis.read(buffer))!=-1){
                os.write(buffer,0,readData);


                Log.i("SocketOP", "sendFILE-3");
            }

        } catch (IOException e) {
            return false;
            //e.printStackTrace();
        }
        //  Toast.makeText(this, "Lvbvhhging...", Toast.LENGTH_SHORT).show();

        return true;
    }
}