using System.Collections.Generic;
using Unity.AI.Navigation;
using UnityEngine;
using UnityEngine.AI;

public class ProceduralMapGenerator : MonoBehaviour
{
    [Header("生成配置")]
    public int seed = 12345;
    public int maxPieces = 20;
    public float gridSize = 2.0f;
    
    [Header("预制体库")]
    public List<GameObject> mapPiecePrefabs = new List<GameObject>();
    public GameObject wallPiecePrefab; // 封口模块
    
    [Header("后处理")]
    public bool enableMeshCombining = true;
    public bool enableNavMesh = true;
    
    [Header("调试")]
    public bool showDebugGizmos = true;
    
    // 内部状态
    private Dictionary<Vector3Int, GameObject> placedPieces = new Dictionary<Vector3Int, GameObject>();
    private List<ConnectionPoint> openConnections = new List<ConnectionPoint>();
    private System.Random random;
    private Transform mapRoot;
    
    void Start()
    {
        GenerateMap();
    }
    
    [ContextMenu("生成地图")]
    public void GenerateMap()
    {
        ClearMap();
        InitializeRandom();
        
        // 创建地图根对象
        mapRoot = new GameObject("GeneratedMap").transform;
        mapRoot.SetParent(transform);
        
        // 选择起始模块
        PlaceStartPiece();
        
        // 主生成循环
        GenerateLoop();
        
        // 后处理
        if (enableMeshCombining)
            CombineMeshes();
            
        if (enableNavMesh)
            BuildNavMesh();
    }
    
    [ContextMenu("清除地图")]
    public void ClearMap()
    {
        if (mapRoot != null)
            DestroyImmediate(mapRoot.gameObject);
            
        placedPieces.Clear();
        openConnections.Clear();
    }
    
    private void InitializeRandom()
    {
        random = new System.Random(seed);
    }
    
    private void PlaceStartPiece()
    {
        // 查找起始模块e
        GameObject startPrefab = null;
        foreach (var prefab in mapPiecePrefabs)
        {
            var piece = prefab.GetComponent<MapPiece>();
            if (piece != null && piece.isStartPiece)
            {
                startPrefab = prefab;
                break;
            }
        }
        
        if (startPrefab == null && mapPiecePrefabs.Count > 0)
        {
            startPrefab = mapPiecePrefabs[0];
        }
        
        if (startPrefab == null)
        {
            Debug.LogError("没有可用的起始模块预制体！");
            return;
        }
        
        // 实例化起始模块
        var startPiece = Instantiate(startPrefab, Vector3.zero, Quaternion.identity, mapRoot);
        var mapPiece = startPiece.GetComponent<MapPiece>();
        
        // 记录位置
        Vector3Int gridPos = WorldToGrid(Vector3.zero);
        placedPieces[gridPos] = startPiece;
        
        // 添加所有连接点到开放列表
        openConnections.AddRange(mapPiece.GetAvailableConnectionPoints());
        
        Debug.Log($"放置起始模块: {mapPiece.pieceName} 在位置 {gridPos}");
    }
    
    private void GenerateLoop()
    {
        int attempts = 0;
        int maxAttempts = maxPieces * 3; // 最大尝试次数
        
        while (openConnections.Count > 0 && placedPieces.Count < maxPieces && attempts < maxAttempts)
        {
            attempts++;
            
            // 从开放列表中取出一个连接点
            var connection = openConnections[0];
            openConnections.RemoveAt(0);
            
            // 尝试放置新模块
            if (TryPlacePieceAtConnection(connection))
            {
                Debug.Log($"成功放置第 {placedPieces.Count} 个模块");
            }
            else
            {
                // 放置失败，放置封口模块
                PlaceWallPiece(connection);
            }
        }
        
        Debug.Log($"生成完成！共放置 {placedPieces.Count} 个模块，尝试次数: {attempts}");
    }
    
    private bool TryPlacePieceAtConnection(ConnectionPoint connection)
    {
        // 获取连接点的世界位置和方向
        Vector3 worldPos = connection.localPosition; // 这里需要修正，应该从父对象获取
        Vector3 worldDir = connection.localDirection;
        
        // 计算新模块的位置
        Vector3 newPiecePos = worldPos + worldDir * gridSize;
        Vector3Int gridPos = WorldToGrid(newPiecePos);
        
        // 检查位置是否已被占用
        if (placedPieces.ContainsKey(gridPos))
            return false;
        
        // 查找合适的预制体
        var candidates = FindCandidatePieces(connection);
        if (candidates.Count == 0)
            return false;
        
        // 随机选择一个候选
        GameObject selectedPrefab = candidates[random.Next(candidates.Count)];
        
        // 计算旋转（使新模块的连接点与当前连接点对齐）
        Quaternion rotation = Quaternion.LookRotation(-worldDir, Vector3.up);
        
        // 实例化新模块
        var newPiece = Instantiate(selectedPrefab, newPiecePos, rotation, mapRoot);
        var newMapPiece = newPiece.GetComponent<MapPiece>();
        
        // 检查碰撞
        if (CheckCollision(newPiece))
        {
            DestroyImmediate(newPiece);
            return false;
        }
        
        // 记录位置
        placedPieces[gridPos] = newPiece;
        
        // 添加新模块的连接点到开放列表（除了与当前连接点匹配的那个）
        var newConnections = newMapPiece.GetAvailableConnectionPoints();
        foreach (var newConn in newConnections)
        {
            // 简单的方向检查，避免添加反向连接
            Vector3 newWorldDir = newPiece.transform.TransformDirection(newConn.localDirection);
            if (Vector3.Dot(newWorldDir, worldDir) < -0.5f) // 大致相反方向
                continue;
                
            openConnections.Add(newConn);
        }
        
        return true;
    }
    
    private List<GameObject> FindCandidatePieces(ConnectionPoint connection)
    {
        var candidates = new List<GameObject>();
        
        foreach (var prefab in mapPiecePrefabs)
        {
            var mapPiece = prefab.GetComponent<MapPiece>();
            if (mapPiece == null) continue;
            
            // 简单的风格匹配（可扩展）
            if (mapPiece.style != connection.style && connection.style != "default")
                continue;
                
            candidates.Add(prefab);
        }
        
        return candidates;
    }
    
    private void PlaceWallPiece(ConnectionPoint connection)
    {
        if (wallPiecePrefab == null) return;
        
        Vector3 worldPos = connection.localPosition;
        Vector3 worldDir = connection.localDirection;
        Vector3 wallPos = worldPos + worldDir * gridSize * 0.5f;
        Vector3Int gridPos = WorldToGrid(wallPos);
        
        if (!placedPieces.ContainsKey(gridPos))
        {
            var wallPiece = Instantiate(wallPiecePrefab, wallPos, Quaternion.LookRotation(-worldDir), mapRoot);
            placedPieces[gridPos] = wallPiece;
        }
    }
    
    private bool CheckCollision(GameObject piece)
    {
        var collider = piece.GetComponent<Collider>();
        if (collider == null) return false;
        
        // 简单的重叠检测
        var bounds = collider.bounds;
        foreach (var placedPiece in placedPieces.Values)
        {
            var placedCollider = placedPiece.GetComponent<Collider>();
            if (placedCollider != null && placedCollider.bounds.Intersects(bounds))
                return true;
        }
        
        return false;
    }
    
    private Vector3Int WorldToGrid(Vector3 worldPos)
    {
        return new Vector3Int(
            Mathf.RoundToInt(worldPos.x / gridSize),
            Mathf.RoundToInt(worldPos.y / gridSize),
            Mathf.RoundToInt(worldPos.z / gridSize)
        );
    }
    
    private void CombineMeshes()
    {
        // 简单的网格合并实现
        var meshFilters = mapRoot.GetComponentsInChildren<MeshFilter>();
        if (meshFilters.Length == 0) return;
        
        // 按材质分组合并
        var combineInstances = new List<CombineInstance>();
        var materials = new List<Material>();
        
        foreach (var meshFilter in meshFilters)
        {
            if (meshFilter.sharedMesh == null) continue;
            
            var renderer = meshFilter.GetComponent<MeshRenderer>();
            if (renderer == null || renderer.sharedMaterial == null) continue;
            
            var combine = new CombineInstance
            {
                mesh = meshFilter.sharedMesh,
                transform = meshFilter.transform.localToWorldMatrix
            };
            
            combineInstances.Add(combine);
            
            // 禁用原始渲染器
            renderer.enabled = false;
        }
        
        if (combineInstances.Count > 0)
        {
            // 创建合并的网格对象
            var combinedObject = new GameObject("CombinedMesh");
            combinedObject.transform.SetParent(mapRoot);
            
            var combinedFilter = combinedObject.AddComponent<MeshFilter>();
            var combinedRenderer = combinedObject.AddComponent<MeshRenderer>();
            
            // 合并网格
            var combinedMesh = new Mesh();
            combinedMesh.CombineMeshes(combineInstances.ToArray());
            combinedFilter.sharedMesh = combinedMesh;
            
            // 设置材质（使用第一个材质）
            if (materials.Count > 0)
                combinedRenderer.sharedMaterial = materials[0];
            
            Debug.Log($"网格合并完成，合并了 {combineInstances.Count} 个网格");
        }
    }
    
    private void BuildNavMesh()
    {
        var navMeshSurface = mapRoot.gameObject.GetComponent<NavMeshSurface>();
        if (navMeshSurface == null)
            navMeshSurface = mapRoot.gameObject.AddComponent<NavMeshSurface>();
        
        navMeshSurface.BuildNavMesh();
        Debug.Log("NavMesh 生成完成");
    }
    
    private void OnDrawGizmos()
    {
        if (!showDebugGizmos) return;
        
        // 绘制已放置模块的网格位置
        Gizmos.color = Color.blue;
        foreach (var kvp in placedPieces)
        {
            Vector3 worldPos = GridToWorld(kvp.Key);
            Gizmos.DrawWireCube(worldPos, Vector3.one * gridSize * 0.8f);
        }
        
        // 绘制开放连接点
        Gizmos.color = Color.red;
        foreach (var connection in openConnections)
        {
            Vector3 worldPos = connection.localPosition;
            Gizmos.DrawSphere(worldPos, 0.2f);
        }
    }
    
    private Vector3 GridToWorld(Vector3Int gridPos)
    {
        return new Vector3(gridPos.x * gridSize, gridPos.y * gridSize, gridPos.z * gridSize);
    }
}