#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
SUW Core - Material Manager Module
拆分自: suw_impl.py (Line 880-1200, 6470-6950)
用途: Blender材质管理、纹理处理、材质应用
版本: 1.0.0
作者: SUWood Team
"""

from .memory_manager import memory_manager
import time
import logging
from typing import Dict, Any, Optional

# 设置日志
logger = logging.getLogger(__name__)

# 检查Blender可用性
try:
    import bpy
    BLENDER_AVAILABLE = True
except ImportError:
    BLENDER_AVAILABLE = False

# 【新增】材质类型常量 - 按照Ruby代码定义
MAT_TYPE_NORMAL = 0
MAT_TYPE_OBVERSE = 1
MAT_TYPE_NATURE = 2

# 导入内存管理器

# ==================== 材质管理器类 ====================


class MaterialManager:
    """材质管理器 - 负责所有材质相关操作"""

    def __init__(self):
        """
        初始化材质管理器 - 完全独立，不依赖suw_impl
        """
        self.textures = {}  # 材质缓存
        self.material_cache = {}  # 【修复】添加缺少的材质缓存字典
        self.material_stats = {
            "materials_created": 0,
            "textures_loaded": 0,
            "creation_errors": 0
        }

        # 材质类型配置
        self.mat_type = MAT_TYPE_NORMAL  # 当前材质类型
        self.back_material = True  # 是否应用背面材质

        logger.info("MaterialManager 初始化完成")

    def init_materials(self):
        """初始化材质 - 减少注册调用"""
        try:
            if not BLENDER_AVAILABLE:
                return

            logger.debug("初始化材质...")

            # 创建基础材质
            materials_to_create = [
                ("mat_default", (0.8, 0.8, 0.8, 1.0)),
                ("mat_select", (1.0, 0.5, 0.0, 1.0)),
                ("mat_normal", (0.7, 0.7, 0.7, 1.0)),
                ("mat_obverse", (0.9, 0.9, 0.9, 1.0)),
                ("mat_reverse", (0.6, 0.6, 0.6, 1.0)),
                ("mat_thin", (0.5, 0.5, 0.5, 1.0)),
                # 【新增】加工相关材质
                ("mat_machining", (0.0, 0.5, 1.0, 1.0)),  # 蓝色 - 有效加工
                ("mat_cancelled", (0.5, 0.5, 0.5, 1.0)),  # 灰色 - 取消的加工
            ]

            for mat_name, color in materials_to_create:
                if mat_name not in bpy.data.materials:
                    material = bpy.data.materials.new(name=mat_name)
                    material.use_nodes = True

                    # 设置基础颜色
                    if material.node_tree:
                        principled = material.node_tree.nodes.get(
                            "Principled BSDF")
                        if principled:
                            principled.inputs['Base Color'].default_value = color

                    # 只注册一次
                    memory_manager.register_object(material)
                    self.textures[mat_name] = material
                else:
                    # 如果材质已存在，直接使用
                    self.textures[mat_name] = bpy.data.materials[mat_name]

            logger.info("材质初始化完成")

        except Exception as e:
            logger.error(f"初始化材质失败: {e}")

    def add_mat_rgb(self, mat_id: str, alpha: float, r: int, g: int, b: int):
        """添加RGB材质"""
        try:
            if not BLENDER_AVAILABLE:
                return None

            # 检查材质是否已存在
            if mat_id in self.material_cache:
                material_name = self.material_cache[mat_id]
                if material_name in bpy.data.materials:
                    return bpy.data.materials[material_name]

            # 创建新材质
            material = bpy.data.materials.new(mat_id)
            material.use_nodes = True

            # 设置颜色
            if material.node_tree:
                principled = material.node_tree.nodes.get("Principled BSDF")
                if principled:
                    color = (r/255.0, g/255.0, b/255.0, alpha)
                    principled.inputs[0].default_value = color

                    # 设置透明度
                    if alpha < 1.0:
                        material.blend_method = 'BLEND'
                        # Alpha input
                        principled.inputs[21].default_value = alpha

            # 缓存材质
            self.material_cache[mat_id] = material.name
            self.textures[mat_id] = material
            memory_manager.register_object(material)

            logger.info(f"创建RGB材质: {mat_id}")
            return material

        except Exception as e:
            logger.error(f"创建RGB材质失败: {e}")
            return None

    def get_texture(self, key: str):
        """获取纹理材质 - 修复版本，支持Default_前缀查找"""
        if not BLENDER_AVAILABLE:
            return None

        try:
            # 检查键是否有效
            if not key:
                return self.textures.get("mat_default")

            # 【修复1】从缓存中获取
            if key in self.textures:
                material = self.textures[key]
                # 验证材质是否仍然有效
                if material and material.name in bpy.data.materials:
                    return material
                else:
                    # 清理无效的缓存
                    del self.textures[key]

            # 【修复2】在现有材质中查找 - 支持多种匹配方式
            for material in bpy.data.materials:
                material_name = material.name

                # 精确匹配
                if key == material_name:
                    self.textures[key] = material
                    logger.info(f"✅ 找到精确匹配材质: {key}")
                    return material

                # 包含匹配（处理Default_前缀）
                if key in material_name:
                    self.textures[key] = material
                    logger.info(f"✅ 找到包含匹配材质: {key} -> {material_name}")
                    return material

                # Default_前缀匹配
                if material_name.startswith(f"Default_{key}"):
                    self.textures[key] = material
                    logger.info(f"✅ 找到Default_前缀材质: {key} -> {material_name}")
                    return material

            # 【修复3】如果没找到，尝试创建默认材质
            logger.warning(f"未找到纹理: {key}，尝试创建默认材质")
            try:
                # 创建默认材质
                default_material = bpy.data.materials.new(
                    name=f"Default_{key}")
                default_material.use_nodes = True

                # 设置基础颜色
                if default_material.node_tree:
                    principled = default_material.node_tree.nodes.get(
                        "Principled BSDF")
                    if principled:
                        # 使用灰色作为默认颜色
                        principled.inputs['Base Color'].default_value = (
                            0.7, 0.7, 0.7, 1.0)

                # 缓存材质
                self.textures[key] = default_material
                if memory_manager:
                    memory_manager.register_object(default_material)

                logger.info(f"✅ 创建默认材质: Default_{key}")
                return default_material

            except Exception as create_error:
                logger.error(f"创建默认材质失败: {create_error}")

            # 【修复4】返回默认材质
            default_material = self.textures.get("mat_default")
            if default_material and default_material.name in bpy.data.materials:
                logger.warning(f"使用系统默认材质: {key}")
                return default_material

            logger.warning(f"未找到纹理: {key}")
            return None

        except Exception as e:
            logger.error(f"获取纹理失败: {e}")
            return None

    def apply_material_to_face(self, face, material):
        """为面应用材质"""
        try:
            if not face or not material or not BLENDER_AVAILABLE:
                return

            if hasattr(face, 'data') and face.data:
                if not face.data.materials:
                    face.data.materials.append(material)
                else:
                    face.data.materials[0] = material

        except Exception as e:
            logger.error(f"为面应用材质失败: {e}")

    def create_transparent_material(self):
        """创建透明材质"""
        try:
            if not BLENDER_AVAILABLE:
                return None

            # 检查是否已存在透明材质
            transparent_mat_name = "mat_transparent"
            if transparent_mat_name in self.textures:
                return self.textures[transparent_mat_name]

            # 创建透明材质
            material = bpy.data.materials.new(name=transparent_mat_name)
            material.use_nodes = True
            material.blend_method = 'BLEND'

            # 设置透明属性
            if material.node_tree:
                principled = material.node_tree.nodes.get("Principled BSDF")
                if principled:
                    # 设置基础颜色为半透明白色
                    principled.inputs['Base Color'].default_value = (
                        1.0, 1.0, 1.0, 0.5)
                    # 设置Alpha
                    principled.inputs['Alpha'].default_value = 0.5

            # 缓存材质
            self.textures[transparent_mat_name] = material
            memory_manager.register_object(material)

            logger.info("创建透明材质完成")
            return material

        except Exception as e:
            logger.error(f"创建透明材质失败: {e}")
            return None

    # ==================== 【修复】添加缺少的c02方法 ====================

    def c02(self, data: Dict[str, Any]):
        """add_texture - 添加纹理"""
        try:
            logger.info(
                f"🎨 MaterialManager.c02: 处理纹理 {data.get('ckey', 'unknown')}")

            if not BLENDER_AVAILABLE:
                logger.warning("Blender不可用，跳过纹理创建")
                return None

            ckey = data.get("ckey")
            if not ckey:
                logger.warning("纹理键为空，跳过创建")
                return None

            # 检查纹理是否已存在
            if ckey in self.textures:
                existing_material = self.textures[ckey]
                if existing_material and existing_material.name in bpy.data.materials:
                    logger.info(f"✅ 纹理 {ckey} 已存在")
                    return existing_material
                else:
                    # 清理无效缓存
                    del self.textures[ckey]

            # 创建新材质
            material = bpy.data.materials.new(name=ckey)
            material.use_nodes = True

            # 获取材质节点
            nodes = material.node_tree.nodes
            links = material.node_tree.links

            # 清理默认节点
            nodes.clear()

            # 创建基础节点
            principled = nodes.new(type='ShaderNodeBsdfPrincipled')
            principled.location = (0, 0)

            output = nodes.new(type='ShaderNodeOutputMaterial')
            output.location = (300, 0)

            # 连接基础节点
            links.new(principled.outputs['BSDF'], output.inputs['Surface'])

            # 设置纹理图像
            src_path = data.get("src")
            if src_path:
                try:
                    import os
                    if os.path.exists(src_path):
                        # 加载图像
                        image_name = os.path.basename(src_path)
                        image = bpy.data.images.get(image_name)

                        if not image:
                            image = bpy.data.images.load(src_path)
                            if memory_manager:
                                memory_manager.register_image(image)

                        # 创建纹理节点
                        tex_coord = nodes.new(type='ShaderNodeTexCoord')
                        tex_coord.location = (-600, 0)

                        tex_image = nodes.new(type='ShaderNodeTexImage')
                        tex_image.image = image
                        tex_image.location = (-300, 0)

                        # 连接节点
                        links.new(
                            tex_coord.outputs['UV'], tex_image.inputs['Vector'])
                        links.new(
                            tex_image.outputs['Color'], principled.inputs['Base Color'])

                        # 透明度
                        alpha_value = data.get("alpha", 1.0)
                        if alpha_value < 1.0:
                            links.new(
                                tex_image.outputs['Alpha'], tex_image.inputs['Alpha'])
                            material.blend_method = 'BLEND'
                    else:
                        # 文件不存在，使用纯色
                        principled.inputs['Base Color'].default_value = (
                            0.5, 0.5, 0.5, 1.0)
                        logger.warning(f"纹理文件不存在: {src_path}")

                except Exception as img_error:
                    logger.error(f"加载图像失败: {img_error}")
                    # 红色表示错误
                    principled.inputs['Base Color'].default_value = (
                        1.0, 0.0, 0.0, 1.0)
            else:
                # 没有图片路径，使用RGB数据
                r = data.get("r", 128) / 255.0
                g = data.get("g", 128) / 255.0
                b = data.get("b", 128) / 255.0
                principled.inputs['Base Color'].default_value = (r, g, b, 1.0)

            # 设置透明度
            alpha_value = data.get("alpha", 1.0)
            principled.inputs['Alpha'].default_value = alpha_value
            if alpha_value < 1.0:
                material.blend_method = 'BLEND'

            # 设置其他属性
            if "reflection" in data:
                metallic_value = data["reflection"]
                principled.inputs['Metallic'].default_value = metallic_value

            if "reflection_glossiness" in data:
                roughness_value = 1.0 - data["reflection_glossiness"]
                principled.inputs['Roughness'].default_value = roughness_value

            # 缓存材质
            self.textures[ckey] = material
            if memory_manager:
                memory_manager.register_object(material)

            # 更新统计
            if hasattr(self, 'material_stats'):
                self.material_stats["materials_created"] += 1

            logger.info(f"✅ 创建纹理材质成功: {ckey}")
            return material

        except Exception as e:
            logger.error(f"❌ MaterialManager.c02 执行失败: {e}")
            self.material_stats["creation_errors"] += 1
            return None

    # ==================== 其他方法继续 ====================

    def textured_surf(self, face, back_material, color, saved_color=None, scale_a=None, angle_a=None):
        """为表面应用纹理 - 保持原始方法名和参数"""
        try:
            if not face or not BLENDER_AVAILABLE:
                return

            # 获取材质
            material = None
            if color:
                material = self.get_texture(color)

            if not material and saved_color:
                material = self.get_texture(saved_color)

            if not material:
                material = self.get_texture("mat_default")

            # 应用材质
            if material:
                self.apply_material_to_face(face, material)

            # 应用纹理变换
            if scale_a or angle_a:
                self.apply_texture_transform(face, material, scale_a, angle_a)

        except Exception as e:
            logger.error(f"应用表面纹理失败: {e}")

    def apply_texture_transform(self, face, material, scale=None, angle=None):
        """应用纹理变换 - 保持原始方法名和参数"""
        try:
            if not face or not material or not BLENDER_AVAILABLE:
                return

            if not hasattr(face, 'data') or not face.data:
                return

            mesh = face.data

            # 确保有UV层
            if not mesh.uv_layers:
                mesh.uv_layers.new(name="UVMap")

            uv_layer = mesh.uv_layers.active

            if uv_layer:
                self.apply_uv_transform(uv_layer, scale, angle)

        except Exception as e:
            logger.error(f"应用纹理变换失败: {e}")

    def apply_uv_transform(self, uv_layer, scale, angle):
        """应用UV变换 - 保持原始方法名和参数"""
        try:
            if not uv_layer:
                return

            import math

            # 应用缩放和旋转
            if scale or angle:
                for loop in uv_layer.data:
                    u, v = loop.uv

                    # 应用缩放
                    if scale:
                        u *= scale
                        v *= scale

                    # 应用旋转
                    if angle:
                        angle_rad = math.radians(angle)
                        cos_a = math.cos(angle_rad)
                        sin_a = math.sin(angle_rad)

                        # 绕中心点旋转
                        u_centered = u - 0.5
                        v_centered = v - 0.5

                        u_new = u_centered * cos_a - v_centered * sin_a + 0.5
                        v_new = u_centered * sin_a + v_centered * cos_a + 0.5

                        u, v = u_new, v_new

                    loop.uv = (u, v)

        except Exception as e:
            logger.error(f"应用UV变换失败: {e}")

    def rotate_texture(self, face, scale, angle):
        """旋转纹理 - 保持原始方法名和参数"""
        try:
            if not face or not BLENDER_AVAILABLE:
                return

            if not hasattr(face, 'data') or not face.data:
                return

            mesh = face.data
            if not mesh.uv_layers:
                return

            uv_layer = mesh.uv_layers.active
            if uv_layer:
                self.apply_uv_transform(uv_layer, scale, angle)

        except Exception as e:
            logger.error(f"旋转纹理失败: {e}")

    def set_mat_type(self, mat_type: int):
        """设置材质类型"""
        self.mat_type = mat_type
        logger.info(f"设置材质类型: {mat_type}")

    def get_mat_type(self) -> int:
        """获取当前材质类型"""
        return self.mat_type

    def clear_material_cache(self):
        """清理材质缓存"""
        try:
            if hasattr(self, 'material_cache'):
                self.material_cache.clear()
            # 保留基础材质，清理其他缓存
            base_materials = ["mat_default", "mat_select",
                              "mat_normal", "mat_obverse", "mat_reverse", "mat_thin"]
            filtered_textures = {
                k: v for k, v in self.textures.items() if k in base_materials}
            self.textures = filtered_textures
            logger.info("材质缓存清理完成")
        except Exception as e:
            logger.error(f"清理材质缓存失败: {e}")

    # ==================== 【新增】c11和c30命令方法 ====================

    def c11(self, data: Dict[str, Any]):
        """part_obverse - 设置零件正面显示 - 按照Ruby逻辑实现"""
        try:
            if not BLENDER_AVAILABLE:
                logger.warning("Blender不可用，跳过零件正面显示设置")
                return 0

            uid = data.get("uid")
            v = data.get("v", False)

            # 【按照Ruby逻辑】设置材质类型
            if v:
                self.mat_type = MAT_TYPE_OBVERSE  # MAT_TYPE_OBVERSE = 1
                logger.info("设置材质类型为正面显示")
            else:
                self.mat_type = MAT_TYPE_NORMAL   # MAT_TYPE_NORMAL = 0
                logger.info("设置材质类型为正常显示")

            # 获取零件数据
            from .data_manager import get_data_manager
            data_manager = get_data_manager()
            parts_data = data_manager.get_parts({"uid": uid})

            processed_count = 0
            for root, part in parts_data.items():
                if part and hasattr(part, 'data'):
                    try:
                        self._textured_part(part, False)
                        processed_count += 1
                    except Exception as e:
                        logger.warning(f"处理零件失败: {root}, {e}")

            logger.info(f"✅ 设置零件正面显示: {processed_count}")
            return processed_count

        except Exception as e:
            logger.error(f"❌ 设置零件正面显示失败: {e}")
            return 0

    def c30(self, data: Dict[str, Any]):
        """part_nature - 设置零件自然显示 - 按照Ruby逻辑实现"""
        try:
            if not BLENDER_AVAILABLE:
                logger.warning("Blender不可用，跳过零件自然显示设置")
                return 0

            uid = data.get("uid")
            v = data.get("v", False)

            # 【按照Ruby逻辑】设置材质类型
            if v:
                self.mat_type = MAT_TYPE_NATURE   # MAT_TYPE_NATURE = 2
                logger.info("设置材质类型为自然显示")
            else:
                self.mat_type = MAT_TYPE_NORMAL   # MAT_TYPE_NORMAL = 0
                logger.info("设置材质类型为正常显示")

            # 获取零件数据
            from .data_manager import get_data_manager
            data_manager = get_data_manager()
            parts_data = data_manager.get_parts({"uid": uid})

            processed_count = 0
            for root, part in parts_data.items():
                if part and hasattr(part, 'data'):
                    try:
                        self._textured_part(part, False)
                        processed_count += 1
                    except Exception as e:
                        logger.warning(f"处理零件失败: {root}, {e}")

            logger.info(f"✅ 设置零件自然显示: {processed_count}")
            return processed_count

        except Exception as e:
            logger.error(f"❌ 设置零件自然显示失败: {e}")
            return 0

    def _textured_part(self, part, selected: bool):
        """为零件应用纹理 - 按照Ruby逻辑实现"""
        try:
            if not part or not hasattr(part, 'data'):
                return

            # 【按照Ruby逻辑】处理零件的每个子对象
            for child in part.children:
                if not child:
                    continue

                # 跳过非模型部件
                child_type = self._get_part_attribute(child, "typ", "")
                if child_type != "cp":
                    continue

                # 跳过加工和拉手
                if child_type in ["work", "pull"]:
                    continue

                # 【按照Ruby逻辑】处理可见性
                if self.mat_type == MAT_TYPE_NATURE:
                    # 自然模式下，模型部件隐藏，虚拟部件显示
                    if hasattr(child, 'type') and child.type == 'MESH':
                        child.hide_viewport = True
                        child.hide_render = True
                    elif self._get_part_attribute(child, "virtual", False):
                        child.hide_viewport = False
                        child.hide_render = False
                else:
                    # 其他模式下，模型部件显示，虚拟部件隐藏
                    if hasattr(child, 'type') and child.type == 'MESH':
                        child.hide_viewport = False
                        child.hide_render = False
                    elif self._get_part_attribute(child, "virtual", False):
                        child.hide_viewport = True
                        child.hide_render = True

                # 【按照Ruby逻辑】为面应用材质
                self._apply_part_materials(child, selected)

        except Exception as e:
            logger.error(f"为零件应用纹理失败: {e}")

    def _apply_part_materials(self, obj, selected: bool):
        """为对象应用材质 - 按照Ruby逻辑实现"""
        try:
            if not obj:
                return

            # 确定材质类型
            material_key = None
            if selected:
                material_key = "mat_select"
            elif self.mat_type == MAT_TYPE_NATURE:
                # 自然模式下根据材质编号选择材质
                mn = self._get_part_attribute(obj, "mn", 0)
                if mn == 1:
                    material_key = "mat_obverse"  # 门板
                elif mn == 2:
                    material_key = "mat_reverse"  # 柜体
                elif mn == 3:
                    material_key = "mat_thin"     # 背板
            else:
                # 正常模式或正面模式，使用原始材质
                material_key = self._get_part_attribute(
                    obj, "ckey", "mat_default")

            # 获取材质
            material = self.get_texture(material_key)
            if not material:
                material = self.get_texture("mat_default")

            # 应用材质到对象
            if hasattr(obj, 'data') and obj.data:
                if not obj.data.materials:
                    obj.data.materials.append(material)
                else:
                    obj.data.materials[0] = material

        except Exception as e:
            logger.error(f"为对象应用材质失败: {e}")

    def _get_part_attribute(self, obj, attr_name: str, default_value=None):
        """获取零件属性 - 支持多种对象类型"""
        try:
            if hasattr(obj, 'get'):
                # 如果是字典或类似对象
                return obj.get(attr_name, default_value)
            elif hasattr(obj, 'sw'):
                # 如果有sw属性
                return obj.sw.get(attr_name, default_value)
            elif isinstance(obj, dict):
                # 如果是字典
                return obj.get(attr_name, default_value)
            else:
                # 尝试从Blender对象的自定义属性获取
                try:
                    if hasattr(obj, attr_name):
                        return getattr(obj, attr_name)
                    elif hasattr(obj, 'sw'):
                        return obj.sw.get(attr_name, default_value)
                    elif hasattr(obj, 'get'):
                        return obj.get(attr_name, default_value)
                except:
                    pass

                return default_value

        except Exception as e:
            logger.debug(f"获取零件属性失败: {e}")
            return default_value

    def get_material_stats(self) -> Dict[str, Any]:
        """获取材质管理器统计信息"""
        try:
            stats = {
                "manager_type": "MaterialManager",
                "cached_textures": len(self.textures),
                "cached_materials": len(getattr(self, 'material_cache', {})),
                "current_mat_type": self.mat_type,
                "back_material": self.back_material,
                "blender_available": BLENDER_AVAILABLE
            }

            if BLENDER_AVAILABLE:
                stats["total_blender_materials"] = len(bpy.data.materials)

            return stats
        except Exception as e:
            logger.error(f"获取材质统计失败: {e}")
            return {"error": str(e)}

    # 【新增】加工材质应用方法
    def apply_machining_material(self, obj):
        """应用加工材质 - 蓝色，表示有效加工"""
        try:
            if not BLENDER_AVAILABLE or not obj:
                return

            material = self.get_texture("mat_machining")
            if not material:
                # 如果材质不存在，创建一个
                material = bpy.data.materials.new(name="mat_machining")
                material.use_nodes = True
                if material.node_tree:
                    principled = material.node_tree.nodes.get(
                        "Principled BSDF")
                    if principled:
                        principled.inputs['Base Color'].default_value = (
                            0.0, 0.5, 1.0, 1.0)  # 蓝色
                self.textures["mat_machining"] = material

            # 应用材质到对象
            if hasattr(obj, 'data') and obj.data:
                if not obj.data.materials:
                    obj.data.materials.append(material)
                else:
                    obj.data.materials[0] = material

        except Exception as e:
            logger.error(f"应用加工材质失败: {e}")

    def apply_cancelled_machining_material(self, obj):
        """应用取消加工材质 - 灰色，表示取消的加工"""
        try:
            if not BLENDER_AVAILABLE or not obj:
                return

            material = self.get_texture("mat_cancelled")
            if not material:
                # 如果材质不存在，创建一个
                material = bpy.data.materials.new(name="mat_cancelled")
                material.use_nodes = True
                if material.node_tree:
                    principled = material.node_tree.nodes.get(
                        "Principled BSDF")
                    if principled:
                        principled.inputs['Base Color'].default_value = (
                            0.5, 0.5, 0.5, 1.0)  # 灰色
                self.textures["mat_cancelled"] = material

            # 应用材质到对象
            if hasattr(obj, 'data') and obj.data:
                if not obj.data.materials:
                    obj.data.materials.append(material)
                else:
                    obj.data.materials[0] = material

        except Exception as e:
            logger.error(f"应用取消加工材质失败: {e}")

# ==================== 模块实例 ====================


# 全局实例，将由SUWImpl初始化时设置
material_manager = None


def init_material_manager():
    """初始化材质管理器 - 不再需要suw_impl参数"""
    global material_manager
    material_manager = MaterialManager()
    return material_manager


def get_material_manager():
    """获取全局材质管理器实例"""
    global material_manager
    if material_manager is None:
        material_manager = init_material_manager()
    return material_manager


# 自动初始化
material_manager = init_material_manager()