// WL788_Measure.cs — PD 지시 #788 크레센트 로컬 프레임 실측 (에디트 모드 · Assets 무수정)
//   unity command run_script --file AgentScripts/WL788_Measure.cs --entry WL788_Measure.Dump --args '["Effect_Slash_10101_1"]'
//   unity command run_script --file AgentScripts/WL788_Measure.cs --entry WL788_Measure.DumpMany --args '["Effect_Slash_10101_1,Effect_Slash_10501_1"]'
//
// 측정 방법 (구 방식 "메시 바운즈 최소축" 의 한계를 넘기 위한 정밀화):
//   ① 프리팹을 프리뷰 씬에 인스턴스(현재 씬 무영향 · isDirty 유발 없음)
//   ② 크레센트 이미터를 수명 30% 지점까지 Simulate → ParticleSystemRenderer.BakeMesh
//      = 정렬(alignment) · startRotation · startSize · 스트레치가 모두 반영된 **실제 렌더 지오메트리**
//   ③ 베이크 메시의 삼각형을 UV 로 리샘플하며 머티리얼 텍스처의 알파×휘도(잉크)를 가중치로 삼아
//      루트 로컬 공간의 "보이는 픽셀 구름" 을 만든다 (크레센트가 메시 모양이든 텍스처든 동일 처리)
//   ④ 가중 PCA → 평면 법선 · 평면 투영 후 Kasa 원 적합 → 호 중심 · 내/외 반지름 · 각도 범위
//      → 시위 방향(start→end) · 볼록 방향(중심→호 중점) 확정
using System.Collections.Generic;
using System.Linq;
using System.Text;
using UnityEditor;
using UnityEditor.SceneManagement;
using UnityEngine;
using UnityEngine.SceneManagement;

public static class WL788_Measure
{
    // ── 결과 구조 ────────────────────────────────────────────────────────────
    public struct Frame
    {
        public string emitter;
        public Vector3 normal;      // 루트 로컬 — 크레센트 평면 법선
        public Vector3 chord;       // 루트 로컬 — 호 시작→끝 (시위) 방향, 정규화
        public Vector3 convex;      // 루트 로컬 — 호 중심→호 중점 (볼록) 방향, 정규화
        public Vector3 center;      // 루트 로컬 — 호의 원 중심
        public float innerR, outerR, midR;
        public float arcDeg;        // 호가 덮는 각도
        public float ink;           // 잉크 총량(가중치 합)
        public float planarity;     // 평면성 = 1 - (최소분산/중간분산). 1 에 가까울수록 평평
        public float circleRms;     // 원 적합 잔차 RMS / midR
        public int samples;
        public string inkMode;
        public bool oriented;       // 방향 정보를 담고 있는가(카메라 정렬이 아닌가)
        public string tile;         // 스프라이트 시트에서 고른 타일
    }

    public static object DumpMany(string csv)
    {
        var sb = new StringBuilder();
        foreach (var n in csv.Split(',')) { sb.AppendLine(Dump(n.Trim()) as string); }
        return sb.ToString();
    }

    public static object Dump(string prefabName)
    {
        string path = FindPrefab(prefabName);
        if (path == null) return "prefab not found: " + prefabName;
        var src = AssetDatabase.LoadAssetAtPath<GameObject>(path);

        var sb = new StringBuilder();
        sb.AppendLine("== " + prefabName + "  " + path);
        sb.AppendLine("   rootScale=" + src.transform.localScale.ToString("F3") + " rootEuler=" + src.transform.localEulerAngles.ToString("F1"));

        Scene preview = default(Scene);
        GameObject inst = null;
        GameObject camGo = null;
        try
        {
            preview = EditorSceneManager.NewPreviewScene();
            inst = Object.Instantiate(src);
            inst.transform.SetPositionAndRotation(Vector3.zero, Quaternion.identity);
            SceneManager.MoveGameObjectToScene(inst, preview);

            camGo = new GameObject("wl788cam");
            SceneManager.MoveGameObjectToScene(camGo, preview);
            var cam = camGo.AddComponent<Camera>();
            camGo.transform.SetPositionAndRotation(new Vector3(0f, 0f, -10f), Quaternion.identity);
            cam.enabled = false;

            var root = inst.transform;
            foreach (var ps in inst.GetComponentsInChildren<ParticleSystem>(true))
            {
                var psr = ps.GetComponent<ParticleSystemRenderer>();
                if (psr == null) continue;
                var main = ps.main;
                string mat = psr.sharedMaterial != null ? psr.sharedMaterial.name : "-";
                var tex = GetTex(psr.sharedMaterial);
                var tsa = ps.textureSheetAnimation;

                sb.AppendLine(string.Format(
                    "  -- {0,-16} on={1} render={2}{3} align={4} size={5:F2} life={6:F2} rot3D={7} rot={8:F0} sim={9} mat={10} tex={11}{12}",
                    ps.gameObject.name, psr.enabled, psr.renderMode,
                    psr.renderMode == ParticleSystemRenderMode.Mesh && psr.mesh != null ? "(" + psr.mesh.name + " v" + psr.mesh.vertexCount + ")" : "",
                    psr.alignment, main.startSize.constantMax, main.startLifetime.constantMax,
                    main.startRotation3D, main.startRotation.constantMax * Mathf.Rad2Deg, main.simulationSpace, mat,
                    tex != null ? tex.name + " " + tex.width + "x" + tex.height : "-",
                    tsa.enabled ? string.Format(" sheet={0}x{1}", tsa.numTilesX, tsa.numTilesY) : ""));

                if (!psr.enabled) continue;

                Frame f;
                if (!MeasureEmitter(ps, psr, root, cam, out f)) { sb.AppendLine("     (측정 불가 — 잉크 없음)"); continue; }
                sb.AppendLine(Format(f));
            }
        }
        finally
        {
            if (camGo != null) Object.DestroyImmediate(camGo);
            if (inst != null) Object.DestroyImmediate(inst);
            if (preview.IsValid()) EditorSceneManager.ClosePreviewScene(preview);
        }
        return sb.ToString();
    }

    static string Format(Frame f)
    {
        return string.Format(
            "     FRAME n={0} chord={1} convex={2} center={3}\n" +
            "           innerR={4:F3} outerR={5:F3} midR={6:F3} arc={7:F1}deg ink={8:F0} planar={9:F3} circRms={10:F3} pts={11}",
            f.normal.ToString("F3"), f.chord.ToString("F3"), f.convex.ToString("F3"), f.center.ToString("F3"),
            f.innerR, f.outerR, f.midR, f.arcDeg, f.ink, f.planarity, f.circleRms, f.samples)
            + " " + f.inkMode + (string.IsNullOrEmpty(f.tile) ? "" : " tile=" + f.tile);
    }

    // ── 이미터 1개 실측 (결정론적) ───────────────────────────────────────────
    //  Simulate + BakeMesh 는 **여러 파티클의 합집합**이라 shape 산포·랜덤 시드 때문에
    //  실행마다 호 중심·시위 방향이 달라진다(실측 2026-09-07: 같은 이미터 2회 측정에서
    //  법선은 4° 이내로 같았지만 chord 가 평면 안에서 60° 이상 회전). 캘리브레이션 값은
    //  재현 가능해야 하므로 **파티클 1개의 소스 지오메트리**를 결정론적으로 잰다.
    //    · Mesh 렌더 → psr.mesh 의 정점/UV 를 그대로 (메시 로컬)
    //    · Billboard/Local → 이미터 로컬 XY 평면의 단위 쿼드로 합성 (모양은 텍스처가 갖는다)
    //    · View 정렬 → 항상 카메라를 보므로 방향 정보 없음 → 측정 제외
    //  그 뒤 이미터의 루트 기준 상대 회전·스케일·위치와 startSize·startRotation 을 곱한다.
    public static bool MeasureEmitter(ParticleSystem ps, ParticleSystemRenderer psr, Transform root, Camera cam, out Frame f)
    {
        f = new Frame();
        f.emitter = ps.gameObject.name;
        var main = ps.main;

        bool oriented = psr.alignment != ParticleSystemRenderSpace.View;
        f.oriented = oriented;
        if (!oriented) return false;

        // ① 파티클 로컬 지오메트리 (정점 + UV + 삼각형)
        Vector3[] verts; Vector2[] uvs; int[] tris;
        if (psr.renderMode == ParticleSystemRenderMode.Mesh && psr.mesh != null)
        {
            verts = psr.mesh.vertices; uvs = psr.mesh.uv; tris = psr.mesh.triangles;
        }
        else
        {
            // 단위 쿼드 — 이미터 로컬 XY 평면, 법선 +Z
            verts = new[] { new Vector3(-0.5f, -0.5f, 0f), new Vector3(0.5f, -0.5f, 0f), new Vector3(0.5f, 0.5f, 0f), new Vector3(-0.5f, 0.5f, 0f) };
            uvs = new[] { new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1) };
            tris = new[] { 0, 1, 2, 0, 2, 3 };
        }
        if (verts.Length < 3 || tris.Length < 3) return false;
        if (uvs == null || uvs.Length != verts.Length) uvs = null;

        // ② 텍스처 (스프라이트 시트면 잉크가 가장 많은 타일을 고른다)
        Texture2D readable = MakeReadable(GetTex(psr.sharedMaterial));
        Vector2 tileScale = Vector2.one, tileOffset = Vector2.zero;
        var tsa = ps.textureSheetAnimation;
        if (readable != null && tsa.enabled && tsa.numTilesX > 0 && tsa.numTilesY > 0)
        {
            tileScale = new Vector2(1f / tsa.numTilesX, 1f / tsa.numTilesY);
            float best = -1f;
            for (int ty = 0; ty < tsa.numTilesY; ty++)
                for (int tx = 0; tx < tsa.numTilesX; tx++)
                {
                    float ink = TileInk(readable, new Vector2(tx * tileScale.x, ty * tileScale.y), tileScale);
                    if (ink > best) { best = ink; tileOffset = new Vector2(tx * tileScale.x, ty * tileScale.y); }
                }
            f.tile = string.Format("{0}x{1}@{2:F2},{3:F2}", tsa.numTilesX, tsa.numTilesY, tileOffset.x, tileOffset.y);
        }

        try
        {
            // ③ 파티클 로컬 → 루트 로컬 변환
            //    루트 기준 상대 회전 · 스케일. startSize 는 파티클 크기 배수.
            Quaternion rel = Quaternion.Inverse(root.rotation) * ps.transform.rotation;
            float rotZ = main.startRotation.constantMax * Mathf.Rad2Deg;
            if (Mathf.Abs(rotZ) > 0.01f) rel = rel * Quaternion.Euler(0f, 0f, rotZ);
            Vector3 relScale = InvScale(ps.transform.lossyScale, root.lossyScale) * Mathf.Max(main.startSize.constantMax, 1e-4f);
            Vector3 origin = root.InverseTransformPoint(ps.transform.position);

            float[] thresholds = { 0.05f, 0.01f, 0f };   // 마지막 0 = 지오메트리 전용 폴백
            for (int ti2 = 0; ti2 < thresholds.Length; ti2++)
            {
                float thr = thresholds[ti2];
                var pts = new List<Vector3>(8192);
                var wts = new List<float>(8192);
                const int GRID = 14;
                int triCount = tris.Length / 3;

                for (int ti = 0; ti < triCount; ti++)
                {
                    Vector3 a = verts[tris[ti * 3]], b = verts[tris[ti * 3 + 1]], c = verts[tris[ti * 3 + 2]];
                    Vector2 ua = Vector2.zero, ub = Vector2.zero, uc = Vector2.zero;
                    if (uvs != null) { ua = uvs[tris[ti * 3]]; ub = uvs[tris[ti * 3 + 1]]; uc = uvs[tris[ti * 3 + 2]]; }

                    for (int i = 0; i <= GRID; i++)
                        for (int j = 0; i + j <= GRID; j++)
                        {
                            float w1 = (float)i / GRID, w2 = (float)j / GRID, w0 = 1f - w1 - w2;
                            float w = 1f;
                            if (readable != null && uvs != null && thr > 0f)
                            {
                                Vector2 uv = ua * w0 + ub * w1 + uc * w2;
                                uv = new Vector2(tileOffset.x + Frac(uv.x) * tileScale.x, tileOffset.y + Frac(uv.y) * tileScale.y);
                                var col = readable.GetPixelBilinear(uv.x, uv.y);
                                // 잉크 = 알파 × 휘도. 가산 합성 텍스처는 알파가 1 이라 휘도가 지배한다.
                                float lum = col.r * 0.299f + col.g * 0.587f + col.b * 0.114f;
                                w = col.a * Mathf.Max(lum, 0.0001f);
                                if (w < thr) continue;
                            }
                            Vector3 pLocal = a * w0 + b * w1 + c * w2;
                            pLocal = new Vector3(pLocal.x * relScale.x, pLocal.y * relScale.y, pLocal.z * relScale.z);
                            pts.Add(origin + rel * pLocal);
                            wts.Add(w);
                        }
                }
                if (pts.Count < 32) continue;
                f.inkMode = thr > 0f ? "tex>" + thr.ToString("F2") : "geom";
                bool ok = Solve(pts, wts, ref f);
                f.emitter = ps.gameObject.name;
                f.oriented = oriented;
                return ok;
            }
            return false;
        }
        finally
        {
            if (readable != null) Object.DestroyImmediate(readable);
        }
    }

    static float Frac(float v) { return v - Mathf.Floor(v); }

    static Vector3 InvScale(Vector3 child, Vector3 parent)
    {
        return new Vector3(
            Mathf.Abs(parent.x) > 1e-6f ? child.x / parent.x : child.x,
            Mathf.Abs(parent.y) > 1e-6f ? child.y / parent.y : child.y,
            Mathf.Abs(parent.z) > 1e-6f ? child.z / parent.z : child.z);
    }

    static float TileInk(Texture2D tex, Vector2 off, Vector2 scale)
    {
        float sum = 0f;
        const int N = 24;
        for (int y = 0; y < N; y++)
            for (int x = 0; x < N; x++)
            {
                var c = tex.GetPixelBilinear(off.x + (x + 0.5f) / N * scale.x, off.y + (y + 0.5f) / N * scale.y);
                sum += c.a * (c.r * 0.299f + c.g * 0.587f + c.b * 0.114f);
            }
        return sum;
    }

    // ── 가중 PCA + 원 적합 ───────────────────────────────────────────────────
    static bool Solve(List<Vector3> pts, List<float> wts, ref Frame f)
    {
        int n = pts.Count;
        float wsum = 0f; Vector3 mean = Vector3.zero;
        for (int i = 0; i < n; i++) { mean += pts[i] * wts[i]; wsum += wts[i]; }
        if (wsum <= 1e-6f) return false;
        mean /= wsum;

        // 3x3 공분산
        double[,] C = new double[3, 3];
        for (int i = 0; i < n; i++)
        {
            Vector3 d = pts[i] - mean; float w = wts[i];
            C[0, 0] += w * d.x * d.x; C[0, 1] += w * d.x * d.y; C[0, 2] += w * d.x * d.z;
            C[1, 1] += w * d.y * d.y; C[1, 2] += w * d.y * d.z; C[2, 2] += w * d.z * d.z;
        }
        C[1, 0] = C[0, 1]; C[2, 0] = C[0, 2]; C[2, 1] = C[1, 2];
        for (int a = 0; a < 3; a++) for (int b = 0; b < 3; b++) C[a, b] /= wsum;

        Vector3[] ev; float[] va;
        Jacobi(C, out ev, out va);
        // 오름차순 정렬 — va[0] 최소 = 법선
        for (int i = 0; i < 2; i++)
            for (int j = i + 1; j < 3; j++)
                if (va[j] < va[i]) { var tv = va[i]; va[i] = va[j]; va[j] = tv; var te = ev[i]; ev[i] = ev[j]; ev[j] = te; }

        Vector3 nrm = ev[0].normalized;
        Vector3 e1 = ev[2].normalized;                       // 최대 분산 축(평면 내)
        Vector3 e2 = Vector3.Cross(nrm, e1).normalized;
        f.planarity = va[1] > 1e-12f ? 1f - Mathf.Sqrt(Mathf.Max(va[0], 0f) / va[1]) : 1f;

        // 평면 2D 좌표
        var x = new float[n]; var y = new float[n];
        for (int i = 0; i < n; i++) { Vector3 d = pts[i] - mean; x[i] = Vector3.Dot(d, e1); y[i] = Vector3.Dot(d, e2); }

        // Kasa 원 적합 (가중)
        double Sx = 0, Sy = 0, Sxx = 0, Syy = 0, Sxy = 0, Sxz = 0, Syz = 0, Sz = 0, W = 0;
        for (int i = 0; i < n; i++)
        {
            double w = wts[i], xi = x[i], yi = y[i], zi = xi * xi + yi * yi;
            W += w; Sx += w * xi; Sy += w * yi; Sxx += w * xi * xi; Syy += w * yi * yi;
            Sxy += w * xi * yi; Sxz += w * xi * zi; Syz += w * yi * zi; Sz += w * zi;
        }
        double a11 = Sxx - Sx * Sx / W, a12 = Sxy - Sx * Sy / W, a22 = Syy - Sy * Sy / W;
        double b1 = 0.5 * (Sxz - Sx * Sz / W), b2 = 0.5 * (Syz - Sy * Sz / W);
        double det = a11 * a22 - a12 * a12;
        double cx, cy;
        bool circleOk = System.Math.Abs(det) > 1e-14;
        if (circleOk) { cx = (b1 * a22 - b2 * a12) / det; cy = (a11 * b2 - a12 * b1) / det; }
        else { cx = 0; cy = 0; }

        // 반지름 분포 · 각도 범위
        var rad = new float[n]; var ang = new float[n];
        for (int i = 0; i < n; i++)
        {
            double dx = x[i] - cx, dy = y[i] - cy;
            rad[i] = (float)System.Math.Sqrt(dx * dx + dy * dy);
            ang[i] = Mathf.Atan2((float)dy, (float)dx);
        }
        float rMid = WeightedPercentile(rad, wts, 0.5f);
        f.innerR = WeightedPercentile(rad, wts, 0.05f);
        f.outerR = WeightedPercentile(rad, wts, 0.95f);
        f.midR = rMid;

        double rms = 0;
        for (int i = 0; i < n; i++) { double d = rad[i] - rMid; rms += wts[i] * d * d; }
        f.circleRms = rMid > 1e-6f ? (float)System.Math.Sqrt(rms / W) / rMid : 999f;

        // 각도 평균 = 원형 평균(±π 경계 안전)
        double sa = 0, ca = 0;
        for (int i = 0; i < n; i++) { sa += wts[i] * Mathf.Sin(ang[i]); ca += wts[i] * Mathf.Cos(ang[i]); }
        float midAng = Mathf.Atan2((float)sa, (float)ca);
        // 중점 기준 상대각으로 펴서 범위를 잰다
        var rel = new float[n];
        for (int i = 0; i < n; i++) rel[i] = Mathf.DeltaAngle(midAng * Mathf.Rad2Deg, ang[i] * Mathf.Rad2Deg);
        float lo = WeightedPercentile(rel, wts, 0.03f), hi = WeightedPercentile(rel, wts, 0.97f);
        f.arcDeg = hi - lo;

        // 프레임 확정
        Vector3 Dir(float degFromMid)
        {
            float t = midAng + degFromMid * Mathf.Deg2Rad;
            return (e1 * Mathf.Cos(t) + e2 * Mathf.Sin(t)).normalized;
        }
        Vector3 convex = Dir(0f);
        Vector3 start = Dir(lo), end = Dir(hi);
        Vector3 chord = end - start;                 // 시위 = 호 시작점 → 끝점
        if (chord.sqrMagnitude < 1e-8f) chord = Vector3.Cross(nrm, convex);
        chord.Normalize();
        // 법선 방향을 (chord × convex) 오른손 규약으로 고정한다 — 뒤집힘 없이 재현 가능
        Vector3 nFixed = Vector3.Cross(chord, convex).normalized;
        if (Vector3.Dot(nFixed, nrm) < 0f) nrm = -nrm;
        nrm = nFixed;

        f.normal = nrm;
        f.chord = chord;
        f.convex = convex;
        f.center = mean + e1 * (float)cx + e2 * (float)cy;
        f.ink = wsum;
        f.samples = n;
        return circleOk;
    }

    static float WeightedPercentile(float[] v, List<float> w, float p)
    {
        int n = v.Length;
        var idx = Enumerable.Range(0, n).ToArray();
        System.Array.Sort(idx, (a, b) => v[a].CompareTo(v[b]));
        float total = 0f; for (int i = 0; i < n; i++) total += w[i];
        float acc = 0f, target = total * p;
        for (int i = 0; i < n; i++) { acc += w[idx[i]]; if (acc >= target) return v[idx[i]]; }
        return v[idx[n - 1]];
    }

    // 대칭 3x3 야코비 고유분해
    static void Jacobi(double[,] a, out Vector3[] vec, out float[] val)
    {
        double[,] v = new double[3, 3] { { 1, 0, 0 }, { 0, 1, 0 }, { 0, 0, 1 } };
        double[,] m = (double[,])a.Clone();
        for (int sweep = 0; sweep < 24; sweep++)
        {
            double off = m[0, 1] * m[0, 1] + m[0, 2] * m[0, 2] + m[1, 2] * m[1, 2];
            if (off < 1e-20) break;
            for (int p = 0; p < 2; p++)
                for (int q = p + 1; q < 3; q++)
                {
                    if (System.Math.Abs(m[p, q]) < 1e-18) continue;
                    double theta = (m[q, q] - m[p, p]) / (2 * m[p, q]);
                    double tt = System.Math.Sign(theta) / (System.Math.Abs(theta) + System.Math.Sqrt(theta * theta + 1));
                    if (theta == 0) tt = 1;
                    double c = 1 / System.Math.Sqrt(tt * tt + 1), s = tt * c;
                    for (int k = 0; k < 3; k++)
                    {
                        double mkp = m[k, p], mkq = m[k, q];
                        m[k, p] = c * mkp - s * mkq; m[k, q] = s * mkp + c * mkq;
                    }
                    for (int k = 0; k < 3; k++)
                    {
                        double mpk = m[p, k], mqk = m[q, k];
                        m[p, k] = c * mpk - s * mqk; m[q, k] = s * mpk + c * mqk;
                    }
                    for (int k = 0; k < 3; k++)
                    {
                        double vkp = v[k, p], vkq = v[k, q];
                        v[k, p] = c * vkp - s * vkq; v[k, q] = s * vkp + c * vkq;
                    }
                }
        }
        vec = new Vector3[3]; val = new float[3];
        for (int i = 0; i < 3; i++)
        {
            vec[i] = new Vector3((float)v[0, i], (float)v[1, i], (float)v[2, i]);
            val[i] = (float)m[i, i];
        }
    }

    // ── 유틸 ────────────────────────────────────────────────────────────────
    public static string FindPrefab(string name)
    {
        var guids = AssetDatabase.FindAssets(name + " t:Prefab");
        return guids.Select(AssetDatabase.GUIDToAssetPath)
                    .FirstOrDefault(p => System.IO.Path.GetFileNameWithoutExtension(p) == name);
    }

    public static Texture GetTex(Material m)
    {
        if (m == null) return null;
        if (m.mainTexture != null) return m.mainTexture;
        string[] names = { "_MainTex", "_BaseMap", "_BaseColorMap", "_Texture" };
        foreach (var n in names) if (m.HasProperty(n) && m.GetTexture(n) != null) return m.GetTexture(n);
        return null;
    }

    /// <summary>읽기 불가 텍스처도 RenderTexture 경유로 픽셀을 읽는다(임포터 무수정).</summary>
    public static Texture2D MakeReadable(Texture src)
    {
        if (src == null) return null;
        int w = Mathf.Min(src.width, 256), h = Mathf.Min(src.height, 256);
        var rt = RenderTexture.GetTemporary(w, h, 0, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Linear);
        var prev = RenderTexture.active;
        Graphics.Blit(src, rt);
        RenderTexture.active = rt;
        var tex = new Texture2D(w, h, TextureFormat.RGBA32, false, true);
        tex.ReadPixels(new Rect(0, 0, w, h), 0, 0);
        tex.Apply();
        RenderTexture.active = prev;
        RenderTexture.ReleaseTemporary(rt);
        return tex;
    }
}