using UnityEngine;
using UnityEditor;

[CustomEditor(typeof(TerrainCreator))]
public class TerrainCreatorEditor : Editor
{
    int generatedTreeCount = 0;

    public override void OnInspectorGUI()
    {
        serializedObject.Update();
        bool isChanged = DrawDefaultInspector();

        TerrainCreator creator = (TerrainCreator)target;

        if (isChanged && creator.autoUpdate)
        {
            bool hasTerrain = creator.transform.Find("TerrainMesh") != null;
            bool hasForest = false;
            for (int i = 0; i < creator.transform.childCount; i++)
            {
                if (creator.transform.GetChild(i).name.StartsWith("Tree_"))
                {
                    hasForest = true;
                    break;
                }
            }

            if (hasTerrain)
            {
                ClearTerrain(creator);
                GenerateTerrainMesh(creator);
            }
            if (hasForest && creator.preset != null && creator.branchPrefab != null)
            {
                ClearForest(creator);
                GenerateForest(creator);
            }
        }

        EditorGUILayout.Space(10);
        EditorGUILayout.LabelField("Terrain & Forest Generation", EditorStyles.boldLabel);

        int count = ComputeTreeCount(creator);
        EditorGUILayout.HelpBox($"Will place {count} trees on terrain", MessageType.None);

        if (creator.preset == null || creator.branchPrefab == null)
        {
            EditorGUILayout.HelpBox("TreeRandomPreset과 Branch 프리팹을 할당해야 숲을 생성할 수 있습니다.", MessageType.Warning);
        }

        if (GUILayout.Button("Generate Terrain", GUILayout.Height(30)))
        {
            ClearTerrain(creator);
            GenerateTerrainMesh(creator);
        }

        EditorGUI.BeginDisabledGroup(creator.preset == null || creator.branchPrefab == null);
        EditorGUILayout.BeginHorizontal();
        if (GUILayout.Button("Generate Forest", GUILayout.Height(30)))
        {
            ClearForest(creator);
            GenerateForest(creator);
        }
        if (GUILayout.Button("Clear All", GUILayout.Height(30)))
        {
            ClearForest(creator);
            ClearTerrain(creator);
        }
        EditorGUILayout.EndHorizontal();
        EditorGUI.EndDisabledGroup();

        if (generatedTreeCount > 0)
        {
            EditorGUILayout.HelpBox($"{generatedTreeCount} trees generated", MessageType.Info);
        }

        serializedObject.ApplyModifiedProperties();
    }

    int ComputeTreeCount(TerrainCreator c)
    {
        if (c.mode == TerrainCreator.DensityMode.Count)
            return Mathf.Max(1, c.treeCount);
        
        float area = (c.width * c.cellSize) * (c.height * c.cellSize);
        return Mathf.Max(1, Mathf.RoundToInt(area * c.treesPerUnit));
    }

    void ClearTerrain(TerrainCreator creator)
    {
        Undo.SetCurrentGroupName("Clear Terrain");
        int undoGroup = Undo.GetCurrentGroup();

        Transform terrainTransform = creator.transform.Find("TerrainMesh");
        if (terrainTransform != null)
        {
            Undo.DestroyObjectImmediate(terrainTransform.gameObject);
        }

        Undo.CollapseUndoOperations(undoGroup);
    }

    void ClearForest(TerrainCreator creator)
    {
        Undo.SetCurrentGroupName("Clear Forest");
        int undoGroup = Undo.GetCurrentGroup();

        for (int i = creator.transform.childCount - 1; i >= 0; i--)
        {
            Transform child = creator.transform.GetChild(i);
            if (child.name.StartsWith("Tree_"))
            {
                Undo.DestroyObjectImmediate(child.gameObject);
            }
        }

        Undo.CollapseUndoOperations(undoGroup);
        generatedTreeCount = 0;
    }

    void GenerateTerrainMesh(TerrainCreator creator)
    {
        int width = creator.width;
        int height = creator.height;

        Vector3[] vertices = new Vector3[width * height];
        Vector2[] uvs = new Vector2[width * height];
        int[] triangles = new int[(width - 1) * (height - 1) * 6];

        float offsetX = (width - 1) * creator.cellSize * 0.5f;
        float offsetZ = (height - 1) * creator.cellSize * 0.5f;

        // Use seed to offset Perlin noise so we get different terrain per seed
        System.Random prng = new System.Random(creator.seed);
        float seedOffsetX = prng.Next(-100000, 100000);
        float seedOffsetZ = prng.Next(-100000, 100000);

        for (int z = 0; z < height; z++)
        {
            for (int x = 0; x < width; x++)
            {
                float xCoord = (x + seedOffsetX) * creator.noiseScale;
                float zCoord = (z + seedOffsetZ) * creator.noiseScale;
                float y = Mathf.PerlinNoise(xCoord, zCoord) * creator.heightScale;

                vertices[z * width + x] = new Vector3(x * creator.cellSize - offsetX, y, z * creator.cellSize - offsetZ);
                uvs[z * width + x] = new Vector2((float)x / (width - 1), (float)z / (height - 1));
            }
        }

        int ti = 0;
        for (int z = 0; z < height - 1; z++)
        {
            for (int x = 0; x < width - 1; x++)
            {
                int i = z * width + x;
                triangles[ti++] = i;
                triangles[ti++] = i + width;
                triangles[ti++] = i + 1;
                
                triangles[ti++] = i + 1;
                triangles[ti++] = i + width;
                triangles[ti++] = i + width + 1;
            }
        }

        Mesh mesh = new Mesh();
        mesh.name = "ProceduralTerrain";
        if (vertices.Length > 65535) mesh.indexFormat = UnityEngine.Rendering.IndexFormat.UInt32;
        
        mesh.vertices = vertices;
        mesh.uv = uvs;
        mesh.triangles = triangles;
        mesh.RecalculateNormals();

        GameObject terrainObj = new GameObject("TerrainMesh");
        Undo.RegisterCreatedObjectUndo(terrainObj, "Create Terrain");
        terrainObj.transform.SetParent(creator.transform, false);
        terrainObj.transform.localPosition = Vector3.zero;
        terrainObj.transform.localRotation = Quaternion.identity;

        MeshFilter mf = terrainObj.AddComponent<MeshFilter>();
        mf.sharedMesh = mesh;

        MeshRenderer mr = terrainObj.AddComponent<MeshRenderer>();
        if (creator.terrainMaterial != null)
        {
            mr.sharedMaterial = creator.terrainMaterial;
        }
        else
        {
            mr.sharedMaterial = AssetDatabase.GetBuiltinExtraResource<Material>("Default-Material.mat");
        }
    }

    void GenerateForest(TerrainCreator creator)
    {
        generatedTreeCount = 0;
        if (creator.preset == null) return;

        Random.State prevState = Random.state;

        Undo.SetCurrentGroupName("Generate Forest");
        int undoGroup = Undo.GetCurrentGroup();

        int count = ComputeTreeCount(creator);

        Random.InitState(creator.seed);
        System.Random prng = new System.Random(creator.seed);
        float seedOffsetX = prng.Next(-100000, 100000);
        float seedOffsetZ = prng.Next(-100000, 100000);

        Vector3[] positions = new Vector3[count];
        Quaternion[] yaws = new Quaternion[count];

        float width = creator.width;
        float height = creator.height;
        float offsetX = (width - 1) * creator.cellSize * 0.5f;
        float offsetZ = (height - 1) * creator.cellSize * 0.5f;

        for (int i = 0; i < count; i++)
        {
            float randX = Random.Range(0f, width - 1);
            float randZ = Random.Range(0f, height - 1);

            float wX = randX * creator.cellSize - offsetX;
            float wZ = randZ * creator.cellSize - offsetZ;

            float xCoord = (randX + seedOffsetX) * creator.noiseScale;
            float zCoord = (randZ + seedOffsetZ) * creator.noiseScale;
            float y = Mathf.PerlinNoise(xCoord, zCoord) * creator.heightScale;

            positions[i] = new Vector3(wX, y, wZ);
            yaws[i] = Quaternion.Euler(0f, Random.Range(0f, 360f), 0f);
        }

        for (int i = 0; i < count; i++)
        {
            Random.InitState(creator.seed + i * 7919);

            GameObject treeRoot = new GameObject($"Tree_{i:D3}");
            Undo.RegisterCreatedObjectUndo(treeRoot, "Create Tree");
            treeRoot.transform.SetParent(creator.transform, false);
            treeRoot.transform.localPosition = positions[i];
            treeRoot.transform.localRotation = yaws[i];

            CreateBranchRecursive(creator, treeRoot.transform, Vector3.zero, Quaternion.identity, 0, 5f, true);

            generatedTreeCount++;
        }

        Undo.CollapseUndoOperations(undoGroup);
        Random.state = prevState;
    }

    void CreateBranchRecursive(TerrainCreator creator, Transform parent, Vector3 localStartPos, Quaternion rot, int depth, float length, bool isRoot = false)
    {
        TreeRandomPreset p = creator.preset;
        if (depth >= p.maxDepth) return;

        float currentLength = isRoot ? 2f : length * p.scaleFactor * Random.Range(1f - p.scaleRandom, 1f + p.scaleRandom);
        
        GameObject pivot = new GameObject($"Pivot_D{depth}");
        pivot.transform.SetParent(parent, false);
        pivot.transform.localPosition = localStartPos;
        pivot.transform.localRotation = rot;

        Vector3 centerPos = localStartPos + pivot.transform.localRotation * Vector3.up * currentLength * 0.5f;
        
        GameObject branchObj;
        if (creator.branchPrefab != null) {
            branchObj = (GameObject)PrefabUtility.InstantiatePrefab(creator.branchPrefab);
        } else {
            branchObj = GameObject.CreatePrimitive(PrimitiveType.Cylinder);
            DestroyImmediate(branchObj.GetComponent<Collider>());
        }
        
        branchObj.transform.SetParent(pivot.transform, false);
        branchObj.transform.localPosition = Vector3.up * currentLength * 0.5f;
        branchObj.transform.localRotation = Quaternion.identity;

        float thickness = 0.2f * (p.maxDepth - depth) / p.maxDepth;
        branchObj.transform.localScale = new Vector3(thickness, currentLength * 0.5f, thickness);

        Renderer rnd = branchObj.GetComponentInChildren<Renderer>();
        if (rnd != null)
        {
            float t = (float)depth / Mathf.Max(1, p.maxDepth - 1);
            Color baseColor = Color.Lerp(p.trunkColor, p.midColor, t * 2f);
            if (t > 0.5f) baseColor = Color.Lerp(p.midColor, p.tipColor, (t - 0.5f) * 2f);
            
            MaterialPropertyBlock mpb = new MaterialPropertyBlock();
            rnd.GetPropertyBlock(mpb);
            mpb.SetColor("_Color", baseColor);
            rnd.SetPropertyBlock(mpb);
        }

        Vector3 nextLocalStartPos = Vector3.up * currentLength;

        int numChildren = p.maxChildren;
        if (Random.value < p.extraChildChance) numChildren++;

        float angleStep = 360f / numChildren;
        float baseTwist = Random.Range(0f, 360f);

        for (int i = 0; i < numChildren; i++)
        {
            float randAngle = Random.Range(-p.angleRandom * p.branchAngle, p.angleRandom * p.branchAngle);
            Quaternion tilt = Quaternion.Euler(p.branchAngle + randAngle, 0, 0);
            
            float twist = baseTwist + i * angleStep + Random.Range(-p.twistRandom * p.twistAngle, p.twistRandom * p.twistAngle);
            Quaternion spin = Quaternion.Euler(0, twist, 0);

            CreateBranchRecursive(creator, pivot.transform, nextLocalStartPos, spin * tilt, depth + 1, currentLength);
        }
    }
    
    void OnSceneGUI()
    {
        TerrainCreator creator = (TerrainCreator)target;
        if (creator == null) return;

        float wX = (creator.width - 1) * creator.cellSize * 0.5f;
        float wZ = (creator.height - 1) * creator.cellSize * 0.5f;
        
        Vector3 c0 = creator.transform.TransformPoint(new Vector3(-wX, 0, -wZ));
        Vector3 c1 = creator.transform.TransformPoint(new Vector3( wX, 0, -wZ));
        Vector3 c2 = creator.transform.TransformPoint(new Vector3( wX, 0,  wZ));
        Vector3 c3 = creator.transform.TransformPoint(new Vector3(-wX, 0,  wZ));

        Handles.color = new Color(0.3f, 1f, 0.5f, 1f);
        Handles.DrawAAPolyLine(4f, c0, c1, c2, c3, c0);

        Handles.color = new Color(1f, 1f, 0.3f, 1f);
        Handles.SphereHandleCap(0, creator.transform.position, Quaternion.identity, 0.3f, EventType.Repaint);
    }
}