"""Read Snail Chess Data records.

The files are xz-compressed (partNN.bin.xz). Decompressed, each one is a flat array of
32-byte little-endian records:

    occupied  u64     bit i set = square i is occupied (a1 = 0, b1 = 1, ..., h8 = 63)
    pieces    16 B    one 4-bit piece code per occupied square, in ascending square order,
                      low nibble first
    score     i16     search score in centipawns, from White's point of view
    base      i16     lean base eval (material + piece-square tables + pawn structure), White's view
    eval      i16     the generating engine's full static eval, White's view, without tempo
    flags     u8      bit 0 = black to move, bit 1 = endgame scaling applies to the base eval
    result    u8      game result: 0 = black won, 1 = draw, 2 = white won

Piece codes are kind << 1 | colour, with colour 0 = white and kinds
1 pawn, 2 knight, 3 bishop, 4 rook, 5 queen, 6 king.
"""

import lzma

import numpy as np

RECORD = np.dtype([
    ("occupied", "<u8"),
    ("pieces", "u1", 16),
    ("score", "<i2"),
    ("base", "<i2"),
    ("eval", "<i2"),
    ("flags", "u1"),
    ("result", "u1"),
])
assert RECORD.itemsize == 32

LETTERS = " ?PpNnBbRrQqKk"


def read(path):
    """Return the records of one .bin.xz (or already decompressed .bin) file as a numpy structured array."""
    path = str(path)
    if path.endswith(".xz"):
        with lzma.open(path) as f:
            return np.frombuffer(f.read(), dtype=RECORD)
    return np.memmap(path, dtype=RECORD, mode="r")


def squares(record):
    """Yield (square, piece code) for every piece in one record."""
    occupied = int(record["occupied"])
    pieces = record["pieces"]
    i = 0
    while occupied:
        square = (occupied & -occupied).bit_length() - 1
        occupied &= occupied - 1
        yield square, (int(pieces[i >> 1]) >> (4 * (i & 1))) & 15
        i += 1


def to_fen(record):
    """FEN of one record. Castling rights and en passant are not stored, so they are always '-'."""
    board = [""] * 64
    for square, code in squares(record):
        board[square] = LETTERS[code]
    rows = []
    for rank in range(7, -1, -1):
        row, empty = "", 0
        for file in range(8):
            piece = board[rank * 8 + file]
            if piece:
                row += (str(empty) if empty else "") + piece
                empty = 0
            else:
                empty += 1
        rows.append(row + (str(empty) if empty else ""))
    side = "b" if record["flags"] & 1 else "w"
    return f"{'/'.join(rows)} {side} - - 0 1"


def planes(records):
    """12 x 64 one-hot piece planes (white P N B R Q K, then black), shape (n, 768), uint8."""
    n = len(records)
    occupied = np.ascontiguousarray(records["occupied"]).view(np.uint8).reshape(n, 8)
    bits = np.unpackbits(occupied, axis=1, bitorder="little").astype(bool)
    packed = np.asarray(records["pieces"])
    nibbles = np.empty((n, 32), dtype=np.uint8)
    nibbles[:, 0::2] = packed & 15
    nibbles[:, 1::2] = packed >> 4
    order = np.cumsum(bits, axis=1) - 1
    rows, squares_ = np.nonzero(bits)
    codes = nibbles[rows, order[rows, squares_]].astype(np.int64)
    out = np.zeros((n, 768), dtype=np.uint8)
    out[rows, ((codes & 1) * 6 + (codes >> 1) - 1) * 64 + squares_] = 1
    return out


def target(records, scale=120.0):
    """Training target used for Shell: sigmoid(search score / scale), White's view.

    The scale was fitted per training run: 140 for gen4, 125 for gen5, 120 for gen6.
    """
    return 1.0 / (1.0 + np.exp(-records["score"].astype(np.float32) / scale))


if __name__ == "__main__":
    import sys

    records = read(sys.argv[1])
    print(f"{len(records):,} records")
    for record in records[:5]:
        print(to_fen(record), "score", int(record["score"]), "result", int(record["result"]))