"""CNN-preprocessed variant of the TH06 NEAT trainer."""

from __future__ import annotations

import argparse
import cProfile
import importlib.util
import pstats
import re
import sys
import threading
from pathlib import Path

import numpy as np
import torch

CNN_TRAIN_DIRECTORY = Path(__file__).resolve().parent
PYTHON_DIRECTORY = CNN_TRAIN_DIRECTORY.parent
PROJECT_DIRECTORY = PYTHON_DIRECTORY.parent
WEIGHTS_PATH = PYTHON_DIRECTORY / "cnn" / "weights" / "grid_autoencoder.pt"
sys.path.insert(0, str(PYTHON_DIRECTORY))

from cnn_encoder import CnnObservationEncoder
from cnn_training_ui import CnnTrainingUi


def _load_base_trainer():
    path = PYTHON_DIRECTORY / "neat_trainer.py"
    spec = importlib.util.spec_from_file_location("base_neat_trainer", path)
    if spec is None or spec.loader is None:
        raise ImportError(f"Unable to load NEAT trainer: {path}")
    module = importlib.util.module_from_spec(spec)
    sys.modules[spec.name] = module
    spec.loader.exec_module(module)
    return module


base = _load_base_trainer()
BaseConfig = base.NeatTrainerConfig
encoder_holder: dict[str, CnnObservationEncoder] = {}
force_cpu = False
profile_training = False
REWARD_COLUMNS = (
    ("survival", "survival"),
    ("score", "score_delta"),
    ("graze", "graze_delta"),
    ("powerups", "powerup"),
    ("focus", "focus_danger"),
    ("bomb", "bomb_misuse"),
    ("edge", "edge_hugging"),
    ("death", "death_penalty"),
    ("edge kill", "edge_termination"),
    ("total", "total"),
)


class CnnNeatTrainer(base.NeatTrainer):
    """Base trainer with an append-only log matching the reward UI table."""

    def __init__(self, config):
        self.generation_offset = 0
        super().__init__(config)

    def run(self):
        if not profile_training:
            return super().run()
        profiler = cProfile.Profile()
        stop_snapshots = threading.Event()
        snapshot_lock = threading.Lock()
        output_dir = Path(self.config.output_dir)

        def write_snapshot() -> None:
            with snapshot_lock:
                profile_path = output_dir / "cnn_training_profile.prof"
                report_path = output_dir / "cnn_training_profile.txt"
                profiler.dump_stats(str(profile_path))
                with report_path.open("w", encoding="utf-8") as report_file:
                    stats = pstats.Stats(profiler, stream=report_file).strip_dirs().sort_stats("cumulative")
                    stats.print_stats(80)

        def snapshot_loop() -> None:
            while not stop_snapshots.wait(10.0):
                write_snapshot()

        print(f"Profiling CNN-NEAT; results will be written to {self.config.output_dir}.")
        profiler.enable()
        snapshot_thread = threading.Thread(target=snapshot_loop, name="cnn-neat-profile", daemon=True)
        snapshot_thread.start()
        try:
            return super().run()
        finally:
            stop_snapshots.set()
            snapshot_thread.join()
            profiler.disable()
            write_snapshot()
            profile_path = output_dir / "cnn_training_profile.prof"
            report_path = output_dir / "cnn_training_profile.txt"
            print(f"CNN-NEAT profile saved: {profile_path} and {report_path}")


def cnn_encoder_factory(config):
    if config.dataset_directory is not None:
        config.dataset_directory = PROJECT_DIRECTORY / "dataset"
    encoder = CnnObservationEncoder(config, WEIGHTS_PATH, use_cpu=force_cpu)
    encoder_holder["encoder"] = encoder
    return encoder


def cnn_ui_factory(*args, **kwargs):
    ui = CnnTrainingUi(*args, **kwargs)
    encoder_holder["encoder"].set_ui(ui)
    return ui


def cnn_trainer_config(*args, **kwargs):
    config = BaseConfig(*args, **kwargs)
    config.output_dir = str(CNN_TRAIN_DIRECTORY / "neat_output")
    config.metrics_path = str(CNN_TRAIN_DIRECTORY / "neat_output" / "live_metrics.json")
    return config


def main(argv: list[str] | None = None) -> None:
    global force_cpu, profile_training
    parser = argparse.ArgumentParser(add_help=False)
    parser.add_argument("--cpu", action="store_true", help="run CNN grid preprocessing on CPU")
    parser.add_argument("--profile", action="store_true", help="write a CNN-NEAT timing profile to neat_output")
    raw_arguments = sys.argv[1:] if argv is None else argv
    cnn_args, arguments = parser.parse_known_args(raw_arguments)
    force_cpu = cnn_args.cpu
    profile_training = cnn_args.profile
    if "--help" in arguments or "-h" in arguments:
        print("CNN-NEAT options:\n  --cpu                 run CNN grid preprocessing on CPU\n  --profile             write timing profile to neat_output")
    if "--config" not in arguments and not any(argument.startswith("--config=") for argument in arguments):
        arguments.extend(("--config", str(CNN_TRAIN_DIRECTORY / "neat_config.ini")))
    base.ObservationEncoder = cnn_encoder_factory
    base.TrainingUi = cnn_ui_factory
    base.NeatTrainerConfig = cnn_trainer_config
    base.NeatTrainer = CnnNeatTrainer
    base.main(arguments)


if __name__ == "__main__":
    main()
