import os
import re
import json
from typing import Dict, Any, Set
from pathlib import Path

class GameSettingsValidator:
    def __init__(self):
        current_dir = Path(__file__).parent
        self.settings_path = current_dir / "src" / "components" / "games" / "gameSettings.js"
        self.games = set()
        self.global_settings = {}
        try:
            self.load_settings()
        except Exception as e:
            print(f"Error initializing validator: {e}")
            raise

    def load_settings(self):
        """Load the games list from gameSettings.js"""
        try:
            with open(self.settings_path, 'r', encoding='utf-8') as file:
                content = file.read()
            
            # First, find the GAME_SETTINGS object
            content = content.replace('\n', ' ')  # Remove newlines for easier regex
            settings_match = re.search(r'GAME_SETTINGS\s*=\s*{(.*)};\s*$', content)
            if not settings_match:
                raise ValueError("Could not find GAME_SETTINGS object")
            
            # Look for game definitions - they have specific properties like ICON and TIME_LIMIT
            game_pattern = r'([A-Z]+):\s*{\s*ICON:'
            games_matches = re.finditer(game_pattern, settings_match.group(1))
            
            for match in games_matches:
                game_name = match.group(1)
                if game_name != 'GLOBAL':
                    self.games.add(game_name.lower())
            
            print(f"Found games: {self.games}")
            
        except Exception as e:
            print(f"Error loading settings: {e}")
            raise

    def validate_save_data(self, save_data: Dict[str, Any]) -> bool:
        """Validate save data structure"""
        try:
            state = save_data.get('state', {})
            
            # Check required top-level fields
            required_fields = {'points', 'coins', 'games', 'automation', 'exchangeRates', 'selectedGame'}
            missing_fields = required_fields - set(state.keys())
            if missing_fields:
                raise ValueError(f"Missing required fields: {missing_fields}")

            # Validate points structure
            points = state.get('points', {})
            for game in self.games:
                points_key = f"{game}Points"
                if not isinstance(points.get(points_key, 0), (int, float)):
                    raise ValueError(f"{points_key} must be a number")

            # Validate games structure
            games = state.get('games', {})
            for game in self.games:
                if game not in games:
                    raise ValueError(f"Missing game configuration for {game}")
                game_config = games[game]
                required_game_fields = {'unlocked', 'cost', 'name', 'icon', 'size', 'state'}
                missing_game_fields = required_game_fields - set(game_config.keys())
                if missing_game_fields:
                    raise ValueError(f"Game {game} missing required fields: {missing_game_fields}")

            # Validate automation structure
            automation = state.get('automation', {})
            for game in self.games:
                if game not in automation:
                    raise ValueError(f"Missing automation configuration for {game}")
                auto_config = automation[game]
                required_auto_fields = {'unlocked', 'level', 'cost', 'pointsPerSecond', 'requiredCoins'}
                missing_auto_fields = required_auto_fields - set(auto_config.keys())
                if missing_auto_fields:
                    raise ValueError(f"Automation config for {game} missing fields: {missing_auto_fields}")

            # Validate exchange rates
            exchange_rates = state.get('exchangeRates', {})
            for game in self.games:
                if game not in exchange_rates:
                    raise ValueError(f"Missing exchange rate configuration for {game}")
                rate_config = exchange_rates[game]
                if not isinstance(rate_config.get('baseRate', 0), (int, float)):
                    raise ValueError(f"Exchange rate baseRate for {game} must be a number")

            # Basic type checks
            if not isinstance(state.get('coins', 0), int):
                raise ValueError("Coins must be an integer")

            # Validate selectedGame
            selected_game = state.get('selectedGame', '').lower()
            if selected_game and selected_game not in self.games:
                raise ValueError(f"Selected game '{selected_game}' not valid")

            return True

        except Exception as e:
            print(f"Validation error: {e}")
            raise ValueError(f"Save data validation failed: {str(e)}")

def get_game_validator():
    return GameSettingsValidator()