#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""Service classes for Storm Games.

Provides centralized services to replace global variables:
- ConfigService: Manages game configuration
- VolumeService: Handles volume settings
- PathService: Manages file paths
"""

import configparser
import os
from xdg import BaseDirectory

# For backward compatibility
from .config import gamePath, globalPath, write_config, read_config

class ConfigService:
    """Configuration management service."""
    
    _instance = None
    
    @classmethod
    def get_instance(cls):
        """Get or create the singleton instance."""
        if cls._instance is None:
            cls._instance = ConfigService()
        return cls._instance
    
    def __init__(self):
        """Initialize configuration parsers."""
        self.local_config = configparser.ConfigParser()
        self.global_config = configparser.ConfigParser()
        self.game_title = None
        self.path_service = None
        
    def set_game_info(self, game_title, path_service):
        """Set game information and initialize configs.
        
        Args:
            game_title (str): Title of the game
            path_service (PathService): Path service instance
        """
        self.game_title = game_title
        self.path_service = path_service
        
        # Load existing configurations
        self.read_local_config()
        self.read_global_config()
    
    def read_local_config(self):
        """Read local configuration from file."""
        try:
            # Try to use path_service if available
            if self.path_service and self.path_service.game_path:
                with open(os.path.join(self.path_service.game_path, "config.ini"), 'r') as configfile:
                    self.local_config.read_file(configfile)
            # Fallback to global gamePath
            elif gamePath:
                with open(os.path.join(gamePath, "config.ini"), 'r') as configfile:
                    self.local_config.read_file(configfile)
            # Delegate to old function as last resort
            else:
                read_config(False)
                self.local_config = configparser.ConfigParser()
                self.local_config.read_dict(globals().get('localConfig', {}))
        except:
            pass
    
    def read_global_config(self):
        """Read global configuration from file."""
        try:
            # Try to use path_service if available
            if self.path_service and self.path_service.global_path:
                with open(os.path.join(self.path_service.global_path, "config.ini"), 'r') as configfile:
                    self.global_config.read_file(configfile)
            # Fallback to global globalPath
            elif globalPath:
                with open(os.path.join(globalPath, "config.ini"), 'r') as configfile:
                    self.global_config.read_file(configfile)
            # Delegate to old function as last resort
            else:
                read_config(True)
                self.global_config = configparser.ConfigParser()
                self.global_config.read_dict(globals().get('globalConfig', {}))
        except:
            pass
    
    def write_local_config(self):
        """Write local configuration to file."""
        try:
            # Try to use path_service if available
            if self.path_service and self.path_service.game_path:
                with open(os.path.join(self.path_service.game_path, "config.ini"), 'w') as configfile:
                    self.local_config.write(configfile)
            # Fallback to global gamePath
            elif gamePath:
                with open(os.path.join(gamePath, "config.ini"), 'w') as configfile:
                    self.local_config.write(configfile)
            # Delegate to old function as last resort
            else:
                # Update old global config
                globals()['localConfig'] = self.local_config
                write_config(False)
        except Exception as e:
            print(f"Warning: Failed to write local config: {e}")
    
    def write_global_config(self):
        """Write global configuration to file."""
        try:
            # Try to use path_service if available
            if self.path_service and self.path_service.global_path:
                with open(os.path.join(self.path_service.global_path, "config.ini"), 'w') as configfile:
                    self.global_config.write(configfile)
            # Fallback to global globalPath
            elif globalPath:
                with open(os.path.join(globalPath, "config.ini"), 'w') as configfile:
                    self.global_config.write(configfile)
            # Delegate to old function as last resort
            else:
                # Update old global config
                globals()['globalConfig'] = self.global_config
                write_config(True)
        except Exception as e:
            print(f"Warning: Failed to write global config: {e}")


class VolumeService:
    """Volume management service."""
    
    _instance = None
    
    @classmethod
    def get_instance(cls):
        """Get or create the singleton instance."""
        if cls._instance is None:
            cls._instance = VolumeService()
        return cls._instance
    
    def __init__(self):
        """Initialize volume settings."""
        self.bgm_volume = 0.75     # Default background music volume
        self.sfx_volume = 1.0      # Default sound effects volume
        self.master_volume = 1.0   # Default master volume
    
    def adjust_master_volume(self, change, pygame_mixer=None):
        """Adjust the master volume for all sounds.
        
        Args:
            change (float): Amount to change volume by (positive or negative)
            pygame_mixer: Optional pygame.mixer module for real-time updates
        """
        self.master_volume = max(0.0, min(1.0, self.master_volume + change))
        
        # Update real-time audio if pygame mixer is provided
        if pygame_mixer:
            # Update music volume
            if pygame_mixer.music.get_busy():
                pygame_mixer.music.set_volume(self.bgm_volume * self.master_volume)
            
            # Update all sound channels
            for i in range(pygame_mixer.get_num_channels()):
                channel = pygame_mixer.Channel(i)
                if channel.get_busy():
                    current_volume = channel.get_volume()
                    if isinstance(current_volume, (int, float)):
                        # Mono audio
                        channel.set_volume(current_volume * self.master_volume)
                    else:
                        # Stereo audio
                        left, right = current_volume
                        channel.set_volume(left * self.master_volume, right * self.master_volume)
    
    def adjust_bgm_volume(self, change, pygame_mixer=None):
        """Adjust only the background music volume.
        
        Args:
            change (float): Amount to change volume by (positive or negative)
            pygame_mixer: Optional pygame.mixer module for real-time updates
        """
        self.bgm_volume = max(0.0, min(1.0, self.bgm_volume + change))
        
        # Update real-time audio if pygame mixer is provided
        if pygame_mixer and pygame_mixer.music.get_busy():
            pygame_mixer.music.set_volume(self.bgm_volume * self.master_volume)
    
    def adjust_sfx_volume(self, change, pygame_mixer=None):
        """Adjust volume for sound effects only.
        
        Args:
            change (float): Amount to change volume by (positive or negative)
            pygame_mixer: Optional pygame.mixer module for real-time updates
        """
        self.sfx_volume = max(0.0, min(1.0, self.sfx_volume + change))
        
        # Update real-time audio if pygame mixer is provided
        if pygame_mixer:
            # Update all sound channels except reserved ones
            for i in range(pygame_mixer.get_num_channels()):
                channel = pygame_mixer.Channel(i)
                if channel.get_busy():
                    current_volume = channel.get_volume()
                    if isinstance(current_volume, (int, float)):
                        # Mono audio
                        channel.set_volume(current_volume * self.sfx_volume * self.master_volume)
                    else:
                        # Stereo audio
                        left, right = current_volume
                        channel.set_volume(left * self.sfx_volume * self.master_volume, 
                                          right * self.sfx_volume * self.master_volume)
    
    def get_bgm_volume(self):
        """Get the current BGM volume with master adjustment.
        
        Returns:
            float: Current adjusted BGM volume
        """
        return self.bgm_volume * self.master_volume
    
    def get_sfx_volume(self):
        """Get the current SFX volume with master adjustment.
        
        Returns:
            float: Current adjusted SFX volume
        """
        return self.sfx_volume * self.master_volume


class PathService:
    """Path management service."""
    
    _instance = None
    
    @classmethod
    def get_instance(cls):
        """Get or create the singleton instance."""
        if cls._instance is None:
            cls._instance = PathService()
        return cls._instance
    
    def __init__(self):
        """Initialize path variables."""
        self.global_path = None
        self.game_path = None
        self.game_name = None
        
        # Try to initialize from global variables for backward compatibility
        global gamePath, globalPath
        if gamePath:
            self.game_path = gamePath
        if globalPath:
            self.global_path = globalPath
    
    def initialize(self, game_title):
        """Initialize paths for a game.
        
        Args:
            game_title (str): Title of the game
        """
        self.game_name = game_title
        self.global_path = os.path.join(BaseDirectory.xdg_config_home, "storm-games")
        self.game_path = os.path.join(self.global_path, 
                                      str.lower(str.replace(game_title, " ", "-")))
        
        # Create game directory if it doesn't exist
        if not os.path.exists(self.game_path):
            os.makedirs(self.game_path)
            
        # Update global variables for backward compatibility
        global gamePath, globalPath
        gamePath = self.game_path
        globalPath = self.global_path
        
        return self