package ch.asynk.rustanddust.game;

import java.io.StringWriter;

import com.badlogic.gdx.utils.Disposable;
import com.badlogic.gdx.utils.Json;
import com.badlogic.gdx.utils.JsonValue;
import com.badlogic.gdx.utils.JsonReader;
import com.badlogic.gdx.utils.JsonWriter.OutputType;

import ch.asynk.rustanddust.RustAndDust;
import ch.asynk.rustanddust.engine.util.IterableQueue;
import ch.asynk.rustanddust.engine.util.IterableStack;
import ch.asynk.rustanddust.ui.Position;
import ch.asynk.rustanddust.util.Marshal;
import ch.asynk.rustanddust.util.GameRecord;
import ch.asynk.rustanddust.game.ctrl.Solo;
import ch.asynk.rustanddust.game.State.StateType;
import ch.asynk.rustanddust.game.states.StateCommon;
import ch.asynk.rustanddust.game.states.StateSelect;
import ch.asynk.rustanddust.game.states.StateMove;
import ch.asynk.rustanddust.game.states.StatePromote;
import ch.asynk.rustanddust.game.states.StateEngage;
import ch.asynk.rustanddust.game.states.StateAnimation;
import ch.asynk.rustanddust.game.states.StateDeployment;
import ch.asynk.rustanddust.game.states.StateReinforcement;
import ch.asynk.rustanddust.game.states.StateReplay;

public abstract class Ctrl implements Disposable
{
    enum Mode
    {
        LOADING,
        REPLAY,
        PLAY,
    }

    private static final boolean debugCtrl = false;

    public enum MsgType
    {
        OK,
        CANCEL,
        PROMOTE,
        ANIMATIONS_DONE,
        UNIT_DOCK_SELECT,
        UNIT_DOCK_TOGGLE,
        UNIT_DEPLOYED,
        UNIT_UNDEPLOYED,
    }

    public enum EventType
    {
        ORDER,
        ORDER_DONE,
        STATE_CHANGE,
        ANIMATION,
        REPLAY_DONE,
        TURN_DONE,
        ACTION_ABORTED,
        EXIT_BATTLE,
    }

    class Event
    {
        public EventType type;
        public Object data;
        @Override
        public String toString() { return String.format("Event : %s - %s", type, (data == null) ? "" : data); }
    }

    public final RustAndDust game;
    public final Battle battle;

    private final StringWriter writer = new StringWriter(2048);
    private final IterableQueue<Event> events = new IterableQueue<Event>(4);
    private final IterableStack<Event> freeEvents = new IterableStack<Event>(4);

    public Map map;
    public Hud hud;
    private float blockEvents;
    public boolean blockMap;
    public boolean blockHud;
    private Hex touchedHex;
    protected int gameId;
    protected boolean synched;
    private boolean replayBattle;
    private int depth;

    private Order lastOrder;

    private final State selectState;
    private final State moveState;
    private final State promoteState;
    private final State engageState;
    private final State animationState;
    private final State deploymentState;
    private final State reinforcementState;
    private final State replayState;

    private Mode mode;
    private State state;
    private StateType stateType;
    private StateType stateAfterAnimation;

    public abstract void init();

    public static Ctrl getCtrl(final RustAndDust game)
    {
        Unit.clear();
        Ctrl ctrl = null;
        switch(game.config.gameMode)
        {
            case SOLO:
                ctrl = new Solo(game);
                break;
        }
        return ctrl;
    }

    public Ctrl(final RustAndDust game)
    {
        game.ctrl = this;
        this.game = game;
        this.battle = game.config.battle;
        this.hud = new Hud(game);

        this.blockEvents = 1.0f;
        this.blockMap = true;
        this.blockHud = false;
        this.touchedHex = null;
        this.gameId = -1;
        this.synched = false;
        this.replayBattle = false;
        this.depth = 0;

        this.lastOrder = null;

        this.selectState = new StateSelect();
        this.moveState = new StateMove();
        this.promoteState = new StatePromote();
        this.engageState = new StateEngage();
        this.animationState = new StateAnimation();
        this.deploymentState = new StateDeployment();
        this.reinforcementState = new StateReinforcement();
        this.replayState = new StateReplay();

        this.mode = Mode.LOADING;

        this.map = battle.init();
        init();
        StateCommon.set(game);
        hud.update();

        this.stateType = StateType.WAIT_EVENT;
        this.stateAfterAnimation = battle.getState();

        setState(StateType.ANIMATION);

        switch(game.config.loadMode)
        {
            case NEW:
                this.hud.notify(battle.toString(), 2, Position.MIDDLE_CENTER, false);
                break;
            case RESUME:
                if (!synched) {
                    map.prepareReplayLastAction();
                    this.stateAfterAnimation = StateType.REPLAY;
                }
                break;
            case REPLAY_LAST:
                map.prepareReplayLastTurn();
                this.stateAfterAnimation = StateType.REPLAY;
                break;
            case REPLAY_BATTLE:
                this.replayBattle = true;
                map.prepareReplayLastTurn();
                this.stateAfterAnimation = StateType.REPLAY;
                break;
        }
    }

    @Override
    public void dispose()
    {
        hud.dispose();
        map.dispose();
        battle.desinit();
        events.clear();
        freeEvents.clear();
    }

    // JSON

    protected void load(Marshal.Mode mode, String payload)
    {
        if (payload == null) return;
        JsonValue root = new JsonReader().parse(payload);
        battle.load(mode, root);
    }

    protected String unload(Marshal.Mode mode)
    {
        Json json = new Json(OutputType.json);
        writer.getBuffer().setLength(0);
        json.setWriter(writer);
        battle.unload(mode, json);
        writer.flush();
        return writer.toString();
    }

    // DB
    private void storeInitialState()
    {
        game.db.storeGameState(gameId, battle.getTurnCount(), battle.getPlayer().id, unload(Marshal.Mode.PLAYERS), unload(Marshal.Mode.MAP));
        game.db.storeTurnState(gameId);
    }

    private void storeGameState()
    {
        game.db.storeGameState(gameId, battle.getTurnCount(), battle.getPlayer().id, unload(Marshal.Mode.PLAYERS), unload(Marshal.Mode.MAP));
    }

    private void storeGameOrders()
    {
        game.db.storeGameOrders(gameId, unload(Marshal.Mode.ORDERS));
    }

    private void storeTurnOrders()
    {
        game.db.storeTurnOrders(gameId, battle.getTurnCount(), unload(Marshal.Mode.ORDERS));
    }

    private void storeNewGameTurn()
    {
        game.db.storeGameState(gameId, battle.getTurnCount(), battle.getPlayer().id, unload(Marshal.Mode.PLAYERS), unload(Marshal.Mode.MAP));
        game.db.clearGameOrders(gameId);
        game.db.storeTurnState(gameId);
    }

    private boolean loadTurn(int turn)
    {
        GameRecord r = game.db.loadTurn(gameId, turn);
        if (r == null)
            return false;
        battle.turnDone();

        load(Marshal.Mode.PLAYER, r.players);
        validateState(r);
        load(Marshal.Mode.ORDERS, r.orders);
        r.dispose();
        return true;
    }

    private void validateState(GameRecord r)
    {
        String playersH = game.db.getDigest(unload(Marshal.Mode.PLAYERS));
        if (!playersH.equals(r.playersH)) {
            RustAndDust.error("playersH does not match");
            System.err.println("DB");
            System.err.println(r.players);
            System.err.println("UNLOAD");
            System.err.println(unload(Marshal.Mode.PLAYERS));
        }
        String mapH = game.db.getDigest(unload(Marshal.Mode.MAP));
        if (!mapH.equals(r.mapH)) {
            RustAndDust.error("mapH does not match");
            System.err.println("DB");
            System.err.println(r.map);
            System.err.println("UNLOAD");
            System.err.println(unload(Marshal.Mode.MAP));
        }
    }

    // INPUTS

    public boolean drag(float x, float y, int dx, int dy)
    {
        if (!blockHud && hud.drag(x, y, dx, dy))
            return true;
        return false;
    }

    public void touchDown(float hudX, float hudY, float mapX, float mapY)
    {
        if (!blockHud && hud.hit(hudX, hudY, inAnimation()))
            return;

        touchedHex = (blockMap ? null : map.getHexAt(mapX, mapY));
    }

    public void touchUp(float hudX, float hudY, float mapX, float mapY)
    {
        if (!blockMap && (touchedHex != null) && (touchedHex == map.getHexAt(mapX, mapY)))
            state.touch(touchedHex);
    }

    // MESSAGES

    public void sendMsg(MsgType msgType)
    {
        sendMsg(msgType, null);
    }

    public void sendMsg(MsgType msgType, Object data)
    {
        RustAndDust.debug(String.format("Msg : %s %s", msgType, data));
        switch(msgType)
        {
            case ANIMATIONS_DONE:   animationsDone(); break;
            case UNIT_DOCK_TOGGLE:  unitDockToggle(); break;
            case UNIT_DEPLOYED:     deploymentState.processMsg(msgType, data); break;
            default:
                if (!this.state.processMsg(msgType, data))
                    RustAndDust.error(String.format("%s does not handle msg : %s %s", this.state, msgType, data));
                break;
        }
    }

    // EVENTS

    public void postTurnDone() { postEvent(EventType.TURN_DONE); }
    public void postActionAborted() { postEvent(EventType.ACTION_ABORTED); }
    public void postReplayDone(StateType stateType) { postEvent(EventType.REPLAY_DONE, stateType); }

    public void post(StateType stateType)
    {
        postEvent(EventType.STATE_CHANGE, stateType);
    }

    public void postOrder(Order order)
    {
        postOrder(order, null);
    }

    public void postInitOrder(Order order)
    {
        // postEvent(EventType.ORDER, order);
        // postEvent(EventType.ORDER_DONE, stateType);
        executeOrder(order);
        orderDone(null);
    }

    public void postOrder(Order order, StateType stateType)
    {
        postEvent(EventType.ORDER, order);
        switch(order.type)
        {
            case END:
            case REVERT:
                break;
            default:
                postEvent(EventType.ANIMATION, StateType.WAIT_EVENT);
        }
        postEvent(EventType.ORDER_DONE, stateType);
    }

    public void postEvent(EventType type)
    {
        postEvent(type, null);
    }

    public void postEvent(EventType type, Object data)
    {
        Event evt = freeEvents.pop();
        if (evt == null)
            evt = new Event();
        evt.type = type;
        evt.data = data;
        events.enqueue(evt);
    }

    public void processEvent(float delta)
    {
        if (blockEvents > 0f) {
            blockEvents -= delta;
            if (blockEvents > 0f)
                return;
        }
        if ((events.size() <= 0) || inAnimation())
            return;

        Event evt = events.dequeue();
        RustAndDust.debug(evt.toString());

        switch(evt.type)
        {
            case ORDER:             executeOrder((Order) evt.data); break;
            case ORDER_DONE:        orderDone((StateType) evt.data); break;
            case STATE_CHANGE:      setState((StateType) evt.data); break;
            case REPLAY_DONE:       replayDone((StateType) evt.data); break;
            case TURN_DONE:         turnDone(); break;
            case ACTION_ABORTED:    abortAction(); break;
            case EXIT_BATTLE:       exitBattle(); break;
            case ANIMATION:
                stateAfterAnimation = (StateType) evt.data;
                setState(StateType.ANIMATION);
                break;
            default:
                RustAndDust.error(String.format("Unhandled Event Type : %s %s", evt.type, evt.data));
        }
        freeEvents.push(evt);
    }

    private boolean inAnimation()
    {
        return (this.stateType == StateType.ANIMATION);
    }

    private void animationsDone()
    {
        if (debugCtrl) RustAndDust.debug("    ANIMATIONS DONE");

        if (hud.dialogActive())
            hud.notifyAnimationsDone();

        if (mode == Mode.LOADING) {
            mode = ((stateAfterAnimation == StateType.REPLAY) ? Mode.REPLAY : Mode.PLAY);
            if ((battle.getTurnCount() == 0) && (mode == Mode.PLAY)) {
                map.clear();
                storeInitialState();
            }
        }

        this.blockMap = false;
        StateType tmp = stateAfterAnimation;
        stateAfterAnimation = StateType.WAIT_EVENT;
        setState(tmp);
    }

    private void replayDone(StateType nextState)
    {
        if (debugCtrl) RustAndDust.debug("    REPLAY DONE");
        if (replayBattle) {
            if (loadTurn(battle.getTurnCount() + 1)) {
                map.prepareReplayLastTurn();
                setState(StateType.REPLAY);
                this.stateAfterAnimation = StateType.REPLAY;
                blockEvents = 0.5f;
                return;
            }
            nextState = null;
        }
        hud.notify("Replay Done", Position.MIDDLE_CENTER);
        mode = Mode.PLAY;
        if (nextState != null) {
            setState(nextState);
        } else {
            if (!synched) {
                storeGameState();
                synched = true;
            }
            checkPlayer(battle.getState(), (mode == Mode.PLAY));
        }
    }

    private void executeOrder(Order order)
    {
        if (debugCtrl) RustAndDust.debug("    EXECUTE ORDER");
        lastOrder = order;
        map.execute(order);
        if ((order.type == Order.OrderType.ENGAGE) && !order.replay) {
            game.ctrl.hud.engagementSummary(order.engagement);
        }
        if (mode == Mode.PLAY)
            storeGameOrders();
        hud.update();
    }

    private void orderDone(StateType nextState)
    {
        if (debugCtrl) RustAndDust.debug("    ORDER DONE -> " + nextState);
        Order order = this.lastOrder;
        this.lastOrder = null;
        if (nextState == null)
            nextState = battle.getState();

        completeOrder(order);

        if (mode == Mode.LOADING)
            return;

        if (mode == Mode.REPLAY) {
            if (order.cost > 0)
                battle.getPlayer().burnDownOneAp();
            hud.update();
            blockEvents = 0.2f;
            post(nextState);
            return;
        }

        if (order.cost == 0) {
            post(nextState);
            return;
        }

        battle.getPlayer().burnDownOneAp();
        hud.notify("1 Action Point burnt", Position.BOTTOM_CENTER);
        checkPlayer(nextState, (mode == Mode.PLAY));
        storeGameState();
    }

    private void checkPlayer(StateType nextState, boolean notify)
    {
        if (battle.getPlayer().apExhausted()) {
            if (notify)
                hud.notify("No more Action Points", Position.MIDDLE_CENTER);
            postTurnDone();
        } else if (!battle.getPlayer().canDoSomething()) {
            if (notify)
                hud.notify("No available Actions", Position.MIDDLE_CENTER);
            postTurnDone();
        } else {
            post(nextState);
        }
        hud.update();
    }

    private void completeOrder(Order order)
    {
        switch(order.type)
        {
            case MOVE:      completeMoveOrder(order, (Unit) order.move.pawn); break;
            case ENGAGE:    completeEngagementOrder(order, order.engagement.defender); break;
            case PROMOTE:   battle.getPlayer().promote(order.leader); break;
            case REVERT:    break;
            case END:       break;
            default:        break;
        }
    }

    private void completeEngagementOrder(Order order, Unit unit)
    {
        if (order.engagement.success) {
            battle.getPlayer().engagementWon += 1;
            battle.getOpponent().casualty(unit);
        } else {
            battle.getPlayer().engagementLost += 1;
        }
    }

    private void completeMoveOrder(Order order, Unit unit)
    {
        switch(order.move.type)
        {
            case EXIT:      battle.getPlayer().unitWithdraw(unit); break;
            case SET:       battle.getPlayer().unitEntry(unit); break;
            case ENTER:     battle.getPlayer().unitEntry(unit); break;
            case REGULAR:   break;
            default:        break;
        }
    }

    private void turnDone()
    {
        if (debugCtrl) RustAndDust.debug("    TURN DONE");

        setState(StateType.WAIT_EVENT);
        storeTurnOrders();

        if (battle.turnDone())
            hud.victory(battle.getPlayer(), battle.getOpponent());
        else {
            hud.update();
            if (battle.getPlayer().hasReinforcement())
                hud.pushNotify("You have reinforcement", Position.MIDDLE_CENTER);
            if (!battle.getPlayer().canDoSomething()) {
                hud.pushNotify("No available Actions", Position.MIDDLE_CENTER);
                postTurnDone();
            } else {
                post(battle.getState());
            }
        }

        storeNewGameTurn();
    }

    private void abortAction()
    {
        if (debugCtrl) RustAndDust.debug("    ABORT ACTION");
        post(battle.getState());
    }

    private void exitBattle()
    {
        if (debugCtrl) RustAndDust.debug("    EXIT BATTLE");
        Unit.clear();
        game.switchToMenu();
    }

    private void unitDockToggle()
    {
        if (this.stateType == StateType.SELECT) {
            sendMsg(MsgType.CANCEL);
            post(StateType.REINFORCEMENT);
        }
        else if (this.stateType == StateType.REINFORCEMENT) {
            sendMsg(MsgType.OK);
            post(StateType.SELECT);
        }
    }

    //

    private void setState(StateType nextState)
    {
        if (stateType == nextState)
            RustAndDust.error("***!!!*** STATE LOOP ********************************************************************** " + stateType);

        if (nextState == StateType.WAIT_EVENT) {
            stateType = nextState;
            if (debugCtrl) RustAndDust.debug("    WAIT_EVENT");
            return;
        }

        depth += 1;
        if (depth > 1)
            RustAndDust.error(String.format("***!!!*** STATE DEPTH : %d", depth));

        if ((mode == Mode.PLAY) && (nextState == StateType.DEPLOYMENT)) {
            if (battle.isDeploymentDone())
                hud.askEndDeployment();
        }

        hud.playerInfo.blockEndOfTurn(nextState != StateType.SELECT);

        this.state = getNextState(nextState);
        StateType tmp = stateType;
        stateType = nextState;
        this.state.enterFrom(tmp);

        depth -= 1;
    }

    private State getNextState(StateType nextState)
    {
        RustAndDust.debug("  State Change", String.format("%s -> %s", stateType, nextState));

        switch(nextState)
        {
            case SELECT:        return selectState;
            case MOVE:          return moveState;
            case PROMOTE:       return promoteState;
            case ENGAGE:        return engageState;
            case ANIMATION:     return animationState;
            case DEPLOYMENT:    return deploymentState;
            case REINFORCEMENT: return reinforcementState;
            case REPLAY:        return replayState;
            default:
                RustAndDust.error(String.format("Unhandled State : %s", nextState));
        }

        return this.state;
    }
}