package grafikchat.model;

import grafikchat.ohmlogger.OhmLogger;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.util.Observable;
import java.util.Observer;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * TCP Client
 * 
 * @author marian
 */
public class Client extends Observable implements Runnable, Transceiver
{
    private Socket socket;
    private ObjectInputStream reader;
    private ObjectOutputStream writer;
    private boolean ready;
    private Thread thd;
    private String ip;
    private int port;
    private static Logger logger = OhmLogger.getLogger();
    
    /**
     * Constructor, initialize variables
     * @param ip IP to connect to
     * @param port Port of remote server
     */
    public Client(String ip, int port)
    {
        this.ip = ip;
        this.port = port;
        this.socket = null;
        this.reader = null;
        this.writer = null;
        this.ready = false;
        this.thd = null;
    }
    
    /**
     * Init client thread, if not already done
     */
    @Override
    public void init()
    {
        if (thd == null) {
            thd = new Thread(this);
            thd.start();
        }
    }

    /**
     * Add observer to client
     * @param o Observer to add
     */
    @Override
    public void registerObserver(Observer o)
    {
        this.addObserver(o);
    }

    /**
     * Run the client in thread.
     */
    @Override
    public void run()
    {
        logger.info("Running client...");
        
        while (true)
        {
            if (socket == null) {
                try {
                    socket = new Socket(ip, port);
                    logger.info("Connected to server");
                } catch (IOException e) {
                    logger.severe(e.getMessage());
                    socket = null;
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException ex) {
                        Logger.getLogger(Client.class.getName()).log(Level.SEVERE, null, ex);
                    }
                    continue;
                }

                try {
                    reader = new ObjectInputStream(socket.getInputStream());
                } catch (IOException e) {
                    logger.severe(e.toString());
                    return;
                }
                
                try {
                    writer = new ObjectOutputStream(socket.getOutputStream());
                } catch (IOException e) {
                    logger.severe(e.toString());
                    return;
                }
                
                ready = true;
            }
            
            if (ready) {
                try {
                    //logger.info("Waiting for message");
                    
                    Object o = reader.readObject();
                    
                    if (o == null) {
                        logger.warning("Reached end of stream");
                        ready = false;
                        continue;
                    }
                    
                    this.setChanged();
                    this.notifyObservers(o);
                } catch (ClassNotFoundException | IOException e) {
                    logger.severe(e.toString());
                    return;
                }
            }
        }
    }
    
    /**
     * Send message to server
     * @param d TransceiverData to transmit
     */
    @Override
    public void sendMessage(TransceiverData d)
    {
        if (ready) {
            try {
                writer.writeObject(d);
            } catch (IOException e) {
                logger.severe(e.toString());
            }
        } else {
            logger.warning("Server not ready to send message. Connect first");
        }
    }
}