using UnityEngine;
using UnityEditor;
using SplashEdit.RuntimeCode;

namespace SplashEdit.EditorCode
{
    // --- Scene Preview Gizmos ---
    // These draw filled rectangles in the Scene view for WYSIWYG UI preview.

    public static class PSXUIGizmos
    {
        [DrawGizmo(GizmoType.NonSelected | GizmoType.Selected)]
        static void DrawBoxGizmo(PSXUIBox box, GizmoType gizmoType)
        {
            RectTransform rt = box.GetComponent<RectTransform>();
            if (rt == null) return;
            Vector3[] corners = new Vector3[4];
            rt.GetWorldCorners(corners);
            Color fill = box.BoxColor;
            fill.a = (gizmoType & GizmoType.Selected) != 0 ? 0.8f : 0.5f;
            Color border = Color.white;
            border.a = (gizmoType & GizmoType.Selected) != 0 ? 1f : 0.4f;
            Handles.DrawSolidRectangleWithOutline(corners, fill, border);
        }

        [DrawGizmo(GizmoType.NonSelected | GizmoType.Selected)]
        static void DrawImageGizmo(PSXUIImage image, GizmoType gizmoType)
        {
            RectTransform rt = image.GetComponent<RectTransform>();
            if (rt == null) return;
            Vector3[] corners = new Vector3[4];
            rt.GetWorldCorners(corners);

            bool selected = (gizmoType & GizmoType.Selected) != 0;

            // Draw texture preview if available
            if (image.SourceTexture != null)
            {
                Color tint = image.TintColor;
                tint.a = selected ? 0.9f : 0.6f;
                Handles.DrawSolidRectangleWithOutline(corners, tint * 0.3f, tint);

                // Draw texture in GUI overlay
                Handles.BeginGUI();
                Vector2 min = HandleUtility.WorldToGUIPoint(corners[0]);
                Vector2 max = HandleUtility.WorldToGUIPoint(corners[2]);
                Rect screenRect = new Rect(
                    Mathf.Min(min.x, max.x), Mathf.Min(min.y, max.y),
                    Mathf.Abs(max.x - min.x), Mathf.Abs(max.y - min.y));
                if (screenRect.width > 2 && screenRect.height > 2)
                {
                    GUI.color = new Color(tint.r, tint.g, tint.b, selected ? 0.9f : 0.5f);
                    GUI.DrawTexture(screenRect, image.SourceTexture, ScaleMode.StretchToFill);
                    GUI.color = Color.white;
                }
                Handles.EndGUI();
            }
            else
            {
                Color fill = new Color(0.4f, 0.4f, 0.8f, selected ? 0.4f : 0.2f);
                Handles.DrawSolidRectangleWithOutline(corners, fill, Color.cyan);
            }
        }

        [DrawGizmo(GizmoType.NonSelected | GizmoType.Selected)]
        static void DrawTextGizmo(PSXUIText text, GizmoType gizmoType)
        {
            RectTransform rt = text.GetComponent<RectTransform>();
            if (rt == null) return;
            Vector3[] corners = new Vector3[4];
            rt.GetWorldCorners(corners);

            bool selected = (gizmoType & GizmoType.Selected) != 0;
            Color border = text.TextColor;
            border.a = selected ? 1f : 0.5f;
            Color fill = new Color(0, 0, 0, selected ? 0.3f : 0.1f);
            Handles.DrawSolidRectangleWithOutline(corners, fill, border);

            // Pixel-perfect preview: render each glyph from the actual font bitmap
            // at PS1 scale, using advance widths for proportional positioning.
            string label = string.IsNullOrEmpty(text.DefaultText) ? "[empty]" : text.DefaultText;

            PSXFontAsset font = text.GetEffectiveFont();
            int glyphW = font != null ? font.GlyphWidth : 8;
            int glyphH = font != null ? font.GlyphHeight : 16;

            Handles.BeginGUI();
            Vector2 topLeft = HandleUtility.WorldToGUIPoint(corners[1]);
            Vector2 botRight = HandleUtility.WorldToGUIPoint(corners[3]);

            float rectScreenW = Mathf.Abs(botRight.x - topLeft.x);
            float rectW = rt.rect.width;
            float psxPixelScale = (rectW > 0.01f) ? rectScreenW / rectW : 1f;

            float guiX = Mathf.Min(topLeft.x, botRight.x);
            float guiY = Mathf.Min(topLeft.y, botRight.y);
            float guiW = Mathf.Abs(botRight.x - topLeft.x);
            float guiH = Mathf.Abs(botRight.y - topLeft.y);

            Color tintColor = text.TextColor;
            tintColor.a = selected ? 1f : 0.7f;

            // If we have a font bitmap, render pixel-perfect from the texture
            if (font != null && font.FontTexture != null && font.SourceFont != null)
            {
                Texture2D fontTex = font.FontTexture;
                int glyphsPerRow = font.GlyphsPerRow;
                int texH = font.TextureHeight;
                float cellScreenW = glyphW * psxPixelScale;
                float cellScreenH = glyphH * psxPixelScale;

                // Get advance widths for proportional positioning
                float cursorX = guiX;
                GUI.color = tintColor;
                foreach (char ch in label)
                {
                    if (ch < 32 || ch > 126) continue;
                    int charIdx = ch - 32;
                    int col = charIdx % glyphsPerRow;
                    int row = charIdx / glyphsPerRow;

                    float advance = glyphW; // fallback
                    if (font.AdvanceWidths != null && charIdx < font.AdvanceWidths.Length)
                    {
                        advance = font.AdvanceWidths[charIdx];
                    }

                    if (ch != ' ')
                    {
                        // UV rect for this glyph in the font bitmap
                        float uvX = (float)(col * glyphW) / fontTex.width;
                        float uvY = 1f - (float)((row + 1) * glyphH) / fontTex.height;
                        float uvW = (float)glyphW / fontTex.width;
                        float uvH = (float)glyphH / fontTex.height;

                        // Draw at advance width, not cell width - matches PS1 proportional rendering
                        float spriteScreenW = advance * psxPixelScale;
                        Rect screenRect = new Rect(cursorX, guiY, spriteScreenW, cellScreenH);
                        // UV: only show the portion of the cell that the advance covers
                        float uvWScaled = uvW * (advance / glyphW);
                        Rect uvRect = new Rect(uvX, uvY, uvWScaled, uvH);

                        if (screenRect.xMax > guiX && screenRect.x < guiX + guiW)
                            GUI.DrawTextureWithTexCoords(screenRect, fontTex, uvRect);
                    }

                    cursorX += advance * psxPixelScale;
                }
                GUI.color = Color.white;
            }
            else
            {
                // Fallback: use Unity's text rendering for system font
                int fSize = Mathf.Clamp(Mathf.RoundToInt(glyphH * psxPixelScale * 0.75f), 6, 72);
                GUIStyle style = new GUIStyle(EditorStyles.label);
                style.normal.textColor = tintColor;
                style.alignment = TextAnchor.UpperLeft;
                style.fontSize = fSize;
                style.wordWrap = false;
                style.clipping = TextClipping.Clip;

                Rect guiRect = new Rect(guiX, guiY, guiW, guiH);
                GUI.color = tintColor;
                GUI.Label(guiRect, label, style);
                GUI.color = Color.white;
            }
            Handles.EndGUI();
        }

        [DrawGizmo(GizmoType.NonSelected | GizmoType.Selected)]
        static void DrawProgressBarGizmo(PSXUIProgressBar bar, GizmoType gizmoType)
        {
            RectTransform rt = bar.GetComponent<RectTransform>();
            if (rt == null) return;
            Vector3[] corners = new Vector3[4];
            rt.GetWorldCorners(corners);

            bool selected = (gizmoType & GizmoType.Selected) != 0;

            // Background
            Color bgColor = bar.BackgroundColor;
            bgColor.a = selected ? 0.8f : 0.5f;
            Handles.DrawSolidRectangleWithOutline(corners, bgColor, Color.white * (selected ? 1f : 0.4f));

            // Fill portion
            float t = bar.InitialValue / 100f;
            if (t > 0.001f)
            {
                Vector3[] fillCorners = new Vector3[4];
                fillCorners[0] = corners[0]; // bottom-left
                fillCorners[1] = corners[1]; // top-left
                fillCorners[2] = Vector3.Lerp(corners[1], corners[2], t); // top-right (partial)
                fillCorners[3] = Vector3.Lerp(corners[0], corners[3], t); // bottom-right (partial)
                Color fillColor = bar.FillColor;
                fillColor.a = selected ? 0.9f : 0.6f;
                Handles.DrawSolidRectangleWithOutline(fillCorners, fillColor, Color.clear);
            }
        }

        [DrawGizmo(GizmoType.NonSelected | GizmoType.Selected)]
        static void DrawCanvasGizmo(PSXCanvas canvas, GizmoType gizmoType)
        {
            RectTransform rt = canvas.GetComponent<RectTransform>();
            if (rt == null) return;
            Vector3[] corners = new Vector3[4];
            rt.GetWorldCorners(corners);
            bool selected = (gizmoType & GizmoType.Selected) != 0;
            Color border = selected ? Color.yellow : new Color(1, 1, 0, 0.3f);
            Handles.DrawSolidRectangleWithOutline(corners, Color.clear, border);

            // Label
            if (selected)
            {
                Vector2 res = PSXCanvas.PSXResolution;
                Vector3 topMid = (corners[1] + corners[2]) * 0.5f;
                string label = $"PSX Canvas: {canvas.CanvasName} ({res.x}x{res.y})";
                GUIStyle style = new GUIStyle(EditorStyles.boldLabel);
                style.normal.textColor = Color.yellow;
                Handles.Label(topMid, label, style);
            }
        }
    }
    /// <summary>
    /// Custom inspector for PSXCanvas component.
    /// Shows canvas name, visibility, sort order, font, and a summary of child elements.
    /// </summary>
    [CustomEditor(typeof(PSXCanvas))]
    public class PSXCanvasEditor : Editor
    {
        public override void OnInspectorGUI()
        {
            serializedObject.Update();

            Vector2 res = PSXCanvas.PSXResolution;

            // Header card
            PSXEditorStyles.BeginCard();
            EditorGUILayout.LabelField($"PSX Canvas ({res.x}x{res.y})", PSXEditorStyles.CardHeaderStyle);
            PSXEditorStyles.EndCard();

            EditorGUILayout.Space(4);

            // Properties card
            PSXEditorStyles.BeginCard();
            EditorGUILayout.PropertyField(serializedObject.FindProperty("canvasName"), new GUIContent("Canvas Name",
                "Name used from Lua: UI.FindCanvas(\"name\"). Max 24 chars."));
            EditorGUILayout.PropertyField(serializedObject.FindProperty("startVisible"), new GUIContent("Start Visible",
                "Whether the canvas is visible when the scene loads."));
            EditorGUILayout.PropertyField(serializedObject.FindProperty("sortOrder"), new GUIContent("Sort Order",
                "Render priority (0 = back, 255 = front)."));
            EditorGUILayout.PropertyField(serializedObject.FindProperty("defaultFont"), new GUIContent("Default Font",
                "Default custom font for text elements. If empty, uses built-in system font (8x16)."));

            PSXEditorStyles.DrawSeparator(6, 6);

            if (GUILayout.Button($"Reset Canvas to {res.x}x{res.y}", PSXEditorStyles.SecondaryButton))
            {
                PSXCanvas.InvalidateResolutionCache();
                ((PSXCanvas)target).ConfigureCanvas();
            }
            PSXEditorStyles.EndCard();

            EditorGUILayout.Space(4);

            // Element summary card
            PSXCanvas canvas = (PSXCanvas)target;
            int imageCount = canvas.GetComponentsInChildren<PSXUIImage>(true).Length;
            int boxCount = canvas.GetComponentsInChildren<PSXUIBox>(true).Length;
            int textCount = canvas.GetComponentsInChildren<PSXUIText>(true).Length;
            int progressCount = canvas.GetComponentsInChildren<PSXUIProgressBar>(true).Length;
            int total = imageCount + boxCount + textCount + progressCount;

            PSXEditorStyles.BeginCard();
            EditorGUILayout.LabelField(
                $"Elements: {total} total\n" +
                $"  Images: {imageCount}  |  Boxes: {boxCount}\n" +
                $"  Texts: {textCount}  |  Progress Bars: {progressCount}",
                PSXEditorStyles.InfoBox);

            if (total > 128)
                EditorGUILayout.LabelField("PS1 UI system supports max 128 elements total across all canvases.", PSXEditorStyles.InfoBox);
            PSXEditorStyles.EndCard();

            serializedObject.ApplyModifiedProperties();
        }
    }

    /// <summary>
    /// Custom inspector for PSXUIImage component.
    /// </summary>
    [CustomEditor(typeof(PSXUIImage))]
    public class PSXUIImageEditor : Editor
    {
        public override void OnInspectorGUI()
        {
            serializedObject.Update();

            // Header card
            PSXEditorStyles.BeginCard();
            EditorGUILayout.LabelField("PSX UI Image", PSXEditorStyles.CardHeaderStyle);
            PSXEditorStyles.EndCard();

            EditorGUILayout.Space(4);

            // Properties card
            PSXEditorStyles.BeginCard();
            EditorGUILayout.PropertyField(serializedObject.FindProperty("elementName"), new GUIContent("Element Name",
                "Name used from Lua: UI.FindElement(canvas, \"name\"). Max 24 chars."));
            EditorGUILayout.PropertyField(serializedObject.FindProperty("sourceTexture"), new GUIContent("Source Texture",
                "Texture to quantize and pack into VRAM."));
            EditorGUILayout.PropertyField(serializedObject.FindProperty("bitDepth"), new GUIContent("Bit Depth",
                "VRAM storage depth. 4-bit = 16 colors, 8-bit = 256 colors, 16-bit = direct color."));
            EditorGUILayout.PropertyField(serializedObject.FindProperty("tintColor"), new GUIContent("Tint Color",
                "Color multiply applied to the image (white = no tint)."));
            EditorGUILayout.PropertyField(serializedObject.FindProperty("startVisible"));
            PSXEditorStyles.EndCard();

            // Texture size warning
            PSXUIImage img = (PSXUIImage)target;
            if (img.SourceTexture != null)
            {
                if (img.SourceTexture.width > 256 || img.SourceTexture.height > 256)
                {
                    EditorGUILayout.Space(4);
                    PSXEditorStyles.BeginCard();
                    EditorGUILayout.LabelField("Texture exceeds 256x256. It will be resized during export.", PSXEditorStyles.InfoBox);
                    PSXEditorStyles.EndCard();
                }
            }

            serializedObject.ApplyModifiedProperties();
        }
    }

    /// <summary>
    /// Custom inspector for PSXUIBox component.
    /// </summary>
    [CustomEditor(typeof(PSXUIBox))]
    public class PSXUIBoxEditor : Editor
    {
        public override void OnInspectorGUI()
        {
            serializedObject.Update();

            // Header card
            PSXEditorStyles.BeginCard();
            EditorGUILayout.LabelField("PSX UI Box", PSXEditorStyles.CardHeaderStyle);
            PSXEditorStyles.EndCard();

            EditorGUILayout.Space(4);

            // Properties card
            PSXEditorStyles.BeginCard();
            EditorGUILayout.PropertyField(serializedObject.FindProperty("elementName"));
            EditorGUILayout.PropertyField(serializedObject.FindProperty("boxColor"), new GUIContent("Box Color",
                "Solid fill color rendered as a FastFill primitive."));
            EditorGUILayout.PropertyField(serializedObject.FindProperty("startVisible"));
            PSXEditorStyles.EndCard();

            serializedObject.ApplyModifiedProperties();
        }
    }

    /// <summary>
    /// Custom inspector for PSXUIText component.
    /// </summary>
    [CustomEditor(typeof(PSXUIText))]
    public class PSXUITextEditor : Editor
    {
        public override void OnInspectorGUI()
        {
            serializedObject.Update();

            // Header card
            PSXEditorStyles.BeginCard();
            EditorGUILayout.LabelField("PSX UI Text", PSXEditorStyles.CardHeaderStyle);
            PSXEditorStyles.EndCard();

            EditorGUILayout.Space(4);

            // Properties card
            PSXEditorStyles.BeginCard();
            EditorGUILayout.PropertyField(serializedObject.FindProperty("elementName"));
            EditorGUILayout.PropertyField(serializedObject.FindProperty("defaultText"), new GUIContent("Default Text",
                "Initial text content. Max 63 chars. Change at runtime via UI.SetText()."));
            EditorGUILayout.PropertyField(serializedObject.FindProperty("textColor"), new GUIContent("Text Color",
                "Text render color."));
            EditorGUILayout.PropertyField(serializedObject.FindProperty("fontOverride"), new GUIContent("Font Override",
                "Custom font for this text element. If empty, uses the canvas default font or built-in system font (8x16)."));
            EditorGUILayout.PropertyField(serializedObject.FindProperty("startVisible"));
            PSXEditorStyles.EndCard();

            EditorGUILayout.Space(4);

            // Warnings and info
            PSXUIText txt = (PSXUIText)target;
            if (!string.IsNullOrEmpty(txt.DefaultText) && txt.DefaultText.Length > 63)
            {
                PSXEditorStyles.BeginCard();
                EditorGUILayout.LabelField("Text exceeds 63 characters and will be truncated.", PSXEditorStyles.InfoBox);
                PSXEditorStyles.EndCard();
                EditorGUILayout.Space(4);
            }

            PSXEditorStyles.BeginCard();
            PSXFontAsset font = txt.GetEffectiveFont();
            if (font != null)
            {
                EditorGUILayout.LabelField(
                    $"Font: {font.name} ({font.GlyphWidth}x{font.GlyphHeight} glyphs)",
                    PSXEditorStyles.InfoBox);
            }
            else
            {
                EditorGUILayout.LabelField("Using built-in system font (8x16 glyphs).", PSXEditorStyles.InfoBox);
            }
            PSXEditorStyles.EndCard();

            serializedObject.ApplyModifiedProperties();
        }
    }

    /// <summary>
    /// Custom inspector for PSXUIProgressBar component.
    /// </summary>
    [CustomEditor(typeof(PSXUIProgressBar))]
    public class PSXUIProgressBarEditor : Editor
    {
        public override void OnInspectorGUI()
        {
            serializedObject.Update();

            // Header card
            PSXEditorStyles.BeginCard();
            EditorGUILayout.LabelField("PSX UI Progress Bar", PSXEditorStyles.CardHeaderStyle);
            PSXEditorStyles.EndCard();

            EditorGUILayout.Space(4);

            // Properties card
            PSXEditorStyles.BeginCard();
            EditorGUILayout.PropertyField(serializedObject.FindProperty("elementName"));
            EditorGUILayout.PropertyField(serializedObject.FindProperty("backgroundColor"), new GUIContent("Background Color",
                "Color shown behind the fill bar."));
            EditorGUILayout.PropertyField(serializedObject.FindProperty("fillColor"), new GUIContent("Fill Color",
                "Color of the progress fill."));
            EditorGUILayout.PropertyField(serializedObject.FindProperty("initialValue"), new GUIContent("Initial Value",
                "Starting progress (0-100). Change via UI.SetProgress()."));
            EditorGUILayout.PropertyField(serializedObject.FindProperty("startVisible"));

            PSXEditorStyles.DrawSeparator(6, 4);

            // Preview bar
            PSXUIProgressBar bar = (PSXUIProgressBar)target;
            PSXEditorStyles.DrawProgressBar(bar.InitialValue / 100f, "Preview", bar.FillColor, 16);
            PSXEditorStyles.EndCard();

            serializedObject.ApplyModifiedProperties();
        }
    }

    /// <summary>
    /// Custom inspector for PSXFontAsset ScriptableObject.
    /// Shows font metrics, auto-conversion from TTF/OTF, and a preview of the glyph layout.
    /// </summary>
    [CustomEditor(typeof(PSXFontAsset))]
    public class PSXFontAssetEditor : Editor
    {
        public override void OnInspectorGUI()
        {
            serializedObject.Update();

            PSXFontAsset font = (PSXFontAsset)target;

            // Header card
            PSXEditorStyles.BeginCard();
            EditorGUILayout.LabelField("PSX Font Asset", PSXEditorStyles.CardHeaderStyle);
            PSXEditorStyles.EndCard();

            EditorGUILayout.Space(4);

            // Source font card
            PSXEditorStyles.BeginCard();
            EditorGUILayout.LabelField("Auto-Convert from Font", PSXEditorStyles.CardHeaderStyle);
            PSXEditorStyles.DrawSeparator(2, 4);

            EditorGUILayout.PropertyField(serializedObject.FindProperty("sourceFont"), new GUIContent("Source Font (TTF/OTF)",
                "Assign a Unity Font (TrueType/OpenType). Click 'Generate Bitmap' to rasterize it.\n" +
                "Glyph cell dimensions are auto-derived from the font metrics."));
            EditorGUILayout.PropertyField(serializedObject.FindProperty("fontSize"), new GUIContent("Font Size",
                "Pixel height for rasterization. Determines glyph cell height.\n" +
                "Glyph cell width is auto-derived from the widest character.\n" +
                "Changing this and re-generating will update both the bitmap AND the glyph dimensions."));

            if (font.SourceFont != null)
            {
                EditorGUILayout.Space(2);
                if (GUILayout.Button("Generate Bitmap from Font", PSXEditorStyles.PrimaryButton, GUILayout.Height(28)))
                {
                    Undo.RecordObject(font, "Generate PSX Font Bitmap");
                    font.GenerateBitmapFromFont();
                }

                if (font.FontTexture == null)
                    EditorGUILayout.LabelField(
                        "Click 'Generate Bitmap' to create the font texture.\n" +
                        "If generation fails, check that the font's import settings have " +
                        "'Character' set to 'ASCII Default Set'.", PSXEditorStyles.InfoBox);
            }
            PSXEditorStyles.EndCard();

            EditorGUILayout.Space(4);

            // Manual bitmap card
            PSXEditorStyles.BeginCard();
            EditorGUILayout.LabelField("Manual Bitmap Source", PSXEditorStyles.CardHeaderStyle);
            PSXEditorStyles.DrawSeparator(2, 4);

            EditorGUILayout.PropertyField(serializedObject.FindProperty("fontTexture"), new GUIContent("Font Texture",
                "256px wide bitmap. Glyphs in ASCII order from 0x20 (space). " +
                "Transparent = background, opaque = foreground."));
            PSXEditorStyles.EndCard();

            EditorGUILayout.Space(4);

            // Glyph metrics card
            PSXEditorStyles.BeginCard();
            EditorGUILayout.LabelField("Glyph Metrics", PSXEditorStyles.CardHeaderStyle);
            PSXEditorStyles.DrawSeparator(2, 4);

            if (font.SourceFont != null && font.FontTexture != null)
            {
                EditorGUI.BeginDisabledGroup(true);
                EditorGUILayout.IntField(new GUIContent("Glyph Width", "Auto-derived from font. Re-generate to change."), font.GlyphWidth);
                EditorGUILayout.IntField(new GUIContent("Glyph Height", "Auto-derived from font. Re-generate to change."), font.GlyphHeight);
                EditorGUI.EndDisabledGroup();
                EditorGUILayout.LabelField("Glyph dimensions are auto-derived when generating from a font.\n" +
                                        "Change the Font Size slider and re-generate to adjust.", PSXEditorStyles.InfoBox);
            }
            else
            {
                EditorGUILayout.PropertyField(serializedObject.FindProperty("glyphWidth"), new GUIContent("Glyph Width",
                    "Width of each glyph cell in pixels. Must divide 256 evenly (4, 8, 16, or 32)."));
                EditorGUILayout.PropertyField(serializedObject.FindProperty("glyphHeight"), new GUIContent("Glyph Height",
                    "Height of each glyph cell in pixels."));
            }
            PSXEditorStyles.EndCard();

            EditorGUILayout.Space(4);

            // Layout info card
            PSXEditorStyles.BeginCard();
            int glyphsPerRow = font.GlyphsPerRow;
            int rowCount = font.RowCount;
            int totalH = font.TextureHeight;
            int vramBytes = totalH * 128;

            EditorGUILayout.LabelField(
                $"Layout: {glyphsPerRow} glyphs/row, {rowCount} rows\n" +
                $"Texture: 256 x {totalH} pixels (4bpp)\n" +
                $"VRAM: {vramBytes} bytes ({vramBytes / 1024f:F1} KB)\n" +
                $"Glyph cell: {font.GlyphWidth} x {font.GlyphHeight}",
                PSXEditorStyles.InfoBox);

            if (font.AdvanceWidths != null && font.AdvanceWidths.Length >= 95)
            {
                int minAdv = 255, maxAdv = 0;
                for (int i = 1; i < 95; i++)
                {
                    if (font.AdvanceWidths[i] < minAdv) minAdv = font.AdvanceWidths[i];
                    if (font.AdvanceWidths[i] > maxAdv) maxAdv = font.AdvanceWidths[i];
                }
                EditorGUILayout.LabelField(
                    $"Advance widths: {minAdv}-{maxAdv}px (proportional spacing stored)",
                    PSXEditorStyles.InfoBox);
            }
            else if (font.FontTexture != null)
            {
                EditorGUILayout.LabelField(
                    "No advance widths stored. Click 'Generate Bitmap' to compute them.",
                    PSXEditorStyles.InfoBox);
            }
            PSXEditorStyles.EndCard();

            // Validation
            if (font.FontTexture != null)
            {
                if (font.FontTexture.width != 256)
                {
                    EditorGUILayout.Space(4);
                    PSXEditorStyles.BeginCard();
                    EditorGUILayout.LabelField($"Font texture must be 256 pixels wide (currently {font.FontTexture.width}).", PSXEditorStyles.InfoBox);
                    PSXEditorStyles.EndCard();
                }

                if (256 % font.GlyphWidth != 0)
                {
                    EditorGUILayout.Space(4);
                    PSXEditorStyles.BeginCard();
                    EditorGUILayout.LabelField($"Glyph width ({font.GlyphWidth}) must divide 256 evenly. " +
                                            "Valid values: 4, 8, 16, 32.", PSXEditorStyles.InfoBox);
                    PSXEditorStyles.EndCard();
                }

                // Preview
                EditorGUILayout.Space(4);
                PSXEditorStyles.BeginCard();
                EditorGUILayout.LabelField("Preview", PSXEditorStyles.CardHeaderStyle);
                PSXEditorStyles.DrawSeparator(2, 4);
                Rect previewRect = EditorGUILayout.GetControlRect(false, 64);
                GUI.DrawTexture(previewRect, font.FontTexture, ScaleMode.ScaleToFit);
                PSXEditorStyles.EndCard();
            }

            serializedObject.ApplyModifiedProperties();
        }
    }
}