"""
水体管理器
负责管理水体的整体状态和配置
"""

import time
from typing import Dict, Any, List, Optional
import math

class WaterManager:
    """
    水体管理器
    负责管理水体的整体状态、配置和基本操作
    """
    
    def __init__(self, plugin):
        """
        初始化水体管理器
        
        Args:
            plugin: 水体和流体模拟插件实例
        """
        self.plugin = plugin
        self.enabled = False
        self.initialized = False
        
        # 水体类型定义
        self.water_types = {
            'ocean': {
                'name': '海洋',
                'description': '广阔的海水',
                'depth': 3000.0,        # 平均深度(米)
                'wave_height': 2.0,     # 平均波高(米)
                'wave_length': 50.0,    # 平均波长(米)
                'wave_speed': 5.0,      # 波速(m/s)
                'color': (0.0, 0.2, 0.6, 0.9),  # RGBA
                'refractive_index': 1.333,
                'absorption_coefficient': 0.02  # 光吸收系数
            },
            'lake': {
                'name': '湖泊',
                'description': '相对平静的淡水湖',
                'depth': 10.0,
                'wave_height': 0.3,
                'wave_length': 10.0,
                'wave_speed': 1.0,
                'color': (0.0, 0.4, 0.8, 0.85),
                'refractive_index': 1.333,
                'absorption_coefficient': 0.01
            },
            'river': {
                'name': '河流',
                'description': '流动的淡水',
                'depth': 2.0,
                'wave_height': 0.1,
                'wave_length': 5.0,
                'wave_speed': 2.0,
                'color': (0.0, 0.5, 0.9, 0.8),
                'refractive_index': 1.333,
                'absorption_coefficient': 0.005
            },
            'pool': {
                'name': '水池',
                'description': '人工水池',
                'depth': 1.5,
                'wave_height': 0.05,
                'wave_length': 2.0,
                'wave_speed': 0.5,
                'color': (0.1, 0.6, 0.9, 0.9),
                'refractive_index': 1.333,
                'absorption_coefficient': 0.002
            },
            'swamp': {
                'name': '沼泽',
                'description': '浅水湿地',
                'depth': 0.5,
                'wave_height': 0.02,
                'wave_length': 1.0,
                'wave_speed': 0.2,
                'color': (0.1, 0.3, 0.2, 0.7),
                'refractive_index': 1.333,
                'absorption_coefficient': 0.05
            }
        }
        
        # 水体配置
        self.water_config = {
            'resolution': 128,              # 网格分辨率
            'tessellation_factor': 4.0,     # 细分因子
            'lod_distance': 100.0,          # LOD距离
            'max_waves': 8,                 # 最大波浪数
            'foam_threshold': 0.7,          # 泡沫阈值
            'reflection_quality': 'medium',  # 反射质量
            'refraction_quality': 'medium'   # 折射质量
        }
        
        # 水体区域
        self.water_bodies = {}
        self.body_counter = 0
        
        # 水体状态
        self.water_states = {
            'total_area': 0.0,
            'total_volume': 0.0,
            'average_depth': 0.0,
            'surface_points': [],
            'underwater_points': []
        }
        
        # 环境影响因子
        self.environment_factors = {
            'wind_speed': 5.0,          # 风速(m/s)
            'wind_direction': 0.0,      # 风向(度)
            'temperature': 20.0,        # 温度(°C)
            'pressure': 101325.0,       # 大气压(Pa)
            'time_of_day': 12.0,        # 时间(小时)
            'season': 'summer'          # 季节
        }
        
        # 天气影响
        self.weather_effects = {
            'rain_intensity': 0.0,      # 雨强度(0-1)
            'storm_intensity': 0.0,     # 风暴强度(0-1)
            'fog_density': 0.0          # 雾密度(0-1)
        }
        
        # 统计信息
        self.stats = {
            'bodies_created': 0,
            'vertices_generated': 0,
            'wave_updates': 0,
            'reflection_updates': 0
        }
        
        print("✓ 水体管理器已创建")
        
    def initialize(self) -> bool:
        """
        初始化水体管理器
        
        Returns:
            是否初始化成功
        """
        try:
            self.initialized = True
            print("✓ 水体管理器初始化完成")
            return True
            
        except Exception as e:
            print(f"✗ 水体管理器初始化失败: {e}")
            import traceback
            traceback.print_exc()
            return False
            
    def enable(self) -> bool:
        """
        启用水体管理器
        
        Returns:
            是否启用成功
        """
        try:
            if not self.initialized:
                print("✗ 水体管理器未初始化")
                return False
                
            self.enabled = True
            print("✓ 水体管理器已启用")
            return True
            
        except Exception as e:
            print(f"✗ 水体管理器启用失败: {e}")
            import traceback
            traceback.print_exc()
            return False
            
    def disable(self):
        """禁用水体管理器"""
        try:
            self.enabled = False
            print("✓ 水体管理器已禁用")
            
        except Exception as e:
            print(f"✗ 水体管理器禁用失败: {e}")
            import traceback
            traceback.print_exc()
            
    def finalize(self):
        """清理水体管理器资源"""
        try:
            self.disable()
            self.water_bodies.clear()
            self.initialized = False
            print("✓ 水体管理器资源已清理")
            
        except Exception as e:
            print(f"✗ 水体管理器资源清理失败: {e}")
            import traceback
            traceback.print_exc()
            
    def update(self, dt: float):
        """
        更新水体管理器状态
        
        Args:
            dt: 时间增量
        """
        try:
            if not self.enabled:
                return
                
            # 更新统计信息
            self.stats['wave_updates'] += 1
            
        except Exception as e:
            print(f"✗ 水体管理器更新失败: {e}")
            import traceback
            traceback.print_exc()
            
    def get_water_types(self) -> List[str]:
        """
        获取所有水体类型
        
        Returns:
            水体类型列表
        """
        return list(self.water_types.keys())
        
    def get_water_info(self, water_type: str) -> Optional[Dict[str, Any]]:
        """
        获取水体类型信息
        
        Args:
            water_type: 水体类型
            
        Returns:
            水体信息字典或None
        """
        return self.water_types.get(water_type)
        
    def create_water_body(self, water_type: str, position: tuple, 
                         size: tuple, depth: float = None) -> int:
        """
        创建水体
        
        Args:
            water_type: 水体类型
            position: 位置坐标 (x, y, z)
            size: 区域大小 (width, height)
            depth: 深度(如果为None则使用默认值)
            
        Returns:
            水体ID
        """
        try:
            if water_type not in self.water_types:
                print(f"✗ 无效的水体类型: {water_type}")
                return -1
                
            body_id = self.body_counter
            self.body_counter += 1
            
            # 获取水体类型信息
            water_info = self.water_types[water_type]
            
            # 使用指定深度或默认深度
            if depth is None:
                depth = water_info['depth']
                
            # 计算面积和体积
            area = size[0] * size[1]
            volume = area * depth
            
            # 创建水体数据
            body_data = {
                'id': body_id,
                'type': water_type,
                'position': position,
                'size': size,
                'depth': depth,
                'area': area,
                'volume': volume,
                'active': True,
                'creation_time': time.time(),
                'last_update': time.time(),
                'wave_parameters': {
                    'height': water_info['wave_height'],
                    'length': water_info['wave_length'],
                    'speed': water_info['wave_speed']
                }
            }
            
            # 存储水体
            self.water_bodies[body_id] = body_data
            
            # 更新统计数据
            self.stats['bodies_created'] += 1
            self.water_states['total_area'] += area
            self.water_states['total_volume'] += volume
            
            print(f"✓ 水体已创建: {water_info['name']} (ID: {body_id})")
            return body_id
            
        except Exception as e:
            print(f"✗ 水体创建失败: {e}")
            import traceback
            traceback.print_exc()
            return -1
            
    def remove_water_body(self, body_id: int) -> bool:
        """
        移除水体
        
        Args:
            body_id: 水体ID
            
        Returns:
            是否移除成功
        """
        try:
            if body_id not in self.water_bodies:
                print(f"✗ 水体不存在: {body_id}")
                return False
                
            body_data = self.water_bodies[body_id]
            
            # 更新统计数据
            self.water_states['total_area'] -= body_data['area']
            self.water_states['total_volume'] -= body_data['volume']
            
            # 移除水体
            del self.water_bodies[body_id]
            
            print(f"✓ 水体已移除: ID {body_id}")
            return True
            
        except Exception as e:
            print(f"✗ 水体移除失败: {e}")
            import traceback
            traceback.print_exc()
            return False
            
    def get_water_body(self, body_id: int) -> Optional[Dict[str, Any]]:
        """
        获取水体信息
        
        Args:
            body_id: 水体ID
            
        Returns:
            水体信息或None
        """
        return self.water_bodies.get(body_id)
        
    def get_all_water_bodies(self) -> Dict[int, Dict[str, Any]]:
        """
        获取所有水体
        
        Returns:
            所有水体字典
        """
        return self.water_bodies.copy()
        
    def update_water_wave_parameters(self, body_id: int, parameters: Dict[str, float]):
        """
        更新水体波浪参数
        
        Args:
            body_id: 水体ID
            parameters: 波浪参数字典
        """
        try:
            if body_id not in self.water_bodies:
                return
                
            if 'wave_parameters' not in self.water_bodies[body_id]:
                self.water_bodies[body_id]['wave_parameters'] = {}
                
            self.water_bodies[body_id]['wave_parameters'].update(parameters)
            self.water_bodies[body_id]['last_update'] = time.time()
            
        except Exception as e:
            print(f"✗ 水体波浪参数更新失败: {e}")
            
    def update_environment_factors(self, factors: Dict[str, Any]):
        """
        更新环境因子
        
        Args:
            factors: 环境因子字典
        """
        self.environment_factors.update(factors)
        print(f"✓ 环境因子已更新: {factors}")
        
    def get_environment_factors(self) -> Dict[str, Any]:
        """
        获取环境因子
        
        Returns:
            环境因子字典
        """
        return self.environment_factors.copy()
        
    def update_weather_effects(self, effects: Dict[str, float]):
        """
        更新天气效果
        
        Args:
            effects: 天气效果字典
        """
        self.weather_effects.update(effects)
        print(f"✓ 天气效果已更新: {effects}")
        
    def get_weather_effects(self) -> Dict[str, float]:
        """
        获取天气效果
        
        Returns:
            天气效果字典
        """
        return self.weather_effects.copy()
        
    def set_water_config(self, config: Dict[str, Any]):
        """
        设置水体配置
        
        Args:
            config: 配置字典
        """
        self.water_config.update(config)
        print(f"✓ 水体配置已更新: {self.water_config}")
        
    def get_water_config(self) -> Dict[str, Any]:
        """
        获取水体配置
        
        Returns:
            水体配置字典
        """
        return self.water_config.copy()
        
    def get_water_states(self) -> Dict[str, Any]:
        """
        获取水体状态
        
        Returns:
            水体状态字典
        """
        return self.water_states.copy()
        
    def get_stats(self) -> Dict[str, Any]:
        """
        获取统计信息
        
        Returns:
            统计信息字典
        """
        return self.stats.copy()
        
    def reset_stats(self):
        """重置统计信息"""
        self.stats = {
            'bodies_created': 0,
            'vertices_generated': 0,
            'wave_updates': 0,
            'reflection_updates': 0
        }
        print("✓ 水体管理器统计信息已重置")
        
    def calculate_wave_energy(self, body_id: int) -> float:
        """
        计算波浪能量
        
        Args:
            body_id: 水体ID
            
        Returns:
            波浪能量
        """
        try:
            if body_id not in self.water_bodies:
                return 0.0
                
            body_data = self.water_bodies[body_id]
            wave_params = body_data.get('wave_parameters', {})
            
            height = wave_params.get('height', 0.0)
            speed = wave_params.get('speed', 0.0)
            
            # 简化的波浪能量计算 (与波高的平方和波速成正比)
            energy = 0.5 * 1000.0 * 9.81 * height * height * speed  # ρgh²v/2
            return energy
            
        except Exception as e:
            print(f"✗ 波浪能量计算失败: {e}")
            return 0.0
            
    def calculate_water_clarity(self, body_id: int) -> float:
        """
        计算水体清澈度
        
        Args:
            body_id: 水体ID
            
        Returns:
            水体清澈度 (0.0-1.0)
        """
        try:
            if body_id not in self.water_bodies:
                return 0.0
                
            body_data = self.water_bodies[body_id]
            water_info = self.water_types[body_data['type']]
            
            # 基础清澈度
            clarity = 1.0 - water_info['absorption_coefficient'] * 10
            
            # 受天气影响
            rain_factor = self.weather_effects['rain_intensity']
            storm_factor = self.weather_effects['storm_intensity']
            fog_factor = self.weather_effects['fog_density']
            
            # 降雨和风暴会降低清澈度
            clarity *= (1.0 - rain_factor * 0.3)
            clarity *= (1.0 - storm_factor * 0.5)
            clarity *= (1.0 - fog_factor * 0.4)
            
            # 确保在有效范围内
            clarity = max(0.0, min(1.0, clarity))
            
            return clarity
            
        except Exception as e:
            print(f"✗ 水体清澈度计算失败: {e}")
            return 0.5