#nullable enable
using System;
using System.Collections.Generic;
using System.Linq;
using Cysharp.Threading.Tasks;

namespace ShrinkContext
{
    /// <summary>
    /// Cordis 核心原型运行时：纤程注册表 + 共享余效应存储 + 惯性生命周期状态机
    /// （论文算法 2-5 的 C#/UniTask 移植）。
    ///
    /// 约定：
    /// - 仅在主线程使用；
    /// - 异步转换在同步可完成路径上内联跑完（无需 PlayerLoop 泵即可确定性测试）；
    /// - 目标（Target）以提供者 uid 集合表示，uid 永不复用，因此“同值不同提供者”的替换也会触发重载。
    /// </summary>
    public sealed class ShrinkContextRuntime
    {
        private readonly ShrinkCtx _rootCtx;
        private readonly List<ShrinkFiber> _fibers = new();
        private readonly Dictionary<string, ShrinkBinding> _store = new();
        private long _uidCounter;

        public ShrinkContextRuntime()
        {
            _rootCtx = new ShrinkCtx(this, null, null, null);
        }

        public ShrinkCtx RootContext => _rootCtx;

        public IReadOnlyList<ShrinkFiber> Fibers => _fibers;

        // ---------------- 实例化（论文算法 4） ----------------

        /// <summary>
        /// 实例化组件为纤程：在父上下文（默认根上下文）上注册一个可逆效应，
        /// 前向 = 启动子纤程生命周期，逆 = 强制子纤程目标为 ⊥ 并卸载——父卸载自动级联子卸载。
        /// isolate 为该纤程自身的键解析叠加隔离域（不影响父上下文）。
        /// </summary>
        public ShrinkFiber Use(IShrinkComponent component, object? config = null, ShrinkCtx? parentCtx = null,
            IReadOnlyDictionary<string, string>? isolate = null)
        {
            if (component == null)
                throw new ArgumentNullException(nameof(component));

            var parent = parentCtx ?? _rootCtx;
            var fiber = new ShrinkFiber(++_uidCounter, component, parent.OwnerFiber, config);
            var fiberCtx = parent.CreateChildForFiber(fiber);
            if (isolate != null && isolate.Count > 0)
                fiberCtx = fiberCtx.WithIsolate(isolate);
            fiber.Ctx = fiberCtx;
            _fibers.Add(fiber);

            var instantiationHandle = new ShrinkEffectHandle();
            instantiationHandle.AttachInverse(() => RetireCoreAsync(fiber));
            parent.Attach(instantiationHandle);

            Refresh(fiber);
            return fiber;
        }

        /// <summary>
        /// 退役并卸载纤程（论文 O-Retire）：目标强制 ⊥，等待纤程到达静止态。
        /// 退役是永久的：之后不再参与依赖通知。
        /// </summary>
        public async UniTask RetireAsync(ShrinkFiber fiber)
        {
            if (fiber.Retired)
                return;
            if (fiber.State == ShrinkFiberState.Inactive && !fiber.InTransition)
            {
                fiber.Retired = true;
                return;
            }

            fiber.Retired = true;
            fiber.Target = null;
            if (!fiber.InTransition)
            {
                fiber.InTransition = true;
                fiber.Inertia = RunTransitionAsync(fiber);
            }

            if (fiber.InTransition)
                await fiber.Inertia;
        }

        /// <summary>卸载全部纤程并回滚根上下文效应。</summary>
        public async UniTask ShutdownAsync()
        {
            foreach (var fiber in _fibers.ToArray())
                await RetireAsync(fiber);
            await _rootCtx.DisposeAsync();
        }

        // ---------------- 生命周期（论文算法 5） ----------------

        /// <summary>
        /// 重算目标：任一依赖键不可解析 → ⊥；否则为全部提供者 uid 的有序集合。
        /// 目标变化即启动（或在惯性边界链式触发）reload / unload 转换。
        /// </summary>
        internal bool Refresh(ShrinkFiber fiber)
        {
            if (fiber.Retired)
                return false;

            var target = ComputeTarget(fiber);
            if (TargetEquals(fiber.Target, target))
                return false;

            fiber.Target = target;
            if (!fiber.InTransition)
            {
                fiber.InTransition = true;
                fiber.Inertia = RunTransitionAsync(fiber);
            }

            return true;
        }

        private async UniTask RunTransitionAsync(ShrinkFiber fiber)
        {
            try
            {
                while (true)
                {
                    if (fiber.Target is null)
                    {
                        // L-Leave：先停止供给（状态置 Unloading），再调度任何逆操作
                        fiber.State = ShrinkFiberState.Unloading;
                        await UnloadCoreAsync(fiber);
                        if (fiber.Target is null)
                        {
                            fiber.State = ShrinkFiberState.Inactive;
                            return;
                        }

                        // 卸载中途目标恢复 → 链式重载（惯性）
                        continue;
                    }

                    fiber.State = ShrinkFiberState.Loading;
                    var stable = await ReloadCoreAsync(fiber);
                    if (stable)
                    {
                        fiber.State = ShrinkFiberState.Active;
                        fiber.EverActive = true;
                        fiber.LastError = null;
                        Notify(fiber.Ctx, fiber.Component.Provide);
                        return;
                    }

                    // 装载中途目标变化（⊥ 或换提供者）→ 链式卸载（惯性）
                }
            }
            finally
            {
                fiber.InTransition = false;
            }
        }

        private async UniTask<bool> ReloadCoreAsync(ShrinkFiber fiber)
        {
            var target0 = fiber.Target!;
            // 提交视图：装载期间（含自身卸载过程）读取同一份绑定（定理 63）
            fiber._committed = ResolveView(fiber);

            try
            {
                if (fiber.Component is IShrinkIterativeComponent iterative)
                {
                    var stepper = iterative.ApplySteps(fiber.Ctx, fiber.Config);
                    // 守卫在每步步进边界检查目标稳定性（算法 1 的 guard 循环）
                    while (TargetEquals(fiber.Target, target0))
                    {
                        if (!await stepper.MoveNextAsync())
                            break;

                        var handle = new ShrinkEffectHandle();
                        handle.AttachInverse(stepper.Current);
                        fiber.Ctx.Attach(handle);
                    }
                }
                else
                {
                    await fiber.Component.ApplyAsync(fiber.Ctx, fiber.Config);
                }
            }
            catch (Exception ex)
            {
                // L-Raise：记录错误并强制走卸载路径，回收已执行的部分效应
                fiber.LastError = ex;
                fiber.Target = null;
                return false;
            }

            return TargetEquals(fiber.Target, target0);
        }

        private async UniTask UnloadCoreAsync(ShrinkFiber fiber)
        {
            // 先通知依赖者并等待它们到达静止态（drain），再运行自身的逆操作（L-Unload 守卫）
            var affected = Notify(fiber.Ctx, fiber.Component.Provide);
            foreach (var dependent in affected)
            {
                if (dependent.InTransition)
                    await dependent.Inertia;
            }

            await fiber.Ctx.DisposeAsync();
            // 卸载完成后才丢弃提交视图，保证自身拆除期间仍可读取依赖
            fiber._committed = null;
        }

        // ---------------- 通知（论文算法 3） ----------------

        /// <summary>
        /// 将键变更传播给声明了该键、且 realm 解析一致的依赖纤程；
        /// 返回本次被触发刷新的纤程（供卸载方等待）。
        /// </summary>
        internal IReadOnlyList<ShrinkFiber> Notify(ShrinkCtx sourceCtx, IReadOnlyCollection<string> keys)
        {
            var affected = new List<ShrinkFiber>();
            foreach (var fiber in _fibers.ToArray())
            {
                foreach (var key in keys)
                {
                    if (!fiber.InjectSet.Contains(key))
                        continue;
                    if (fiber.Ctx.ResolveRealm(key) != sourceCtx.ResolveRealm(key))
                        continue;

                    if (Refresh(fiber))
                        affected.Add(fiber);
                    break;
                }
            }

            return affected;
        }

        // ---------------- 余效应存储（论文算法 2） ----------------

        internal ShrinkEffectHandle SetBinding(ShrinkCtx ctx, string key, object? value)
        {
            var realm = ctx.ResolveRealm(key);
            var setter = ctx.OwnerFiber;

            InstallBinding(realm, key, value, setter, ctx);

            var handle = new ShrinkEffectHandle();
            handle.AttachInverse(() =>
            {
                RemoveBinding(realm, key, setter, ctx);
                return UniTask.CompletedTask;
            });
            ctx.Attach(handle);
            return handle;
        }

        private void InstallBinding(string realm, string key, object? value, ShrinkFiber? setter, ShrinkCtx ctx)
        {
            if (_store.TryGetValue(realm, out var existing) && !IsTakeoverAllowed(existing, setter))
                throw new ShrinkSupplyConflictException(key, existing.Provider, setter);

            _store[realm] = new ShrinkBinding(value, setter, key);
            Notify(ctx, new[] { key });
        }

        private void RemoveBinding(string realm, string key, ShrinkFiber? setter, ShrinkCtx ctx)
        {
            // 只撤回仍归属本设置者的绑定，不误删后继提供者
            if (_store.TryGetValue(realm, out var current) && current.Provider == setter)
                _store.Remove(realm);
            Notify(ctx, new[] { key });
        }

        private static bool IsTakeoverAllowed(ShrinkBinding existing, ShrinkFiber? setter)
        {
            if (existing.Provider == null || existing.Provider == setter)
                return true;

            var state = existing.Provider.State;
            return state == ShrinkFiberState.Unloading || state == ShrinkFiberState.Inactive;
        }

        /// <summary>解析绑定：realm 不存在、或提供者非 Active（正在装载/卸载/失活）时视为不可用。</summary>
        internal ShrinkBinding? ResolveBinding(ShrinkCtx ctx, string key)
        {
            var realm = ctx.ResolveRealm(key);
            if (!_store.TryGetValue(realm, out var binding))
                return null;

            if (binding.Provider != null && binding.Provider.State != ShrinkFiberState.Active)
                return null;

            return binding;
        }

        /// <summary>绕过介导规则的原始查找（编排层/测试用）：active 提供者或无主绑定才命中。</summary>
        public bool TryGetRaw<T>(ShrinkCtx ctx, string key, out T value)
        {
            value = default!;
            var binding = ResolveBinding(ctx, key);
            if (binding == null)
                return false;

            value = (T)binding.Value!;
            return true;
        }

        // ---------------- 目标计算 ----------------

        private long[]? ComputeTarget(ShrinkFiber fiber)
        {
            var uids = new List<long>();
            foreach (var key in fiber.Component.Inject)
            {
                var binding = ResolveBinding(fiber.Ctx, key);
                if (binding == null)
                    return null;
                uids.Add(binding.Provider?.Uid ?? 0);
            }

            return uids.Distinct().OrderBy(uid => uid).ToArray();
        }

        private Dictionary<string, ShrinkBinding> ResolveView(ShrinkFiber fiber)
        {
            var view = new Dictionary<string, ShrinkBinding>();
            foreach (var key in fiber.Component.Inject)
            {
                var binding = ResolveBinding(fiber.Ctx, key);
                if (binding != null)
                    view[key] = binding;
            }

            return view;
        }

        private static bool TargetEquals(long[]? a, long[]? b)
        {
            if (a == null || b == null)
                return a == null && b == null;
            if (a.Length != b.Length)
                return false;

            for (var i = 0; i < a.Length; i++)
            {
                if (a[i] != b[i])
                    return false;
            }

            return true;
        }

        private async UniTask RetireCoreAsync(ShrinkFiber fiber)
        {
            if (fiber.Retired)
                return;
            await RetireAsync(fiber);
        }
    }
}