using System;
using System.Collections.Generic;
using UnityEditor;
using UnityEngine;

public class FoldEditorWindow : EditorWindow
{
    [SerializeField] Material targetMaterial;
    [SerializeField] Vector2 scrollPos;
    [SerializeReference] List<DeformOperation> operations = new();
    [SerializeField] List<int> expandedOps = new();
    [SerializeField] bool liveUpdate = true;

    [MenuItem("Tools/yum_food/Fold")]
    static void ShowWindow()
    {
        var window = GetWindow<FoldEditorWindow>("Fold");
        window.minSize = new Vector2(400, 300);
    }

    void OnEnable()
    {
        // Operations list is restored via SerializeReference
    }

    void OnGUI()
    {
        EditorGUILayout.Space(5);

        DrawHeader();
        EditorGUILayout.Space(10);

        if (targetMaterial == null)
        {
            EditorGUILayout.HelpBox("Select a material to build deformation pipelines", MessageType.Info);
            return;
        }

        DrawToolbar();
        EditorGUILayout.Space(5);

        EditorGUI.BeginChangeCheck();

        scrollPos = EditorGUILayout.BeginScrollView(scrollPos);
        DrawOperationsList();
        EditorGUILayout.EndScrollView();

        if (EditorGUI.EndChangeCheck() && liveUpdate && targetMaterial != null)
            ApplyToMaterial();

        EditorGUILayout.Space(5);
        DrawFooter();
    }

    void DrawHeader()
    {
        EditorGUILayout.BeginHorizontal();
        EditorGUILayout.LabelField("Target Material", EditorStyles.boldLabel, GUILayout.Width(100));

        var newMat = EditorGUILayout.ObjectField(targetMaterial, typeof(Material), false) as Material;
        if (newMat != targetMaterial)
        {
            targetMaterial = newMat;
            if (targetMaterial != null)
                LoadFromMaterial();
        }

        EditorGUILayout.EndHorizontal();
    }

    void DrawToolbar()
    {
        EditorGUILayout.BeginHorizontal(EditorStyles.toolbar);

        bool pipelineFull = operations.Count >= 16;
        using (new EditorGUI.DisabledScope(pipelineFull))
        {
            var content = pipelineFull
                ? new GUIContent("Add Operation", "Pipeline full (16/16)")
                : new GUIContent("Add Operation");
            if (GUILayout.Button(content, EditorStyles.toolbarDropDown, GUILayout.Width(120)))
                ShowAddOperationMenu();
        }

        GUILayout.FlexibleSpace();

        liveUpdate = GUILayout.Toggle(liveUpdate, "Live", EditorStyles.toolbarButton, GUILayout.Width(40));

        if (GUILayout.Button("Load Presets", EditorStyles.toolbarDropDown, GUILayout.Width(100)))
            ShowPresetsMenu();

        EditorGUILayout.EndHorizontal();
    }

    void DrawOperationsList()
    {
        if (operations.Count == 0)
        {
            EditorGUILayout.HelpBox("No operations. Click 'Add Operation' to begin.", MessageType.Info);
            return;
        }

        for (int i = 0; i < operations.Count; i++)
        {
            DrawOperation(i);
            EditorGUILayout.Space(3);
        }
    }

    void DrawOperation(int index)
    {
        var op = operations[index];
        bool isExpanded = expandedOps.Contains(index);

        var bgColor = isExpanded ? new Color(0.3f, 0.5f, 0.8f, 0.3f) : new Color(0.2f, 0.2f, 0.2f, 0.3f);

        EditorGUILayout.BeginVertical(GUI.skin.box);
        GUI.backgroundColor = bgColor;

        // Header with drag handle and delete button
        EditorGUILayout.BeginHorizontal();

        // Drag handle
        GUILayout.Label($"#{index}", GUILayout.Width(30));

        // Operation name (clickable to expand/collapse)
        if (GUILayout.Button(op.GetDisplayName(), EditorStyles.boldLabel))
        {
            if (isExpanded) expandedOps.Remove(index);
            else expandedOps.Add(index);
        }

        GUILayout.FlexibleSpace();

        // Move up/down
        GUI.enabled = index > 0;
        if (GUILayout.Button("▲", GUILayout.Width(25)))
        {
            operations.RemoveAt(index);
            operations.Insert(index - 1, op);
            if (expandedOps.Contains(index))
            {
                expandedOps.Remove(index);
                expandedOps.Add(index - 1);
            }
        }

        GUI.enabled = index < operations.Count - 1;
        if (GUILayout.Button("▼", GUILayout.Width(25)))
        {
            operations.RemoveAt(index);
            operations.Insert(index + 1, op);
            if (expandedOps.Contains(index))
            {
                expandedOps.Remove(index);
                expandedOps.Add(index + 1);
            }
        }

        GUI.enabled = true;

        // Delete button
        if (GUILayout.Button("×", GUILayout.Width(25)))
        {
            operations.RemoveAt(index);
            expandedOps.Remove(index);
            // Adjust indices in expandedOps
            for (int i = 0; i < expandedOps.Count; i++)
            {
                if (expandedOps[i] > index) expandedOps[i]--;
            }
        }

        EditorGUILayout.EndHorizontal();

        // Draw parameters when expanded
        if (isExpanded)
        {
            EditorGUILayout.Space(5);
            EditorGUI.indentLevel++;
            op.DrawParameters();
            EditorGUI.indentLevel--;
        }

        GUI.backgroundColor = Color.white;
        EditorGUILayout.EndVertical();
    }

    void DrawFooter()
    {
        EditorGUILayout.BeginHorizontal();

        if (GUILayout.Button("Apply to Material", GUILayout.Height(30)))
            ApplyToMaterial();

        if (GUILayout.Button("Clear All", GUILayout.Height(30), GUILayout.Width(100)))
        {
          operations.Clear();
          expandedOps.Clear();
        }

        EditorGUILayout.EndHorizontal();

        EditorGUILayout.Space(5);
        EditorGUILayout.LabelField($"Operations: {operations.Count}/16", EditorStyles.miniLabel);
    }

    void ShowAddOperationMenu()
    {
        var menu = new GenericMenu();

        menu.AddItem(new GUIContent("Tube to Plane"), false, () => AddOperation(new TubeToPlaneOp()));
        menu.AddItem(new GUIContent("Plane to Tube"), false, () => AddOperation(new PlaneToTubeOp()));
        menu.AddItem(new GUIContent("Plane to Hemi-Octahedron"), false, () => AddOperation(new PlaneToHemiOctahedronOp()));
        menu.AddItem(new GUIContent("Hemi-Octahedron to Plane"), false, () => AddOperation(new HemiOctahedronToPlaneOp()));
        menu.AddSeparator("");
        menu.AddItem(new GUIContent("Point Align"), false, () => AddOperation(new PointAlignOp()));
        menu.AddItem(new GUIContent("Axis Align"), false, () => AddOperation(new AxisAlignOp()));
        menu.AddSeparator("");
        menu.AddItem(new GUIContent("Norm Conversion"), false, () => AddOperation(new NormConversionOp()));
        menu.AddItem(new GUIContent("Seal"), false, () => AddOperation(new SealOp()));
        menu.AddSeparator("");
        menu.AddItem(new GUIContent("Sine Waves"), false, () => AddOperation(new SineWavesOp()));
        menu.AddItem(new GUIContent("FBM"), false, () => AddOperation(new FBMOp()));

        menu.ShowAsContext();
    }

    void ShowPresetsMenu()
    {
        var menu = new GenericMenu();

        menu.AddItem(new GUIContent("Tube to Plane"), false, () => LoadPreset_TubeToPlane());
        menu.AddItem(new GUIContent("Plane to Tube"), false, () => LoadPreset_PlaneToTube());
        menu.AddItem(new GUIContent("Plane to Hemi-Octahedron"), false, () => LoadPreset_PlaneToHemiOct());
        menu.AddSeparator("");
        menu.AddItem(new GUIContent("Norm: L1→L2 (Diamond→Sphere)"), false, () => LoadPreset_NormL1L2());
        menu.AddItem(new GUIContent("Norm: L2→L1 (Sphere→Diamond)"), false, () => LoadPreset_NormL2L1());
        menu.AddItem(new GUIContent("Norm: L2→L∞ (Sphere→Cube)"), false, () => LoadPreset_NormL2Linf());
        menu.AddSeparator("");
        menu.AddItem(new GUIContent("Complex/Tube→Plane + Norm Conv"), false, () => LoadPreset_TubePlaneNorm());

        menu.ShowAsContext();
    }

    void AddOperation(DeformOperation op)
    {
        if (operations.Count >= 16)
            return;
        operations.Add(op);
        expandedOps.Add(operations.Count - 1);
    }

    void LoadPreset_TubeToPlane()
    {
        operations.Clear();
        expandedOps.Clear();
        AddOperation(new TubeToPlaneOp());
    }

    void LoadPreset_PlaneToTube()
    {
        operations.Clear();
        expandedOps.Clear();
        AddOperation(new PlaneToTubeOp());
    }

    void LoadPreset_PlaneToHemiOct()
    {
        operations.Clear();
        expandedOps.Clear();
        AddOperation(new PlaneToHemiOctahedronOp());
    }

    void LoadPreset_NormL1L2()
    {
        operations.Clear();
        expandedOps.Clear();
        var op = new NormConversionOp();
        op.inputK = 1f;
        op.outputK = 2f;
        AddOperation(op);
    }

    void LoadPreset_NormL2L1()
    {
        operations.Clear();
        expandedOps.Clear();
        var op = new NormConversionOp();
        op.inputK = 2f;
        op.outputK = 1f;
        AddOperation(op);
    }

    void LoadPreset_NormL2Linf()
    {
        operations.Clear();
        expandedOps.Clear();
        var op = new NormConversionOp();
        op.inputK = 2f;
        op.outputK = float.PositiveInfinity;
        AddOperation(op);
    }

    void LoadPreset_TubePlaneNorm()
    {
        operations.Clear();
        expandedOps.Clear();
        AddOperation(new TubeToPlaneOp());
        var norm = new NormConversionOp();
        norm.inputK = 2f;
        norm.outputK = 1f;
        AddOperation(norm);
    }

    void ApplyToMaterial()
    {
        var builder = FoldPipelineBuilder.Create().For(targetMaterial);

        foreach (var op in operations)
            op.ApplyTo(builder);

        builder.Apply();
    }

    void LoadFromMaterial()
    {
        // Could potentially read back from material properties here
        // For now, just clear the list
        operations.Clear();
        expandedOps.Clear();
    }
}

// Base class for deformation operations
[System.Serializable]
public abstract class DeformOperation
{
    public abstract string GetDisplayName();
    public abstract void DrawParameters();
    public abstract void ApplyTo(FoldPipelineBuilder builder);
}

[System.Serializable]
public class TubeToPlaneOp : DeformOperation
{
    public Vector3 p = Vector3.zero;
    public Vector3 r = Vector3.right;
    public Vector3 s = Vector3.forward;
    public float t = 1f;

    public override string GetDisplayName() => "Tube to Plane";

    public override void DrawParameters()
    {
        p = EditorGUILayout.Vector3Field("Origin (p)", p);
        r = EditorGUILayout.Vector3Field("R Axis", r);
        s = EditorGUILayout.Vector3Field("S Axis", s);
        t = EditorGUILayout.Slider("Interpolation (t)", t, 0f, 1f);
    }

    public override void ApplyTo(FoldPipelineBuilder builder) =>
        builder.TubeToPlane(p, r, s, t);
}

[System.Serializable]
public class PlaneToTubeOp : DeformOperation
{
    public Vector3 p = Vector3.zero;
    public Vector3 r = Vector3.right;
    public Vector3 s = Vector3.forward;
    public float t = 1f;

    public override string GetDisplayName() => "Plane to Tube";

    public override void DrawParameters()
    {
        p = EditorGUILayout.Vector3Field("Origin (p)", p);
        r = EditorGUILayout.Vector3Field("R Axis", r);
        s = EditorGUILayout.Vector3Field("S Axis", s);
        t = EditorGUILayout.Slider("Interpolation (t)", t, 0f, 1f);
    }

    public override void ApplyTo(FoldPipelineBuilder builder) =>
        builder.PlaneToTube(p, r, s, t);
}

[System.Serializable]
public class PlaneToHemiOctahedronOp : DeformOperation
{
    public Vector3 p = Vector3.zero;
    public Vector3 r = Vector3.right;
    public Vector3 s = Vector3.forward;
    public float t = 1f;

    public override string GetDisplayName() => "Plane to Hemi-Octahedron";

    public override void DrawParameters()
    {
        p = EditorGUILayout.Vector3Field("Origin (p)", p);
        r = EditorGUILayout.Vector3Field("R Axis", r);
        s = EditorGUILayout.Vector3Field("S Axis", s);
        t = EditorGUILayout.Slider("Interpolation (t)", t, 0f, 1f);
    }

    public override void ApplyTo(FoldPipelineBuilder builder) =>
        builder.PlaneToHemiOctahedron(p, r, s, t);
}

[System.Serializable]
public class HemiOctahedronToPlaneOp : DeformOperation
{
    public Vector3 p = Vector3.zero;
    public Vector3 r = Vector3.right;
    public Vector3 s = Vector3.forward;
    public float t = 1f;

    public override string GetDisplayName() => "Hemi-Octahedron to Plane";

    public override void DrawParameters()
    {
        p = EditorGUILayout.Vector3Field("Origin (p)", p);
        r = EditorGUILayout.Vector3Field("R Axis", r);
        s = EditorGUILayout.Vector3Field("S Axis", s);
        t = EditorGUILayout.Slider("Interpolation (t)", t, 0f, 1f);
    }

    public override void ApplyTo(FoldPipelineBuilder builder) =>
        builder.HemiOctahedronToPlane(p, r, s, t);
}

[System.Serializable]
public class PointAlignOp : DeformOperation
{
    public Vector3 po = Vector3.zero;
    public Vector3 pp = Vector3.up;
    public Vector3 r = Vector3.right;
    public float t = 1f;

    public override string GetDisplayName() => "Point Align";

    public override void DrawParameters()
    {
        po = EditorGUILayout.Vector3Field("Origin Point (po)", po);
        pp = EditorGUILayout.Vector3Field("Target Point (pp)", pp);
        r = EditorGUILayout.Vector3Field("Rotation Axis (r)", r);
        t = EditorGUILayout.Slider("Interpolation (t)", t, 0f, 1f);
    }

    public override void ApplyTo(FoldPipelineBuilder builder) =>
        builder.PointAlign(po, pp, r, t);
}

[System.Serializable]
public class AxisAlignOp : DeformOperation
{
    public Vector3 po = Vector3.zero;
    public Vector3 pp = Vector3.up;
    public Vector3 r = Vector3.right;
    public float t = 1f;

    public override string GetDisplayName() => "Axis Align";

    public override void DrawParameters()
    {
        po = EditorGUILayout.Vector3Field("Origin Point (po)", po);
        pp = EditorGUILayout.Vector3Field("Target Point (pp)", pp);
        r = EditorGUILayout.Vector3Field("Rotation Axis (r)", r);
        t = EditorGUILayout.Slider("Interpolation (t)", t, 0f, 1f);
    }

    public override void ApplyTo(FoldPipelineBuilder builder) =>
        builder.AxisAlign(po, pp, r, t);
}

[System.Serializable]
public class NormConversionOp : DeformOperation
{
    public float inputK = 2f;
    public float outputK = 1f;
    public float t = 1f;

    public override string GetDisplayName() => $"Norm Conversion (L{FormatNorm(inputK)}→L{FormatNorm(outputK)})";

    string FormatNorm(float k)
    {
        if (float.IsPositiveInfinity(k)) return "∞";
        return k.ToString("F1");
    }

    public override void DrawParameters()
    {
        EditorGUILayout.BeginHorizontal();
        EditorGUILayout.LabelField("Input Norm (k)", GUILayout.Width(120));
        inputK = EditorGUILayout.FloatField(inputK);
        if (GUILayout.Button("L∞", GUILayout.Width(30))) inputK = float.PositiveInfinity;
        EditorGUILayout.EndHorizontal();

        EditorGUILayout.BeginHorizontal();
        EditorGUILayout.LabelField("Output Norm (k)", GUILayout.Width(120));
        outputK = EditorGUILayout.FloatField(outputK);
        if (GUILayout.Button("L∞", GUILayout.Width(30))) outputK = float.PositiveInfinity;
        EditorGUILayout.EndHorizontal();

        t = EditorGUILayout.Slider("Interpolation (t)", t, 0f, 1f);

        EditorGUILayout.HelpBox(
            "Common: L1=diamond, L2=sphere, L∞=cube",
            MessageType.Info);
    }

    public override void ApplyTo(FoldPipelineBuilder builder) =>
        builder.NormConversion(inputK, outputK, t);
}

[System.Serializable]
public class SealOp : DeformOperation
{
    public float A = 0.1f;
    public float k = 2f;
    public float st = 0.8f;
    public float t = 1f;

    public override string GetDisplayName() => "Seal";

    public override void DrawParameters()
    {
        A = EditorGUILayout.FloatField("Amplitude (A)", A);
        k = EditorGUILayout.FloatField("Smoothness (k)", k);
        st = EditorGUILayout.FloatField("Scale (st)", st);
        t = EditorGUILayout.Slider("Interpolation (t)", t, 0f, 1f);
    }

    public override void ApplyTo(FoldPipelineBuilder builder) =>
        builder.Seal(A, k, st, t);
}

[System.Serializable]
public class SineWavesOp : DeformOperation
{
    public override string GetDisplayName() => "Sine Waves";

    public override void DrawParameters()
    {
        EditorGUILayout.HelpBox("Sine waves use shader-side parameters", MessageType.Info);
    }

    public override void ApplyTo(FoldPipelineBuilder builder) =>
        builder.SineWaves();
}

[System.Serializable]
public class FBMOp : DeformOperation
{
    public override string GetDisplayName() => "FBM (Fractal Brownian Motion)";

    public override void DrawParameters()
    {
        EditorGUILayout.HelpBox("FBM uses shader-side parameters", MessageType.Info);
    }

    public override void ApplyTo(FoldPipelineBuilder builder) =>
        builder.FBM();
}