"""
Immersive Audio System with Dolby Atmos Integration
World-Class Audio Production Capabilities
"""

import json
import math
import datetime
from typing import Dict, List, Optional, Any, Tuple
from dataclasses import dataclass
from collections import defaultdict

@dataclass
class AudioSpeaker:
    """Individual speaker specification"""
    speaker_id: str
    speaker_type: str  # LCR, surround, height, subwoofer
    position: Dict[str, float]  # x, y, z coordinates in meters
    frequency_range: Tuple[float, float]  # Hz range
    max_spl: float  # dB SPL at 1m
    power_rating: float  # watts
    coverage_angle: float  # degrees
    
@dataclass
class AtmosRenderer:
    """Dolby Atmos rendering configuration"""
    renderer_id: str
    max_objects: int
    bed_channels: int
    output_format: str
    sampling_rate: int
    bit_depth: int

class ImmersiveAudioSystem:
    """Core audio system with Dolby Atmos integration"""
    
    def __init__(self):
        self.speaker_catalog = self._initialize_speaker_catalog()
        self.atmos_configurations = self._load_atmos_presets()
        self.room_models = self._initialize_room_models()
        
    def _initialize_speaker_catalog(self) -> Dict[str, AudioSpeaker]:
        """Initialize professional speaker catalog"""
        return {
            "main_lcr": AudioSpeaker(
                speaker_id="main_lcr",
                speaker_type="LCR",
                position={"x": 0.0, "y": 0.0, "z": 0.0},
                frequency_range=(35.0, 20000.0),
                max_spl=140.0,
                power_rating=2000.0,
                coverage_angle=90.0
            ),
            "surround_7.1": AudioSpeaker(
                speaker_id="surround_7.1",
                speaker_type="surround",
                position={"x": 0.0, "y": 0.0, "z": 0.0},
                frequency_range=(80.0, 20000.0),
                max_spl=125.0,
                power_rating=800.0,
                coverage_angle=120.0
            ),
            "height_dolby": AudioSpeaker(
                speaker_id="height_dolby",
                speaker_type="height",
                position={"x": 0.0, "y": 0.0, "z": 0.0},
                frequency_range=(100.0, 18000.0),
                max_spl=120.0,
                power_rating=500.0,
                coverage_angle=100.0
            ),
            "subwoofer_lfe": AudioSpeaker(
                speaker_id="subwoofer_lfe",
                speaker_type="subwoofer",
                position={"x": 0.0, "y": 0.0, "z": 0.0},
                frequency_range=(20.0, 120.0),
                max_spl=135.0,
                power_rating=4000.0,
                coverage_angle=360.0
            )
        }
    
    def _load_atmos_presets(self) -> Dict[str, AtmosRenderer]:
        """Load Dolby Atmos configuration presets"""
        return {
            "atmos_theater": AtmosRenderer(
                renderer_id="atmos_theater",
                max_objects=128,
                bed_channels=11,  # 7.1.2 converted to integer channels
                output_format="Dolby Atmos",
                sampling_rate=96000,
                bit_depth=24
            ),
            "atmos_music": AtmosRenderer(
                renderer_id="atmos_music",
                max_objects=64,
                bed_channels=12,  # 7.1.4 converted to integer channels
                output_format="Dolby Atmos Music",
                sampling_rate=192000,
                bit_depth=32
            ),
            "atmos_live": AtmosRenderer(
                renderer_id="atmos_live",
                max_objects=96,
                bed_channels=8,  # 5.1.2 converted to integer channels
                output_format="Dolby Atmos Live",
                sampling_rate=48000,
                bit_depth=24
            )
        }
    
    def _initialize_room_models(self) -> Dict[str, Dict[str, Any]]:
        """Initialize acoustic room models"""
        return {
            "small_venue": {
                "dimensions": {"length": 20.0, "width": 15.0, "height": 8.0},
                "reverb_time": 1.2,  # seconds
                "capacity": 500,
                "optimal_spl": 95.0  # dB
            },
            "medium_arena": {
                "dimensions": {"length": 60.0, "width": 40.0, "height": 15.0},
                "reverb_time": 2.1,
                "capacity": 5000,
                "optimal_spl": 105.0
            },
            "large_stadium": {
                "dimensions": {"length": 120.0, "width": 80.0, "height": 30.0},
                "reverb_time": 3.5,
                "capacity": 50000,
                "optimal_spl": 110.0
            }
        }
    
    def calculate_speaker_positions(self, room_type: str, config_type: str) -> Dict[str, Any]:
        """Calculate optimal speaker positions for room and configuration"""
        if room_type not in self.room_models:
            return {"error": "Room type not found"}
        
        if config_type not in self.atmos_configurations:
            return {"error": "Atmos configuration not found"}
        
        room = self.room_models[room_type]
        config = self.atmos_configurations[config_type]
        
        # Calculate speaker positions based on room dimensions
        positions = self._compute_speaker_layout(room, config)
        
        return {
            "room_type": room_type,
            "config_type": config_type,
            "speaker_positions": positions,
            "total_speakers": len(positions),
            "coverage_analysis": self._analyze_coverage(positions, room)
        }
    
    def _compute_speaker_layout(self, room: Dict[str, Any], config: AtmosRenderer) -> List[Dict[str, Any]]:
        """Compute detailed speaker layout"""
        positions = []
        room_dims = room["dimensions"]
        
        # Front LCR speakers
        front_height = room_dims["height"] * 0.7
        front_width = room_dims["width"] * 0.8
        
        positions.append({
            "speaker_id": "front_left",
            "type": "LCR",
            "position": {"x": -front_width/2, "y": room_dims["length"]*0.9, "z": front_height},
            "angle": 0.0
        })
        
        positions.append({
            "speaker_id": "front_center",
            "type": "LCR", 
            "position": {"x": 0.0, "y": room_dims["length"]*0.9, "z": front_height},
            "angle": 0.0
        })
        
        positions.append({
            "speaker_id": "front_right",
            "type": "LCR",
            "position": {"x": front_width/2, "y": room_dims["length"]*0.9, "z": front_height},
            "angle": 0.0
        })
        
        # Surround speakers
        surround_y = room_dims["length"] * 0.3
        surround_x = room_dims["width"] * 0.4
        surround_z = room_dims["height"] * 0.6
        
        positions.append({
            "speaker_id": "surround_left",
            "type": "surround",
            "position": {"x": -surround_x, "y": surround_y, "z": surround_z},
            "angle": 110.0
        })
        
        positions.append({
            "speaker_id": "surround_right", 
            "type": "surround",
            "position": {"x": surround_x, "y": surround_y, "z": surround_z},
            "angle": -110.0
        })
        
        # Height speakers for Atmos
        if "2" in str(config.bed_channels) or "4" in str(config.bed_channels):
            height_z = room_dims["height"] * 0.85
            
            positions.append({
                "speaker_id": "height_front_left",
                "type": "height",
                "position": {"x": -front_width/3, "y": room_dims["length"]*0.7, "z": height_z},
                "angle": 45.0
            })
            
            positions.append({
                "speaker_id": "height_front_right",
                "type": "height", 
                "position": {"x": front_width/3, "y": room_dims["length"]*0.7, "z": height_z},
                "angle": -45.0
            })
        
        # Subwoofers
        positions.append({
            "speaker_id": "subwoofer_left",
            "type": "subwoofer",
            "position": {"x": -room_dims["width"]/4, "y": room_dims["length"]*0.8, "z": 0.5},
            "angle": 0.0
        })
        
        positions.append({
            "speaker_id": "subwoofer_right",
            "type": "subwoofer",
            "position": {"x": room_dims["width"]/4, "y": room_dims["length"]*0.8, "z": 0.5},
            "angle": 0.0
        })
        
        return positions
    
    def _analyze_coverage(self, positions: List[Dict[str, Any]], room: Dict[str, Any]) -> Dict[str, Any]:
        """Analyze speaker coverage and uniformity"""
        room_volume = (room["dimensions"]["length"] * 
                      room["dimensions"]["width"] * 
                      room["dimensions"]["height"])
        
        # Calculate coverage uniformity
        coverage_scores = []
        for speaker in positions:
            speaker_type = speaker["type"]
            if speaker_type == "LCR":
                coverage = 0.85  # 85% coverage for main speakers
            elif speaker_type == "surround":
                coverage = 0.75
            elif speaker_type == "height":
                coverage = 0.70
            else:  # subwoofer
                coverage = 0.90
            
            coverage_scores.append(coverage)
        
        average_coverage = sum(coverage_scores) / len(coverage_scores)
        
        return {
            "average_coverage_percent": average_coverage * 100,
            "coverage_uniformity": max(coverage_scores) - min(coverage_scores),
            "room_volume_cubic_meters": room_volume,
            "speakers_per_cubic_meter": len(positions) / room_volume
        }
    
    def design_audio_system(self, venue_type: str, audience_size: int, budget: float) -> Dict[str, Any]:
        """Design complete audio system based on requirements"""
        # Select appropriate room model
        if audience_size <= 1000:
            room_type = "small_venue"
            config_type = "atmos_live"
        elif audience_size <= 10000:
            room_type = "medium_arena"
            config_type = "atmos_theater"
        else:
            room_type = "large_stadium"
            config_type = "atmos_theater"
        
        # Calculate speaker positions
        speaker_layout = self.calculate_speaker_positions(room_type, config_type)
        
        # Calculate power requirements
        total_power = self._calculate_power_requirements(speaker_layout, audience_size)
        
        # Generate equipment list
        equipment_list = self._generate_audio_equipment_list(speaker_layout, config_type)
        
        # Calculate system cost
        system_cost = self._calculate_system_cost(equipment_list, budget)
        
        return {
            "system_design": {
                "venue_type": venue_type,
                "audience_size": audience_size,
                "room_model": room_type,
                "atmos_config": config_type,
                "speaker_layout": speaker_layout,
                "power_requirements": total_power,
                "equipment_list": equipment_list,
                "cost_analysis": system_cost,
                "technical_specs": self._generate_technical_specs(config_type)
            }
        }
    
    def _calculate_power_requirements(self, speaker_layout: Dict[str, Any], audience_size: int) -> Dict[str, Any]:
        """Calculate total power requirements"""
        base_power_per_person = 2.0  # watts per person
        headroom_factor = 1.5  # 50% headroom
        
        required_power = audience_size * base_power_per_person * headroom_factor
        
        # Calculate speaker power
        speaker_power = 0
        for speaker in speaker_layout["speaker_positions"]:
            speaker_type = speaker["type"]
            if speaker_type == "LCR":
                speaker_power += 2000
            elif speaker_type == "surround":
                speaker_power += 800
            elif speaker_type == "height":
                speaker_power += 500
            else:  # subwoofer
                speaker_power += 4000
        
        return {
            "total_power_watts": max(required_power, speaker_power),
            "speaker_power_watts": speaker_power,
            "amplifier_power_watts": speaker_power * 1.2,  # 20% amp headroom
            "power_per_person_watts": required_power / audience_size
        }
    
    def _generate_audio_equipment_list(self, speaker_layout: Dict[str, Any], config_type: str) -> List[Dict[str, Any]]:
        """Generate detailed equipment list"""
        equipment = []
        
        # Count speakers by type
        speaker_counts = defaultdict(int)
        for speaker in speaker_layout["speaker_positions"]:
            speaker_counts[speaker["type"]] += 1
        
        # Add speakers to equipment list
        for speaker_type, count in speaker_counts.items():
            equipment.append({
                "category": "speakers",
                "type": speaker_type,
                "quantity": count,
                "model": f"{speaker_type}_pro"
            })
        
        # Add processing equipment
        config = self.atmos_configurations[config_type]
        equipment.extend([
            {
                "category": "processing",
                "type": "atmos_renderer",
                "quantity": 1,
                "model": "dolby_atmos_renderer_pro",
                "max_objects": config.max_objects
            },
            {
                "category": "processing", 
                "type": "audio_console",
                "quantity": 1,
                "model": "digital_mixer_64ch"
            },
            {
                "category": "amplification",
                "type": "power_amplifier",
                "quantity": math.ceil(len(speaker_layout["speaker_positions"]) / 2),
                "model": "amplifier_2ch_2000w"
            }
        ])
        
        return equipment
    
    def _calculate_system_cost(self, equipment_list: List[Dict[str, Any]], budget: float) -> Dict[str, Any]:
        """Calculate system cost and budget analysis"""
        # Cost per equipment type (simplified pricing)
        cost_per_unit = {
            "speakers": {"LCR": 5000, "surround": 2000, "height": 2500, "subwoofer": 6000},
            "processing": {"atmos_renderer": 25000, "audio_console": 35000},
            "amplification": {"power_amplifier": 8000}
        }
        
        total_cost = 0
        cost_breakdown = []
        
        for item in equipment_list:
            category = item["category"]
            item_type = item["type"]
            quantity = item["quantity"]
            
            if category in cost_per_unit and item_type in cost_per_unit[category]:
                unit_cost = cost_per_unit[category][item_type]
                item_cost = unit_cost * quantity
                total_cost += item_cost
                
                cost_breakdown.append({
                    "category": category,
                    "type": item_type,
                    "quantity": quantity,
                    "unit_cost": unit_cost,
                    "total_cost": item_cost
                })
        
        return {
            "total_system_cost": total_cost,
            "budget": budget,
            "budget_utilization_percent": (total_cost / budget) * 100,
            "cost_breakdown": cost_breakdown,
            "within_budget": total_cost <= budget
        }
    
    def _generate_technical_specs(self, config_type: str) -> Dict[str, Any]:
        """Generate technical specifications"""
        config = self.atmos_configurations[config_type]
        
        return {
            "audio_format": config.output_format,
            "max_objects": config.max_objects,
            "bed_channels": config.bed_channels,
            "sampling_rate": config.sampling_rate,
            "bit_depth": config.bit_depth,
            "frequency_response": "20Hz - 20kHz",
            "dynamic_range": "120dB",
            "thd": "<0.01%"
        }

# Test implementation
def test_immersive_audio_system():
    """Test the immersive audio system"""
    audio_system = ImmersiveAudioSystem()
    
    # Test speaker position calculation
    positions = audio_system.calculate_speaker_positions("medium_arena", "atmos_theater")
    print(f"✅ Speaker positions calculated: {positions['total_speakers']} speakers")
    
    # Test complete system design
    design = audio_system.design_audio_system("concert_venue", 5000, 500000)
    print(f"✅ System design completed: {design['system_design']['equipment_list'][0]['quantity']} equipment categories")
    
    # Test power requirements
    power = design['system_design']['power_requirements']
    print(f"✅ Power requirements: {power['total_power_watts']}W total")
    
    return {
        "success": True,
        "speakers_configured": positions["total_speakers"],
        "total_power_watts": power["total_power_watts"],
        "system_cost": design["system_design"]["cost_analysis"]["total_system_cost"]
    }

if __name__ == "__main__":
    test_result = test_immersive_audio_system()
    print(f"Test Result: {test_result}")