using System.Collections.Generic;
using System.Runtime.Serialization;

namespace Uigenx.Protocol
{
    public enum UgxFileKind
    {
        [EnumMember(Value = "uxml")] Uxml,
        [EnumMember(Value = "uss")] Uss,
        [EnumMember(Value = "tss")] Tss,
        [EnumMember(Value = "cs")] Cs,
        [EnumMember(Value = "png")] Png,
        [EnumMember(Value = "asset")] Asset,
        [EnumMember(Value = "json")] Json,
        [EnumMember(Value = "shader")] Shader,
        [EnumMember(Value = "mat")] Mat,
    }

    public enum UgxTextureType
    {
        [EnumMember(Value = "Sprite")] Sprite,
        [EnumMember(Value = "Default")] Default,
    }

    public enum UgxSpriteMode
    {
        [EnumMember(Value = "Single")] Single,
        [EnumMember(Value = "Multiple")] Multiple,
    }

    public enum UgxFilterMode
    {
        [EnumMember(Value = "Point")] Point,
        [EnumMember(Value = "Bilinear")] Bilinear,
        [EnumMember(Value = "Trilinear")] Trilinear,
    }

    public enum UgxMeshType
    {
        [EnumMember(Value = "Tight")] Tight,
        [EnumMember(Value = "FullRect")] FullRect,
    }

    public sealed class UgxTextureImportSettings
    {
        public UgxTextureType TextureType { get; set; } = UgxTextureType.Sprite;
        public UgxSpriteMode SpriteMode { get; set; } = UgxSpriteMode.Single;
        public float PixelsPerUnit { get; set; } = 100f;
        public UgxFilterMode FilterMode { get; set; } = UgxFilterMode.Bilinear;

        /// <summary>Left, bottom, right, top, matching Unity's spriteBorder vector.</summary>
        public float[] SpriteBorder { get; set; }

        public UgxMeshType MeshType { get; set; } = UgxMeshType.FullRect;
        public bool Mipmaps { get; set; }
        public bool AlphaIsTransparency { get; set; } = true;
        public int MaxSize { get; set; } = 2048;
    }

    public sealed class UgxBundleFile
    {
        /// <summary>Path relative to the Unity UI folder.</summary>
        public string Path { get; set; } = string.Empty;

        public string Sha256 { get; set; } = string.Empty;
        public UgxFileKind Kind { get; set; }

        /// <summary>Base64 content, omitted when the file was streamed with sync.file first.</summary>
        public string Content { get; set; }

        public string Guid { get; set; }

        /// <summary>True when the compiler owns the file and rewrites it on every export.</summary>
        public bool Generated { get; set; } = true;
    }

    public sealed class UgxBundleAsset
    {
        public string Path { get; set; } = string.Empty;
        public UgxTextureImportSettings Importer { get; set; } = new UgxTextureImportSettings();
    }

    public sealed class UgxBundleMaterial
    {
        public string Path { get; set; } = string.Empty;
        public string Shader { get; set; } = string.Empty;
        public Dictionary<string, object> Properties { get; set; } = new Dictionary<string, object>();
    }

    public sealed class UgxFilterParameter
    {
        public string Name { get; set; } = string.Empty;

        /// <summary>`float` or `color`.</summary>
        public string Type { get; set; } = "float";

        public object Default { get; set; }
    }

    public sealed class UgxBundleFilter
    {
        public string Path { get; set; } = string.Empty;
        public string Shader { get; set; } = string.Empty;
        public List<UgxFilterParameter> Parameters { get; set; } = new List<UgxFilterParameter>();
    }

    public sealed class UgxManifestScreen
    {
        public string Key { get; set; } = string.Empty;
        public string Uxml { get; set; } = string.Empty;
        public string ClassName { get; set; } = string.Empty;
        public string Layer { get; set; } = string.Empty;
    }

    public sealed class UgxManifestAction
    {
        public string Name { get; set; } = string.Empty;
        public Dictionary<string, string> Payload { get; set; } = new Dictionary<string, string>();
    }

    /// <summary>
    /// A PanelSettings asset the editor package creates or updates on import. Unity owns the asset,
    /// so the export carries the settings rather than a `.asset` file it would have to write itself.
    /// </summary>
    public sealed class UgxManifestPanel
    {
        public string Name { get; set; } = string.Empty;

        /// <summary>Where the asset goes, relative to the UI folder.</summary>
        public string Path { get; set; } = string.Empty;

        public float SortOrder { get; set; }

        /// <summary>`constant-pixel-size`, `constant-physical-size` or `scale-with-screen-size`.</summary>
        public string ScaleMode { get; set; } = "scale-with-screen-size";

        public float Scale { get; set; } = 1f;

        public float ReferenceDpi { get; set; } = 96f;

        public float FallbackDpi { get; set; } = 96f;

        /// <summary>Width and height the UI was designed against.</summary>
        public int[] ReferenceResolution { get; set; } = { 1920, 1080 };

        /// <summary>`width-or-height`, `shrink` or `expand`.</summary>
        public string ScreenMatchMode { get; set; } = "width-or-height";

        /// <summary>0 follows the width, 1 follows the height.</summary>
        public float Match { get; set; } = 0.5f;

        public float ReferenceSpritePixelsPerUnit { get; set; } = 100f;

        /// <summary>Theme stylesheet relative to the UI folder, or empty for the engine's own.</summary>
        public string Theme { get; set; } = string.Empty;
    }

    /// <summary>
    /// A FontAsset the editor package bakes on import. The compiler cannot render an SDF atlas,
    /// only Unity's own text engine can, so the export carries the recipe instead of the artefact.
    /// </summary>
    public sealed class UgxManifestFont
    {
        /// <summary>The font file the atlas is rendered from, relative to the UI folder.</summary>
        public string Source { get; set; } = string.Empty;

        /// <summary>Where the generated FontAsset goes, relative to the UI folder.</summary>
        public string Path { get; set; } = string.Empty;

        public string Guid { get; set; } = string.Empty;
        public string RenderMode { get; set; } = "SDFAA";
        public int SamplingPointSize { get; set; } = 90;
        public int AtlasSize { get; set; } = 1024;
        public int Padding { get; set; } = 9;
    }

    public sealed class UgxBundleManifest
    {
        public List<UgxManifestScreen> Screens { get; set; } = new List<UgxManifestScreen>();
        public List<UgxManifestAction> Actions { get; set; } = new List<UgxManifestAction>();
        public List<UgxManifestPanel> Panels { get; set; } = new List<UgxManifestPanel>();
        public List<UgxManifestFont> Fonts { get; set; } = new List<UgxManifestFont>();
    }

    public sealed class UgxSyncBundle
    {
        public string BundleId { get; set; } = string.Empty;
        public long GeneratedAt { get; set; }
        public List<UgxBundleFile> Files { get; set; } = new List<UgxBundleFile>();
        public List<UgxBundleAsset> Assets { get; set; } = new List<UgxBundleAsset>();
        public List<UgxBundleMaterial> Materials { get; set; } = new List<UgxBundleMaterial>();
        public List<UgxBundleFilter> Filters { get; set; } = new List<UgxBundleFilter>();
        public List<string> Deletions { get; set; } = new List<string>();
        public UgxBundleManifest Manifest { get; set; } = new UgxBundleManifest();
    }

    public sealed class UgxSyncFileChunk
    {
        public string Sha256 { get; set; } = string.Empty;
        public int Index { get; set; }
        public int Total { get; set; }
        public string Chunk { get; set; } = string.Empty;
    }

    public sealed class UgxImportedFile
    {
        public string Path { get; set; } = string.Empty;
        public string Guid { get; set; } = string.Empty;
    }

    public sealed class UgxSyncResult
    {
        public string BundleId { get; set; } = string.Empty;
        public List<UgxImportedFile> Imported { get; set; } = new List<UgxImportedFile>();
        public List<string> Warnings { get; set; } = new List<string>();
        public double DurationMs { get; set; }
    }

    public sealed class UgxCompileRequest
    {
        public string RequestId { get; set; } = string.Empty;
    }

    public sealed class UgxCompileDiagnostic
    {
        public string File { get; set; } = string.Empty;
        public int Line { get; set; }
        public int Column { get; set; }
        public string Code { get; set; } = string.Empty;
        public string Message { get; set; } = string.Empty;
    }

    public sealed class UgxCompileResult
    {
        public string RequestId { get; set; }
        public bool Ok { get; set; }
        public List<UgxCompileDiagnostic> Errors { get; set; } = new List<UgxCompileDiagnostic>();
        public List<UgxCompileDiagnostic> Warnings { get; set; } = new List<UgxCompileDiagnostic>();
        public double DurationMs { get; set; }
    }
}