package com.rs2hd;

import com.rs2hd.io.PlayerLoadResult;
import com.rs2hd.io.PlayerLoader;
import com.rs2hd.model.Player;
import com.rs2hd.model.PlayerDetails;
import com.rs2hd.model.World;
import com.rs2hd.packetbuilder.StaticPacketBuilder;
import com.rs2hd.util.log.Logger;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

import org.apache.mina.common.IoFuture;
import org.apache.mina.common.IoFutureListener;
import org.apache.mina.common.WriteFuture;

/**
 * Does blocking 'work'.
 *
 * @author Graham
 */
public final class WorkerThread implements Runnable {

    public static boolean saved = false;

    /**
     * Logger instance.
     */
    private Logger logger = Logger.getInstance();

    /**
     * A list of tasks to do by Mystic
     */
    private final BlockingQueue<Runnable> taskQueue = new LinkedBlockingQueue<Runnable>();

    //public Frame frame = new Frame("MezzyScape");
    /**
     * Constructor.
     *
     * @param loader
     */
    public WorkerThread(PlayerLoader loader) {
        this.loader = loader;
    }

    /**
     * The player loader.
     */
    private PlayerLoader loader;

    @Override
    public void run() {
        while (true) {
            Runnable runnable = null;
            try {
                runnable = taskQueue.take();
            } catch (InterruptedException e) {
                cleanup();
                break;
            }
            if(runnable != null) {
                try {
                    runnable.run();
                } catch(Exception e) {
                    continue;
                }
            }
        }
    }

    private void cleanup() {
        // save ALL games
        logger.info("Saving all games...");
        int saved = 0;
        int total = 0;
        for (Player p : World.getWorld().getPlayers()) {
            total++;
            if(p.getRequests().getTrade() != null)
                p.getRequests().getTrade().close();
            if (loader.save(p)) {
                saved++;
            } else {
                logger.info("Could not save " + p.getPlayerDetails().getDisplayName() + "'s game.");
            }
        }
        if (total == 0) {
            logger.info("No games to save.");
        } else {
            logger.info("Saved " + (saved / total * 100) + "% of games (" + saved + "/" + total + ").");
        }
        WorkerThread.saved = true;
    }

    public void loadPlayer(final PlayerDetails d) {
        taskQueue.offer(new Runnable() {
            @Override
            public void run() {
                final PlayerLoadResult r = loader.load(d);
                if(!Server.getFirewall().connectionAllowed(d.getSession(), false)) {
                    Server.getFirewall().ipBanPlayer(r.player);
                    return;
                }
                if(r.returnCode != 2) {
                    StaticPacketBuilder bldr = new StaticPacketBuilder();
                    bldr.addByte((byte) r.returnCode);
                    d.getSession().write(bldr.toPacket()).addListener(IoFutureListener.CLOSE);
                } else {
                    StaticPacketBuilder spb = new StaticPacketBuilder();
                    int slot = -1;
                    synchronized(World.getWorld().getPlayers()) {
                        slot = World.getWorld().register(r.player);
                    }
                    int returnCode = 2;
                    if (slot == -1) {
                        returnCode = Constants.ReturnCodes.WORLD_FULL;
                    }
                    spb.addByte((byte) returnCode);
                    if (returnCode == 2) {
                        spb.addByte((byte) r.player.getRights());
                        spb.addByte((byte) 0);
                        spb.addByte((byte) 0);
                        spb.addByte((byte) 0);
                        spb.addByte((byte) 1);
                        spb.addByte((byte) 0);
                        spb.addByte((byte) 0);
                        spb.addShort(slot);
                        spb.addByte((byte) 1);
                        spb.addByte((byte) 1); //members
                        d.getSession().setAttachment(r.player);
                    }
                    WriteFuture f = r.player.getSession().write(spb.toPacket());
                    final int fReturncode = returnCode;
                    f.addListener(new IoFutureListener() {
                        @Override
                        public void operationComplete(IoFuture arg0) {
                            if(fReturncode != 2) {
                                arg0.getSession().close();
                            } else {
                                try {
                                    r.player.setOnLogin(true);
                                    r.player.getActionSender().sendLogin();
                                } catch(Exception e) {

                                }
                            }
                        }
                    });
                }
            }
        });
    }

    public void savePlayer(final Player p) {
        taskQueue.offer(new Runnable() {
            @Override
            public void run() {
                loader.save(p);
            }
        });
    }

    public void submit(final Runnable runnable) {
        taskQueue.offer(runnable);
    }

}