/* tt-test.c - transposition table test.
 *
 * Copyright (C) 2024 Bruno Raoult ("br")
 * Licensed under the GNU General Public License v3.0 or later.
 * Some rights reserved. See COPYING.
 *
 * You should have received a copy of the GNU General Public License along with this
 * program. If not, see <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
 *
 * SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <unistd.h>
#include <time.h>
#include <locale.h>
#include <limits.h>

#include <brlib.h>

#include "chessdefs.h"
#include "fen.h"
#include "position.h"
#include "move.h"
#include "move-do.h"
#include "move-gen.h"
#include "search.h"

// #include "common-test.h"

static move_t move_in_movelist(movelist_t *ml, square_t from, square_t to, piece_type_t pt)
{
    const int nmoves = ml->nmoves;
    const move_t *moves = ml->move;
    int movenum = 0;
    move_t move;
    for (movenum = 0; movenum < nmoves; ++movenum) {
        move = moves[movenum];
        printf("compare %s%s to %s%s pt=%d ",
               sq_to_string(from), sq_to_string(to),
               sq_to_string(move_from(move)),
               sq_to_string(move_to(move)),
               pt
            );
        if (move_from(move) == from && move_to(move) == to) {
            printf("HIT!\n");
            if (pt != NO_PIECE_TYPE && move_promoted(move) != pt)
                continue;
            printf("move_in_movelist(%s%s) found from=%s to=%s\n",
                   sq_to_string(from), sq_to_string(to),
                   sq_to_string(move_from(move)),
                   sq_to_string(move_to(move)));
            return move;
        } else
            puts("");
    }
    return MOVE_NONE;
}

static move_t move_from_str(pos_t *pos, const char *move)
{
    movelist_t movelist;
    square_t from = sq_from_string(move);
    square_t to = sq_from_string(move + 2);
    piece_type_t promoted = piece_t_from_char(*(move + 4));
    printf("from=%o to=%o promoted=%d\n", from, to, promoted);

    pos_set_checkers_pinners_blockers(pos);
    pos_legal(pos, pos_gen_pseudo(pos, &movelist));
    return  move_in_movelist(&movelist, from, to, promoted);
}

static void pr_entry(hentry_t *entry)
{
    if (!entry)
        printf("entry: NULL\n");
    else {
        printf("entry: key=%lx depth=%d n=%lu\n",
               entry->key, HASH_PERFT_DEPTH(entry->data),
               HASH_PERFT_VAL(entry->data));
    }
}

int main()
{
    pos_t *pos = NULL;
    char *token, *str, buf[128];
    hentry_t *entry;
    move_t move;
    state_t state;
    //movelist_t movelist;

    const char *moves_array[] = {
        "e2e4 e7e5 g1f3 b8c6",
        "e2e4 b8c6 g1f3 e7e5"
    };

    init_all();

    for (uint i = 0; i < ARRAY_SIZE(moves_array); ++i) {
        int depth = 0;
        str = strdup(moves_array[i]);
        printf("%2d: ", i + 1);

        pos = startpos(pos);
        entry = tt_store_perft(pos->key, 0, 123 + depth);
        pr_entry(entry);
        token = strtok(str, " \t");
        while (token) {
            depth++;
            printf("%s ", token);

            //pos_set_checkers_pinners_blockers(pos);
            //pos_legal(pos, pos_gen_pseudo(pos, &movelist));
            move = move_from_str(pos, token);
            printf("move: %s\n", move_to_str(buf, move, 0));
            move_do(pos, move, &state);
            if ((entry = tt_probe_perft(pos->key, depth))) {
                printf("tt hit: depth=%d val=%lu",
                       HASH_PERFT_DEPTH(entry->data),
                       HASH_PERFT_VAL(entry->data));
            } else {
                tt_store_perft(pos->key, i + 1, depth);
                printf("tt store: depth=%d val=%lu", depth, (u64)i * 123);
            };

            token = strtok(NULL, " \t");
        }
        printf("\n");
        free(str);
    }
    return 0;
}

/* ccls bug report: https://github.com/emacs-lsp/emacs-ccls/issues/126
 */
/*
 * int called(int), caller();
 *
 * /\**
 *  * called() - test ccls.
 *  * @x: int, the test value
 *  *
 *  * @called() description.
 *  *
 *  * @return: int, a very interesting value.
 *  *\/
 * int called(int x) { return x; }
 *
 * int caller()
 * {
 *     int i = 0;
 *     called(int x)
 *     return i;
 * }
 */