#include "Search.hpp"
#include "Move.hpp"
#include "Board.hpp"

int Search::search(Node *node, const Board &board, unsigned depth) {

    if (depth == 0) {
        return evaluate(board);
    }

    auto moves = Board::MoveVec();
    board.pseudoLegalMoves(moves);
    if (moves.empty()) {
        return evaluate(board);
    }

    int maxValue = kNegInfinity;
    for (auto &kMove: moves) {
        Board nodeBoard = board;
        nodeBoard.makeMove(kMove);

        Node child(kMove);
        child.value = search(&child, nodeBoard, depth - 1);

        auto value = -child.value;
        if (value > maxValue) {
            maxValue = value;
            node->next = std::make_unique<Node>(child);
        }
    }

    node->value = maxValue;

    return maxValue;
}

int Search::evaluate(const Board &board) {

    return board.evaluate();
}

PrincipalVariation Search::start(const Board &board) {
    auto rootMoves = Board::MoveVec();
    board.pseudoLegalMoves(rootMoves);

    if (rootMoves.size() <= 1) {
        auto b = board;
        return PrincipalVariation(rootMoves, b);
    }

    std::unique_ptr<RootNode> best = std::make_unique<RootNode>();
    for (const auto &kMove: rootMoves) {

        auto node = Node(kMove);

        Board nodeBoard = board;
        nodeBoard.makeMove(kMove);

        auto value = -search(&node, nodeBoard, 4);
        if (value > best->value) {
            best->child = std::make_unique<Node>(node);
            best->board = nodeBoard;
            best->value = value;
        }
    }

    auto moves = std::vector<Move>();
    auto current = std::move(best->child);
    do {
        moves.push_back(current->move);
        current = std::move(current->next);
    } while (current);

    return PrincipalVariation(moves, best->board);
}