package com.jesseweiman.RPChat.manager;

import com.jesseweiman.RPChat.Message;
import com.jesseweiman.RPChat.Properties;
import com.jesseweiman.RPChat.Utils;
import com.jesseweiman.RPChat.chat.ChatManager;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.concurrent.ConcurrentLinkedQueue;

/**
 * Created with IntelliJ IDEA.
 * User: Jesse
 * Date: 10/3/12
 * Time: 1:23 AM
 * To change this template use File | Settings | File Templates.
 */
public class NetworkManager {

    private static final String RPCHAT_SIGNAL = "RPCHAT";
    private static final String MESSAGE_SIGNAL = "MESSAGE";
    private static final String HELLO_SIGNAL = "HELLO";
    private static final String BYE_SIGNAL = "BYE";

    private static final int DEFAULT_LISTEN_PORT = 1990;
    private static final int DEFAULT_BUDDY_PORT = 1990;

    private ChatManager chatManager;
    private ConfigManager configManager;
    private Server server = new Server();
    private Client client = new Client();

    private boolean buddyOnline = false;

    public NetworkManager(ChatManager chatManager, ConfigManager configManager){
        this.chatManager = chatManager;
        this.configManager = configManager;
        server.start();
        client.start();
    }

    public void sendMessage(Message message){
        client.offerMessage(message);
    }

    private class Client extends Thread implements Runnable{
        boolean sending = true;
        Socket socket;
        ConcurrentLinkedQueue<Message> messages = new ConcurrentLinkedQueue<Message>();

        public void stopSending(){
            sending = false;
        }

        public void offerMessage(Message message){
            messages.offer(message);
        }

        public void run(){
            boolean failed;

            while(sending){
                if(messages.isEmpty()){
                    Utils.sleepThread(20L);
                }
                else {
                    Message message = messages.peek();

                    try {
                        sendMessage(message);
                        failed = false;
                    }
                    catch(UnknownHostException e){
                        System.out.println("Unknown host! Address is: " + configManager.getString(Properties.ADDRESS_KEY, "localhost"));
                        failed = true;
                    }
                    catch (IOException e) {
                        System.out.println("There was an IO problem!");
                        e.printStackTrace();
                        failed = true;
                    }

                    if(failed){
                        Utils.sleepThread(5000);
                    }
                    else{
                        messages.poll();
                    }
                }
            }

            sending = true;
        }

        private void sendMessage(Message message) throws IOException {
            configManager.load();
            socket = new Socket(configManager.getString(Properties.ADDRESS_KEY, "localhost"), configManager.getInt(Properties.BUDDY_PORT_KEY, DEFAULT_BUDDY_PORT));
            Utils.log("Address to send: " + socket.getInetAddress().getHostName() + "; Port: " + socket.getPort());

            PrintWriter streamWriter = new PrintWriter(socket.getOutputStream()) ;
            BufferedWriter writer = new BufferedWriter(streamWriter);

            writer.write(RPCHAT_SIGNAL); writer.newLine();
            Message.send(writer, message);
            writer.close();
        }
    }

    private class Server extends Thread implements Runnable {
        ServerSocket socket;
        boolean listen = true;

        public void stopListening(){
            listen = false;
        }

        public void run(){
            try{
                socket = new ServerSocket(configManager.getInt(Properties.LISTEN_PORT_KEY, DEFAULT_LISTEN_PORT));
            }
            catch(IOException e){
                Utils.log("There was a problem starting the server!");
                e.printStackTrace();
                System.exit(1);
            }
            try{
                configManager.load();
                while(listen){
                    Socket buddy = socket.accept();

                    InputStreamReader streamReader = new InputStreamReader(buddy.getInputStream());
                    BufferedReader reader = new BufferedReader(streamReader);


                    String line = reader.readLine();

                    if(line.equals(RPCHAT_SIGNAL)){
                        Message message = Message.receive(reader);
                        chatManager.receiveMessage(message);
                    }
                    else{
                        reader.close();
                    }
                }
            }
            catch(IOException e){
                Utils.log("There was a problem recieving information!");
                e.printStackTrace();
            }

            listen = true;
        }
    }


}