package grafikchat.model;

import grafikchat.ohmlogger.OhmLogger;
import java.awt.Point;
import java.util.ArrayList;
import java.util.Observable;
import java.util.Observer;
import java.util.logging.Logger;
import java.util.prefs.Preferences;

/**
 * Model of chat application. Handle communication
 * 
 * @author marian
 */
public class ChatModel extends Observable implements Observer
{
    private boolean connected;
    private boolean mode;
    private boolean initialized;
    private Transceiver trx; 
    private Figures intern;
    private Figures extern;
    
    private final Preferences prefs;
    private static Logger logger = OhmLogger.getLogger();
    
    /**
     * Constructor, initialize variables
     */
    public ChatModel()
    {
        connected = false;
        mode = false;
        initialized = false;
        trx = null;
        
        intern = new Figures();
        extern = new Figures();
        
        prefs = Preferences.userNodeForPackage(this.getClass());
    }
    
    /**
     * Get local drawn figure
     * @return internal figure
     */
    public Figures getIntern()
    {
        return intern;
    }
    
    /**
     * Get remote drawn figure
     * @return extern figure
     */
    public Figures getExtern()
    {
        return extern;
    }
    
    /**
     * Set new filename in preferences
     * @param f 
     */
    public void setFilename(String f)
    {
        prefs.put("LAST_FILE", f);
    }

    /**
     * Get latest filename from preferences
     * @return filename
     */
    public String getFilename()
    {
        String last = prefs.get("LAST_FILE", "");
        System.out.println(last);
        return last;
    }
    
    /**
     * Connect to peer
     * @param mode true to use server mode, false to use client mode
     * @param ip IP to connect to (not relevant in server mode)
     * @param port Port to open or connect to (depending on selected mode)
     */
    public void connectToPeer(boolean mode, String ip, int port)
    {
        if (initialized) {
            logger.info("Chat already running");
            return;
        }
        
        this.mode = mode;
        
        if (mode) {
            logger.info("Running in server mode");
            trx = new Server(port);
        } else {
            logger.info("Running in client mode");
            trx = new Client(ip, port);
        }
        
        trx.registerObserver(this);
        trx.init();
            
        initialized = true;
    }
    
    /**
     * Send message to peer
     * @param d TransceiverData to transmit
     */
    public void sendMessage(TransceiverData d)
    {
        if (!initialized) {
            logger.warning("Chat not initialized");
            return;
        }
        
        trx.sendMessage(d);
    }

    /**
     * Get received data from network
     * @param obs Observable
     * @param object Received object
     */
    @Override
    public void update(Observable obs, Object object)
    {        
        TransceiverData d = (TransceiverData)object;
        
        if (object instanceof TransceiverData) {
            switch (d.getEvent())
            {
                case NEWFIGURE:
                    extern.newFigure();
                    break;
                case NEWPOINT:
                    extern.addPoint((Point)d.getObject());
                    this.setChanged();
                    this.notifyObservers(TransceiverDataEvent.NEWPOINT);
                    break;
                case REPAINT:
                    ArrayList<Figures> fig = (ArrayList<Figures>)d.getObject();
                    intern.setFigures(fig.get(0).getFigures());
                    extern.setFigures(fig.get(1).getFigures());
                    this.setChanged();
                    this.notifyObservers(TransceiverDataEvent.REPAINT);
                default:
                    logger.warning("Unknown TransceiverDataEvent");
            }
        } else {
            logger.warning("Received invalid object");
        }
    }
}