import logging, os
from datasets import (
    GeneratorBasedBuilder,
    DatasetInfo,
    SplitGenerator,
    Split,
    DownloadManager,
    Features,
    Value,
    Array2D,
    Version,
    BuilderConfig
)

from datasets.data_files import sanitize_patterns, DataFilesDict
from adversarial_gym.chess_env import ChessEnv



class ChessPGNConfig(BuilderConfig):
    def __init__(self, *, data_files: dict, **kwargs):
        super().__init__(**kwargs)
        # data_files is just {"train":"train/*.pgn", "test":"test/*.pgn"}
        self.data_files = data_files

class ChessPGNDataset(GeneratorBasedBuilder):
    VERSION = "0.0.1"
    BUILDER_CONFIGS = [
        ChessPGNConfig(
            name="default",
            version=Version("0.0.3"),     # bump this each time you update the script
            description="PGN shards of chess games",
            data_files={
                "train": "train/*.pgn",
                "test":  "test/*.pgn",
            },
        ),
    ]
    
    def _info(self):
        return DatasetInfo(
            description="Chess positions + moves + results, streamed from PGN shards",
            features=Features({
                "state":  Array2D((8,8), dtype="int8"),
                "action": Value("int16"),
                "result": Value("int8"),
            })
        )

    def _split_generators(self, dl_manager: DownloadManager):
        from pathlib import Path, os

        if self.config.data_files:
            train_files = self.config.data_files["train"]
            test_files  = self.config.data_files["test"]

        elif self.config.data_dir or self.config.data_files is None:
            repo_root = Path(self.config.data_dir)
            train_files = [repo_root / 'train' / f for f in os.listdir(repo_root / 'train')]
            test_files  = [repo_root / 'test'  / f for f in os.listdir(repo_root / 'test')]


        train_paths = dl_manager.download(train_files)
        test_paths  = dl_manager.download(test_files)

        return [
            SplitGenerator(
                name=Split.TRAIN,
                gen_kwargs={"shards": train_paths},
            ),
            SplitGenerator(
                name=Split.TEST,
                gen_kwargs={"shards": test_paths},
            ),
        ]
        
    def _generate_examples(self, shards):
        import chess.pgn
        uid = 0

        for path in shards:
            with open(path, "r") as f:
                while (game := chess.pgn.read_game(f)) is not None:
                    board = game.board()
                    base = {"1-0":1,"0-1":-1}.get(game.headers["Result"], 0)
                    for move in game.mainline_moves():
                        state  = ChessEnv.get_piece_configuration(board)
                        state  = state if board.turn else -state
                        action = ChessEnv.move_to_action(move)
                        result = base * (-1 if board.turn == 0 else 1)
                        yield uid, {
                            "state":  state.astype("int8"),
                            "action": int(action),
                            "result": int(result),
                        }
                        uid += 1
                        board.push(move)