using System;
using System.Collections.Generic;
using System.IO;
using Uigenx.Protocol;
using UnityEngine;

namespace Uigenx.Editor
{
    /// <summary>
    /// The on disk twin of `sync.bundle.manifest`, written by `ugx export --to unity`. It exists so
    /// an export with no daemon running still produces a working registry: CI, a teammate who was
    /// handed the files, and the first export before anyone starts the studio.
    /// </summary>
    /// <remarks>
    /// The screen, action and panel shapes are the protocol types, so the file and the wire can
    /// never drift apart. Only <see cref="SchemaVersion"/> is extra.
    /// </remarks>
    public sealed class UgxManifestFile
    {
        public const string FileName = "ugx-manifest.json";

        /// <summary>Bumped only when the file shape changes incompatibly.</summary>
        public const int SupportedSchemaVersion = 1;

        public int SchemaVersion { get; set; } = SupportedSchemaVersion;

        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 static string PathFor(string assetsUiFolder)
            => (assetsUiFolder ?? string.Empty).TrimEnd('/') + "/Generated/" + FileName;

        public static bool Exists(string assetsUiFolder) => File.Exists(PathFor(assetsUiFolder));

        /// <summary>
        /// Reads the manifest. Returns false with a message the caller can log rather than throwing,
        /// because a missing file is the normal state in a project that only ever syncs live.
        /// </summary>
        public static bool TryLoad(string assetsUiFolder, out UgxManifestFile manifest, out string problem)
        {
            manifest = null;
            var path = PathFor(assetsUiFolder);

            if (!File.Exists(path))
            {
                problem = "no manifest at " + path;
                return false;
            }

            try
            {
                manifest = UgxJson.Deserialize<UgxManifestFile>(File.ReadAllText(path));
            }
            catch (Exception e)
            {
                problem = path + " is not readable: " + e.Message;
                return false;
            }

            if (manifest == null)
            {
                problem = path + " is empty";
                return false;
            }
            if (manifest.SchemaVersion > SupportedSchemaVersion)
            {
                problem = path + " is schema version " + manifest.SchemaVersion + " but this package " +
                          "understands " + SupportedSchemaVersion + ". Update com.uigenx.runtime.";
                manifest = null;
                return false;
            }

            manifest.Screens = manifest.Screens ?? new List<UgxManifestScreen>();
            manifest.Actions = manifest.Actions ?? new List<UgxManifestAction>();
            manifest.Panels = manifest.Panels ?? new List<UgxManifestPanel>();
            manifest.Fonts = manifest.Fonts ?? new List<UgxManifestFont>();
            problem = null;
            return true;
        }

        public UgxBundleManifest ToManifest()
            => new UgxBundleManifest
            {
                Screens = Screens ?? new List<UgxManifestScreen>(),
                Actions = Actions ?? new List<UgxManifestAction>(),
                Panels = Panels ?? new List<UgxManifestPanel>(),
                Fonts = Fonts ?? new List<UgxManifestFont>(),
            };

        /// <summary>Writes the file. Used by tests and by anything that wants to seed a project.</summary>
        public void Save(string assetsUiFolder)
        {
            var path = PathFor(assetsUiFolder);
            Directory.CreateDirectory(Path.GetDirectoryName(path) ?? assetsUiFolder);
            File.WriteAllText(path, UgxJson.Serialize(this) + "\n");
        }
    }

    /// <summary>
    /// Rebuilds the registry whenever the manifest lands in the project, so dropping an offline
    /// export into `Assets/` is enough. Without this the files import but nothing registers.
    /// </summary>
    public sealed class UgxManifestPostprocessor : UnityEditor.AssetPostprocessor
    {
        static bool _pending;

        static void OnPostprocessAllAssets(string[] imported, string[] deleted, string[] moved,
            string[] movedFrom)
        {
            var folder = UgxProjectSettings.Load().AssetsUiFolder;
            var manifestPath = UgxManifestFile.PathFor(folder);

            if (!Mentions(imported, manifestPath) && !Mentions(moved, manifestPath)) return;
            if (_pending) return;

            _pending = true;

            // A batch run quits before delayCall is ever pumped, so a headless export would import
            // the manifest and register nothing, which is the whole point of the offline path.
            // Building here is safe: this callback only fires for the manifest, and nothing it
            // writes is the manifest.
            if (Application.isBatchMode)
            {
                _pending = false;
                Build(folder);
                return;
            }

            // Deferred: writing the registry asset from inside an import callback re-enters the
            // asset pipeline.
            UnityEditor.EditorApplication.delayCall += () =>
            {
                _pending = false;
                Build(folder);
            };
        }

        static void Build(string folder)
        {
            UgxScreenRegistryBuilder.RebuildFromDisk(folder);
            foreach (var warning in UgxFontAssetBuilder.BuildFromDisk(folder).Warnings)
                Debug.LogWarning("[ugx] " + warning);
        }

        static bool Mentions(string[] paths, string target)
        {
            if (paths == null) return false;
            for (int i = 0; i < paths.Length; i++)
                if (string.Equals(paths[i], target, StringComparison.Ordinal))
                    return true;
            return false;
        }
    }
}