package truelecter.checkers.client;

import java.util.Arrays;

import checkers.client.CheckersBot;
import checkers.client.Client;
import checkers.pojo.board.Letters;
import checkers.pojo.board.Numbers;
import checkers.pojo.checker.Checker;
import checkers.pojo.checker.CheckerColor;
import checkers.pojo.checker.CheckerType;
import checkers.pojo.checker.Position;
import checkers.pojo.step.Step;
import checkers.pojo.step.StepUnit;
import truelecter.checkers.board.Board;
import truelecter.checkers.board.Board.Cell;
import truelecter.checkers.board.Move;
import truelecter.checkers.board.MoveChain;
import truelecter.checkers.search.MiniMax;
import truelecter.checkers.search.evaluator.Oracle;

public class AIPlayerClient {

    private static class BooleanWrapper {
        private boolean value;

        public BooleanWrapper(boolean b) {
            value = b;
        }

        public boolean set(boolean v) {
            value = v;
            return value;
        }
    }

    private static CheckerColor myColor = null;

    public static void main(final String[] args) {
        int port;
        try {
            port = args.length > 1 ? Integer.valueOf(args[1]) : 3000;
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("Using default port: 3000");
            port = 3000;
        }
        String ip = args.length > 0 ? args[0] : "localhost";

        final MiniMax mm = new MiniMax(new Oracle());
        final BooleanWrapper isWhite = new BooleanWrapper(false);
        final BooleanWrapper asWhiteFirstMoveDone = new BooleanWrapper(false);

        Client client = new Client(ip, port, new CheckersBot() {
            @Override
            public void onGameStart(CheckerColor checkerColor) {
                System.out.println(checkerColor);
                isWhite.set(checkerColor == CheckerColor.WHITE);
                myColor = checkerColor;
            }

            @Override
            public Step next(checkers.pojo.board.Board board) {
                System.out.println("My turn");
                if (isWhite.value && !asWhiteFirstMoveDone.value) {
                    return FIRST_MOVE_WHITE;
                }
                Board b = translate(board, isWhite.value);
                System.out.println(b);
                MoveChain mc = mm.perform(b, (byte) 4, (byte) -1);
                System.out.println("Choosen move: " + mc);
                return translate(mc, isWhite.value);
            }

            @Override
            public void onGameEnd(String s) {
                System.out.println(s);
            }

            @Override
            public String clientBotName() {
                return args.length > 2 ? args[2] : "Hikki";
            }
        });
        client.run();
    }

    private static Board translate(checkers.pojo.board.Board b, boolean isWhite) {
        byte[][] rb = new byte[8][8];

        for (Checker c : b.getCheckers()) {
            byte sign = (byte) (c.getColor() == myColor ? -1 : 1);
            System.out.println("sign " + sign + ", checker = " + c);
            byte[] pos = translate(c.getPosition(), isWhite);
            rb[pos[0]][pos[1]] = (byte) (sign * (c.getType() == CheckerType.SIMPLE ? 1 : 10));
            System.out.println("rb[" + pos[0] + "][" + pos[1] + "]  = " + rb[pos[0]][pos[1]]);
        }
        System.out.println("Converted: ");
        Board res = new Board(rb);
        System.out.println(res);
        return res;
    }

    private static Step translate(MoveChain mc, boolean isWhite) {
        Step s = new Step();
        for (int i = 0; i < mc.size(); i++) {
            Move m = mc.get(i);
            s.addStep(new StepUnit(translate(m.from, isWhite), translate(m.to, isWhite)));
        }
        return s;
    }

    private static byte[] translate(Position p, boolean isWhite) {
        byte rx, ry;
        if (!isWhite) {
            // rx = (byte) (p.getLetter().getValue() - 1);
            // ry = (byte) (8 - p.getNumber().getValue());
            rx = (byte) (p.getLetter().getValue() - 1);
            ry = (byte) (p.getNumber().getValue() - 1);
        } else {
            // rx = (byte) (8 - p.getLetter().getValue());
            // ry = (byte) (p.getNumber().getValue() - 1);
            rx = (byte) (8 - p.getLetter().getValue());
            ry = (byte) (8 - p.getNumber().getValue());
        }
        return new byte[] { ry, rx };
    }

    private static Position translate(Cell c, boolean isWhite) {
        Letters l;
        Numbers n;
        if (isWhite) {
            l = Letters.getByValue(c.x + 1);
            n = Numbers.getByValue(c.y + 1);
        } else {
            l = Letters.getByValue(8 - c.x);
            n = Numbers.getByValue(8 - c.y);
        }
        return new Position(l, n);
    }

    private static final Step FIRST_MOVE_WHITE = new Step(
            Arrays.asList(new StepUnit[] { new StepUnit(new Position(Letters.B, Numbers._6), new Position(Letters.A, Numbers._5)) }));

}