controller.py

import random
import sys
from typing import List, Optional

from galactic_chess.ai.agent import AIAgent
from galactic_chess.ai.learning import SelfPlayLearner
from galactic_chess.game.game_state import GameState
from galactic_chess.ui.renderer import GalacticChessUI
from galactic_chess.utils.constants import FACTION_NAMES


def run_ai_vs_ai_match(
    agents: List[AIAgent],
    max_turns: int = 200,
    verbose: bool = True,
) -> Optional[int]:
    """Run a match between AI agents"""
    state = GameState()

    for turn in range(max_turns):
        if state.is_game_over():
            winner = state.get_winner()
            if verbose:
                print(
                    f"\nGame Over! {FACTION_NAMES[winner or 0]} wins after {turn} turns!"
                )
            return winner

        current = state.current_player

        if current in state.eliminated_players:
            state.advance_turn()
            continue

        agent = agents[current]
        move = agent.get_move(state)

        if move:
            if verbose and turn % 10 == 0:
                print(f"Turn {turn}: {FACTION_NAMES[current]} plays {move}")
            state = state.make_move(move)

        state.advance_turn()

    if verbose:
        print(f"\nGame ended in draw after {max_turns} turns")
    return None


def benchmark_algorithms() -> None:
    """Compare Max-N vs Paranoid performance"""
    print("=" * 60)
    print("Benchmarking Max-N vs Paranoid Search")
    print("=" * 60)

    results = {"maxn": 0, "paranoid": 0, "draws": 0}

    for game in range(5):
        print(f"\nGame {game + 1}/5")

        algorithms = ["maxn", "paranoid", "maxn"]
        random.shuffle(algorithms)

        agents = [AIAgent(i, algorithms[i], depth=2) for i in range(3)]

        winner = run_ai_vs_ai_match(agents, max_turns=100, verbose=False)

        if winner is not None:
            winning_algo = algorithms[winner]
            results[winning_algo] += 1
            print(f"  Winner: {FACTION_NAMES[winner]} ({winning_algo})")
        else:
            results["draws"] += 1
            print("  Draw")

    print("\n" + "=" * 60)
    print("Results:")
    print(f"  Max-N wins: {results['maxn']}")
    print(f"  Paranoid wins: {results['paranoid']}")
    print(f"  Draws: {results['draws']}")
    print("=" * 60)


def main() -> None:
    """Main entry point"""
    if len(sys.argv) > 1:
        if sys.argv[1] == "--benchmark":
            benchmark_algorithms()
            return

        if sys.argv[1] == "--selfplay":
            print("Running self-play learning...")
            learner = SelfPlayLearner(games_per_generation=5, population_size=4)

            for gen in range(3):
                print(f"\nGeneration {gen + 1}")
                weights = learner.run_generation()
                print(f"  Best weights: {weights.to_dict()}")

            learner.save_weights("learned_weights.json")
            print("\nWeights saved to learned_weights.json")
            return

        if sys.argv[1] == "--nogui":
            print("Running AI vs AI match (no GUI)...")
            agents = [
                AIAgent(0, "maxn", depth=3),
                AIAgent(1, "paranoid", depth=3),
                AIAgent(2, "maxn", depth=3),
            ]
            run_ai_vs_ai_match(agents, verbose=True)
            return

        print("Usage: python -m galactic_chess.main [--benchmark|--selfplay|--nogui]")
        return

    ui = GalacticChessUI()
    ui.run()


if __name__ == "__main__":
    main()