import { AbstractMesh } from '@babylonjs/core/Meshes/abstractMesh';
import { PointerDragBehavior } from '@babylonjs/core/Behaviors/Meshes/pointerDragBehavior';
import { Vector3 } from '@babylonjs/core/Maths/math.vector';
import { Scene } from '@babylonjs/core/scene';
import { Monobehiver } from '../base/Monobehiver';

/**
 * 拖拽配置接口
 */
export interface DragConfig {
    enable: boolean;
    axis?: 'x' | 'y' | 'z' | 'xy' | 'xz' | 'yz' | 'xyz';
    step?: number;
    snapToZone?: boolean;           // 拖拽吸附：松开时自动吸附到最近的分割区域
    returnWhenOutOfBounds?: boolean; // 拖拽到区域外时返回原位置
    handleOccupiedZone?: boolean;   // 拖拽到已占用区域时的处理：true=返回原位置或替换，false=允许重叠
    occupiedZoneAction?: 'return' | 'replace';  // 当 handleOccupiedZone=true 时的具体行为：'return' 返回原位置，'replace' 替换目标位置的模型
}

/**
 * 模型拖拽信息
 */
interface ModelDragInfo {
    config: DragConfig;
    behavior: PointerDragBehavior | null;
    currentAxis: 'x' | 'y' | 'z' | null;
}

/**
 * 模型拖拽管理器 - 负责处理模型的拖拽交互
 */
export class AppModelDrag extends Monobehiver {
    private modelDragMap: Map<string, ModelDragInfo>;
    private scene: Scene | null;

    constructor(mainApp: any) {
        super(mainApp);
        this.modelDragMap = new Map();
        this.scene = null;
    }

    /**
     * 初始化拖拽管理器
     */
    Awake(): void {
        this.scene = this.mainApp.appScene.object;
        if (!this.scene) {
            console.warn('Scene not initialized');
            return;
        }
    }

    /**
     * 为模型配置拖拽
     * @param modelId 模型ID
     * @param config 拖拽配置
     */
    configureDrag(modelId: string, config: DragConfig): void {
        // 获取模型的根网格
        const meshes = this.mainApp.appModel?.modelDic?.Get(modelId);
        if (!meshes || !meshes.length) {
            console.warn(`Model not found: ${modelId}`);
            return;
        }

        const rootMesh = meshes[0]; // 第一个是根节点

        // 如果已存在，先移除旧的行为
        const existingInfo = this.modelDragMap.get(modelId);
        if (existingInfo?.behavior) {
            rootMesh.removeBehavior(existingInfo.behavior);
        }

        // 创建拖拽信息
        const dragInfo: ModelDragInfo = {
            config: { ...config },
            behavior: null,
            currentAxis: this.getFirstAvailableAxis(config.axis || 'xyz')
        };

        if (config.enable) {
            // 创建并配置拖拽行为
            dragInfo.behavior = this.createDragBehavior(modelId, dragInfo);
            rootMesh.addBehavior(dragInfo.behavior);
        }

        this.modelDragMap.set(modelId, dragInfo);
    }

    /**
     * 创建拖拽行为
     */
    private createDragBehavior(modelId: string, dragInfo: ModelDragInfo): PointerDragBehavior {
        const axis = dragInfo.currentAxis;
        let dragAxis: Vector3;

        // 根据当前激活的轴创建拖拽向量
        switch (axis) {
            case 'x':
                dragAxis = new Vector3(1, 0, 0);
                break;
            case 'y':
                dragAxis = new Vector3(0, 1, 0);
                break;
            case 'z':
                dragAxis = new Vector3(0, 0, 1);
                break;
            default:
                dragAxis = new Vector3(1, 0, 0);
        }

        // 创建拖拽行为
        const pointerDragBehavior = new PointerDragBehavior({ dragAxis: dragAxis });

        // 使用世界坐标系而不是物体本地坐标系
        pointerDragBehavior.useObjectOrientationForDragging = false;

        // 记录拖拽起始位置和状态
        let dragStartPosition: Vector3 | null = null;
        let hasShownZones = false; // 是否已显示分割区域

        // 监听拖拽开始事件
        pointerDragBehavior.onDragStartObservable.add(() => {
            // 记录起始位置
            const meshes = this.mainApp.appModel?.modelDic?.Get(modelId);
            if (meshes && meshes.length > 0) {
                dragStartPosition = meshes[0].position.clone();
            }

            // 禁用相机控制
            this.disableCameraControl();

            // 不在这里显示分割区域，等到实际拖动时再显示
            hasShownZones = false;
        });

        // 监听拖拽中事件（用于延迟显示分割区域）
        pointerDragBehavior.onDragObservable.add((event) => {
            // 检查是否实际移动了
            const meshes = this.mainApp.appModel?.modelDic?.Get(modelId);
            if (meshes && meshes.length > 0 && dragStartPosition) {
                const distance = Vector3.Distance(dragStartPosition, meshes[0].position);

                // 如果移动距离超过阈值且还没显示分割区域，则显示
                if (distance > 0.01 && !hasShownZones && dragInfo.config.snapToZone) {
                    this.showZonesForModel(modelId);
                    hasShownZones = true;
                }
            }
        });

        // 监听拖拽结束事件
        pointerDragBehavior.onDragEndObservable.add(() => {
            // 检查是否实际移动了
            const meshes = this.mainApp.appModel?.modelDic?.Get(modelId);
            let hasMoved = false;
            if (meshes && meshes.length > 0 && dragStartPosition) {
                const distance = Vector3.Distance(dragStartPosition, meshes[0].position);
                hasMoved = distance > 0.01; // 移动距离大于 0.01 才算拖拽
            }

            // 恢复相机控制
            this.enableCameraControl();

            // 只有在实际移动的情况下才执行拖拽逻辑
            if (hasMoved) {
                // 如果启用了拖拽吸附，隐藏分割区域并吸附到最近区域
                if (dragInfo.config.snapToZone && hasShownZones) {
                    this.hideZonesForModel(modelId);
                    this.snapModelToZone(modelId);
                } else {
                    // 否则只更新映射关系
                    this.updateModelZoneMapping(modelId);
                }
            }

            // 清除状态
            dragStartPosition = null;
            hasShownZones = false;
        });

        return pointerDragBehavior;
    }

    /**
     * 获取模型的拖拽配置
     * @param modelId 模型ID
     */
    getDragConfig(modelId: string): DragConfig | undefined {
        return this.modelDragMap.get(modelId)?.config;
    }

    /**
     * 启用/禁用模型拖拽
     * @param modelId 模型ID
     * @param enable 是否启用
     */
    setDragEnabled(modelId: string, enable: boolean): void {
        const dragInfo = this.modelDragMap.get(modelId);
        if (!dragInfo) return;

        dragInfo.config.enable = enable;

        const meshes = this.mainApp.appModel?.modelDic?.Get(modelId);
        if (!meshes || !meshes.length) return;

        const rootMesh = meshes[0];

        if (enable) {
            // 启用：创建并添加行为
            if (!dragInfo.behavior) {
                dragInfo.behavior = this.createDragBehavior(modelId, dragInfo);
                rootMesh.addBehavior(dragInfo.behavior);
            }
        } else {
            // 禁用：移除行为
            if (dragInfo.behavior) {
                rootMesh.removeBehavior(dragInfo.behavior);
                dragInfo.behavior = null;
            }
        }
    }

    /**
     * 切换激活的轴向
     * @param modelId 模型ID
     * @param axis 要激活的轴向
     */
    switchAxis(modelId: string, axis: 'x' | 'y' | 'z'): void {
        const dragInfo = this.modelDragMap.get(modelId);
        if (!dragInfo) return;

        // 检查该轴是否在允许的轴向中
        if (!this.isAxisAllowed(axis, dragInfo.config.axis || 'xyz')) {
            console.warn(`Axis ${axis} is not allowed for model ${modelId}`);
            return;
        }

        // 更新当前轴
        dragInfo.currentAxis = axis;

        // 重新创建拖拽行为
        const meshes = this.mainApp.appModel?.modelDic?.Get(modelId);
        if (!meshes || !meshes.length) return;

        const rootMesh = meshes[0];

        // 移除旧行为
        if (dragInfo.behavior) {
            rootMesh.removeBehavior(dragInfo.behavior);
        }

        // 创建新行为
        if (dragInfo.config.enable) {
            dragInfo.behavior = this.createDragBehavior(modelId, dragInfo);
            rootMesh.addBehavior(dragInfo.behavior);
        }
    }

    /**
     * 获取配置中的第一个可用轴
     */
    private getFirstAvailableAxis(axisConfig: string): 'x' | 'y' | 'z' | null {
        if (axisConfig.includes('x')) return 'x';
        if (axisConfig.includes('y')) return 'y';
        if (axisConfig.includes('z')) return 'z';
        return null;
    }

    /**
     * 检查轴是否在允许的配置中
     */
    private isAxisAllowed(axis: 'x' | 'y' | 'z', axisConfig: string): boolean {
        return axisConfig.includes(axis);
    }

    /**
     * 禁用相机控制
     */
    private disableCameraControl(): void {
        const camera = this.mainApp.appCamera?.object;
        if (camera) {
            camera.detachControl();
        }
    }

    /**
     * 启用相机控制
     */
    private enableCameraControl(): void {
        const camera = this.mainApp.appCamera?.object;
        const canvas = this.mainApp.appEngin?.object?.getRenderingCanvas();
        if (camera && canvas) {
            camera.attachControl(canvas, true);
        }
    }

    /**
     * 显示模型所在墙面的分割区域
     * @param modelId 模型ID
     */
    private showZonesForModel(modelId: string): void {
        const appDropZone = this.mainApp.appDropZone;
        if (!appDropZone) return;

        // 查找模型所在的墙面
        let wallName: string | null = null;
        appDropZone['zoneModelMap']?.forEach((id: string, zoneKey: string) => {
            if (id === modelId) {
                const match = zoneKey.match(/^(.+)\[(\d+)\]$/);
                if (match) {
                    wallName = match[1];
                }
            }
        });

        if (wallName) {
            console.log(`[拖拽吸附] 显示墙面 ${wallName} 的分割区域`);
            // 只显示该墙面的分割区域
            appDropZone.showWall(wallName);
        }
    }

    /**
     * 隐藏分割区域
     * @param modelId 模型ID
     */
    private hideZonesForModel(modelId: string): void {
        const appDropZone = this.mainApp.appDropZone;
        if (!appDropZone) return;

        console.log(`[拖拽吸附] 隐藏分割区域`);
        appDropZone.hide();
    }

    /**
     * 将模型吸附到最近的分割区域
     * @param modelId 模型ID
     */
    private snapModelToZone(modelId: string): void {
        const meshes = this.mainApp.appModel?.modelDic?.Get(modelId);
        if (!meshes || !meshes.length) return;

        const rootMesh = meshes[0];
        const appDropZone = this.mainApp.appDropZone;
        if (!appDropZone) return;

        // 查找模型原来所在的墙面和区域索引
        let wallName: string | null = null;
        let originalZoneIndex: number = -1;
        appDropZone['zoneModelMap']?.forEach((id: string, zoneKey: string) => {
            if (id === modelId) {
                const match = zoneKey.match(/^(.+)\[(\d+)\]$/);
                if (match) {
                    wallName = match[1];
                    originalZoneIndex = parseInt(match[2]);
                }
            }
        });

        if (!wallName) return;

        // 获取该墙面的所有分割区域
        const wallZones = appDropZone.getZonesByWall(wallName);
        if (!wallZones.length) return;

        // 找到最近的区域
        let closestZoneIndex = -1;
        let minDistance = Number.POSITIVE_INFINITY;

        wallZones.forEach((zone, index) => {
            const distance = rootMesh.position.subtract(zone.center).length();
            if (distance < minDistance) {
                minDistance = distance;
                closestZoneIndex = index;
            }
        });

        if (closestZoneIndex === -1) return;

        // 获取拖拽配置
        const dragInfo = this.modelDragMap.get(modelId);
        const returnWhenOutOfBounds = dragInfo?.config.returnWhenOutOfBounds ?? false;
        const handleOccupiedZone = dragInfo?.config.handleOccupiedZone ?? false;
        const occupiedZoneAction = dragInfo?.config.occupiedZoneAction ?? 'return';

        // 检查是否拖拽到区域外
        let isOutOfBounds = false;

        // 计算墙面的边界
        let minX = Number.POSITIVE_INFINITY;
        let maxX = Number.NEGATIVE_INFINITY;
        let minZ = Number.POSITIVE_INFINITY;
        let maxZ = Number.NEGATIVE_INFINITY;

        wallZones.forEach(zone => {
            const halfWidth = zone.width / 2;

            // 根据法线方向计算边界
            if (Math.abs(zone.normal.x) > 0.5) {
                // 左右墙面（法线沿X轴）
                minZ = Math.min(minZ, zone.center.z - halfWidth);
                maxZ = Math.max(maxZ, zone.center.z + halfWidth);
            } else if (Math.abs(zone.normal.z) > 0.5) {
                // 前后墙面（法线沿Z轴）
                minX = Math.min(minX, zone.center.x - halfWidth);
                maxX = Math.max(maxX, zone.center.x + halfWidth);
            }
        });

        // 检查当前位置是否在边界内
        const currentPos = rootMesh.position;

        if (minX !== Number.POSITIVE_INFINITY && maxX !== Number.NEGATIVE_INFINITY) {
            if (currentPos.x < minX || currentPos.x > maxX) {
                isOutOfBounds = true;
            }
        }
        if (minZ !== Number.POSITIVE_INFINITY && maxZ !== Number.NEGATIVE_INFINITY) {
            if (currentPos.z < minZ || currentPos.z > maxZ) {
                isOutOfBounds = true;
            }
        }

        // 处理超出边界的情况（开关2：returnWhenOutOfBounds）
        if (isOutOfBounds) {
            console.log(`[拖拽吸附] 模型 ${modelId} 超出边界`);

            if (returnWhenOutOfBounds) {
                // 启用了边界返回，回到原来的区域
                console.log(`[拖拽吸附] 启用边界返回，回到原区域 ${originalZoneIndex}`);
                if (originalZoneIndex !== -1) {
                    const originalZone = wallZones[originalZoneIndex];
                    if (originalZone) {
                        const offsetDistance = 0;
                        const returnPosition = originalZone.center.add(originalZone.normal.scale(offsetDistance));
                        rootMesh.position.copyFrom(returnPosition);

                        const targetDirection = originalZone.normal.scale(-1);
                        const angle = Math.atan2(targetDirection.x, targetDirection.z);
                        rootMesh.rotation.y = angle;

                        console.log(`[拖拽吸附] 模型 ${modelId} 已返回原区域 ${originalZoneIndex}`);
                        return; // 不更新映射，保持原映射
                    }
                }
            } else {
                // 未启用边界返回，保持当前位置，不做吸附
                console.log(`[拖拽吸附] 未启用边界返回，保持当前位置，不做吸附`);
                // 更新映射关系（可能移出了原区域）
                this.updateModelZoneMapping(modelId);
                return;
            }
        }

        const targetZone = wallZones[closestZoneIndex];

        // 检查目标区域是否已被其他模型占用（开关2：handleOccupiedZone）
        const targetZoneKey = `${wallName}[${closestZoneIndex}]`;
        const occupyingModelId = appDropZone['zoneModelMap']?.get(targetZoneKey);

        if (occupyingModelId && occupyingModelId !== modelId) {
            // 目标区域已被其他模型占用
            console.log(`[拖拽吸附] 目标区域 ${closestZoneIndex} 已被模型 ${occupyingModelId} 占用`);

            if (handleOccupiedZone) {
                // 启用了占用区域处理
                if (occupiedZoneAction === 'return') {
                    // 返回原位置
                    console.log(`[拖拽吸附] 配置为返回原位置，回到区域 ${originalZoneIndex}`);
                    if (originalZoneIndex !== -1) {
                        const originalZone = wallZones[originalZoneIndex];
                        if (originalZone) {
                            const offsetDistance = 0;
                            const returnPosition = originalZone.center.add(originalZone.normal.scale(offsetDistance));
                            rootMesh.position.copyFrom(returnPosition);

                            const targetDirection = originalZone.normal.scale(-1);
                            const angle = Math.atan2(targetDirection.x, targetDirection.z);
                            rootMesh.rotation.y = angle;

                            console.log(`[拖拽吸附] 模型 ${modelId} 返回原区域 ${originalZoneIndex}`);
                            return; // 不更新映射，保持原映射
                        }
                    }
                } else if (occupiedZoneAction === 'replace') {
                    // 替换目标位置的模型（继续执行后面的逻辑）
                    console.log(`[拖拽吸附] 配置为替换模型，将替换模型 ${occupyingModelId}`);
                }
            } else {
                // 未启用占用区域处理，允许重叠（继续执行后面的逻辑）
                console.log(`[拖拽吸附] 未启用占用区域处理，允许重叠`);
            }
        }

        // 计算吸附位置（区域中心 + 法线偏移）
        const offsetDistance = 0;
        const snapPosition = targetZone.center.add(targetZone.normal.scale(offsetDistance));

        // 吸附到目标位置
        rootMesh.position.copyFrom(snapPosition);

        // 更新旋转
        const targetDirection = targetZone.normal.scale(-1);
        const angle = Math.atan2(targetDirection.x, targetDirection.z);
        rootMesh.rotation.y = angle;

        console.log(`[拖拽吸附] 模型 ${modelId} 吸附到区域 ${closestZoneIndex}`);

        // 更新映射关系
        this.updateModelZoneMapping(modelId);
    }

    /**
     * 更新模型所属的分割区域映射
     * @param modelId 模型ID
     */
    private updateModelZoneMapping(modelId: string): void {
        const meshes = this.mainApp.appModel?.modelDic?.Get(modelId);
        if (!meshes || !meshes.length) return;

        const rootMesh = meshes[0];
        const modelPosition = rootMesh.position;

        console.log(`[边界检测] 模型 ${modelId} 拖拽结束，当前位置:`, modelPosition);

        // 获取 AppDropZone
        const appDropZone = this.mainApp.appDropZone;
        if (!appDropZone) return;

        // 查找该模型原本所在的墙面
        let originalWallName: string | null = null;
        appDropZone['zoneModelMap']?.forEach((id: string, zoneKey: string) => {
            if (id === modelId) {
                const match = zoneKey.match(/^(.+)\[(\d+)\]$/);
                if (match) {
                    originalWallName = match[1];
                }
            }
        });

        if (!originalWallName) {
            console.log(`[边界检测] 模型 ${modelId} 未找到原始墙面，跳过检测`);
            return;
        }

        console.log(`[边界检测] 模型 ${modelId} 原始墙面: ${originalWallName}`);

        // 获取该墙面的所有分割区域
        const wallZones = appDropZone.getZonesByWall(originalWallName);
        if (!wallZones.length) return;

        console.log(`[边界检测] 墙面 ${originalWallName} 有 ${wallZones.length} 个分割区域`);

        // 计算模型与每个分割区域的距离，找到最近的区域
        let closestZoneIndex = -1;
        let minDistance = Number.POSITIVE_INFINITY;

        wallZones.forEach((zone, index) => {
            // 计算模型位置到区域中心的距离
            const distance = modelPosition.subtract(zone.center).length();
            console.log(`[边界检测] 区域 ${index} 中心:`, zone.center, `距离: ${distance.toFixed(3)}`);

            if (distance < minDistance) {
                minDistance = distance;
                closestZoneIndex = index;
            }
        });

        if (closestZoneIndex === -1) {
            console.log(`[边界检测] 未找到最近的区域`);
            return;
        }

        console.log(`[边界检测] 模型 ${modelId} 最接近区域 ${closestZoneIndex}，距离: ${minDistance.toFixed(3)}`);

        // 查找模型当前所在的区域索引
        let currentZoneIndex = -1;
        appDropZone['zoneModelMap']?.forEach((id: string, zoneKey: string) => {
            if (id === modelId) {
                const match = zoneKey.match(/^.+\[(\d+)\]$/);
                if (match) {
                    currentZoneIndex = parseInt(match[1]);
                }
            }
        });

        // 如果模型移动到了新的区域，更新映射
        if (currentZoneIndex !== closestZoneIndex) {
            console.log(`[边界检测] 模型 ${modelId} 从区域 ${currentZoneIndex} 移动到区域 ${closestZoneIndex}`);

            // 删除旧映射
            if (currentZoneIndex !== -1) {
                const oldKey = `${originalWallName}[${currentZoneIndex}]`;
                appDropZone['zoneModelMap']?.delete(oldKey);
                console.log(`[边界检测] 删除旧映射: ${oldKey}`);
            }

            // 检查目标区域是否已有模型
            const newKey = `${originalWallName}[${closestZoneIndex}]`;
            const existingModelId = appDropZone['zoneModelMap']?.get(newKey);

            // 获取拖拽配置
            const dragInfo = this.modelDragMap.get(modelId);
            const handleOccupiedZone = dragInfo?.config.handleOccupiedZone ?? false;
            const occupiedZoneAction = dragInfo?.config.occupiedZoneAction ?? 'return';

            if (existingModelId && existingModelId !== modelId) {
                console.log(`[边界检测] 目标区域 ${closestZoneIndex} 已有模型 ${existingModelId}`);

                // 只有在启用占用区域处理且为 'replace' 模式下才交换位置
                if (handleOccupiedZone && occupiedZoneAction === 'replace') {
                    console.log(`[边界检测] 配置为替换模式，交换位置`);

                    // 将原有模型移动到旧位置
                    if (currentZoneIndex !== -1) {
                        const swapKey = `${originalWallName}[${currentZoneIndex}]`;
                        appDropZone['zoneModelMap']?.set(swapKey, existingModelId);
                        console.log(`[边界检测] 模型 ${existingModelId} 移动到区域 ${currentZoneIndex}`);

                        // 实际移动被替换模型的物理位置
                        const existingMeshes = this.mainApp.appModel?.modelDic?.Get(existingModelId);
                        if (existingMeshes && existingMeshes.length) {
                            const existingRootMesh = existingMeshes[0];
                            const swapZone = wallZones[currentZoneIndex];
                            if (swapZone) {
                                const offsetDistance = 0;
                                const swapPosition = swapZone.center.add(swapZone.normal.scale(offsetDistance));
                                existingRootMesh.position.copyFrom(swapPosition);

                                // 更新旋转
                                const targetDirection = swapZone.normal.scale(-1);
                                const angle = Math.atan2(targetDirection.x, targetDirection.z);
                                existingRootMesh.rotation.y = angle;

                                console.log(`[边界检测] 已将模型 ${existingModelId} 物理移动到区域 ${currentZoneIndex}`);
                            }
                        }
                    }
                } else {
                    console.log(`[边界检测] 未启用替换模式或未启用占用区域处理，允许重叠`);
                }
            }

            // 添加新映射
            appDropZone['zoneModelMap']?.set(newKey, modelId);
            console.log(`[边界检测] 添加新映射: ${newKey} -> ${modelId}`);
        } else {
            console.log(`[边界检测] 模型 ${modelId} 仍在区域 ${currentZoneIndex}，无需更新映射`);
        }
    }

    /**
     * 清理资源
     */
    dispose(): void {
        // 移除所有拖拽行为
        this.modelDragMap.forEach((dragInfo, modelId) => {
            if (dragInfo.behavior) {
                const meshes = this.mainApp.appModel?.modelDic?.Get(modelId);
                if (meshes && meshes.length) {
                    meshes[0].removeBehavior(dragInfo.behavior);
                }
            }
        });
        this.modelDragMap.clear();
    }
}