import logging
from datasets.data_files import DataFilesPatternsDict
from datasets import (
    GeneratorBasedBuilder,
    DatasetInfo,
    SplitGenerator,
    Split,
    DownloadManager,
    Features,
    Value,
    Array2D,
    Version,
    BuilderConfig
)
from adversarial_gym.chess_env import ChessEnv


class ChessPGNDataset(GeneratorBasedBuilder):
    BUILDER_CONFIGS = [
        BuilderConfig(
            name="default",
            version=Version("0.0.2"),
            description="Chess positions + moves + results, streamed from PGN shards",
            data_files=DataFilesPatternsDict({
                "train": "**/train/*.pgn",
                "test":  "**/test/*.pgn",
            }),
        ),
    ]
    DEFAULT_CONFIG_NAME = "default"
    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

        logging.getLogger(__name__).info(f"Loaded config: {self.config.name}")
        logging.getLogger(__name__).info(f"Data files: {self.config.data_files}")

        if self.config.data_dir:
            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')]

        elif self.config.data_files:
            train_files = self.config.data_files["train"]
            test_files  = self.config.data_files["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)