using System;
using System.Threading;
using System.Threading.Tasks;
using Aging.Infrastructure.Contracts;
using Aging.Infrastructure.Core;
using Aging.ResourceContracts;
using log4net;

namespace Aging.Infrastructure.Services
{
    /// <summary>
    /// 自动化设备门面实现。
    /// 
    /// 生命周期：
    ///   1) ReserveAsync 申请资源占用 → 得到 ResourceOwnerToken
    ///   2) DeviceService 分派命令 → 内部再拿操作租约
    ///   3) ReleaseReservationAsync 释放资源
    /// 
    /// 两种调用模式：
    ///   - ExecuteAsync/QueryAsync：一次性执行（内部完成 1→2→3）
    ///   - AcquireAsync：作用域租约（1 手动触发；3 在 lease.Dispose 时触发；2 可多次）
    /// </summary>
    public sealed class AutoDeviceFacade : IAutoDeviceFacade
    {
        private static readonly ILog Log = LogManager.GetLogger(typeof(AutoDeviceFacade));

        private readonly IResourceManager _resourceManager;
        private readonly IDeviceService _deviceService;

        /// <summary>
        /// 默认租约申请超时（秒）
        /// </summary>
        public int DefaultLeaseTimeoutSeconds { get; set; } = 30;

        /// <summary>
        /// 构造函数
        /// </summary>
        public AutoDeviceFacade(IResourceManager resourceManager, IDeviceService deviceService)
        {
            _resourceManager = resourceManager ?? throw new ArgumentNullException(nameof(resourceManager));
            _deviceService = deviceService ?? throw new ArgumentNullException(nameof(deviceService));
        }

        // ==================== 一次性执行模式 ====================

        /// <inheritdoc/>
        public async Task<DeviceCommandResult> ExecuteAsync(
            string deviceId, string command, CancellationToken ct = default)
        {
            if (string.IsNullOrWhiteSpace(deviceId))
                throw new ArgumentException("设备 ID 不能为空", nameof(deviceId));
            if (string.IsNullOrWhiteSpace(command))
                throw new ArgumentException("命令不能为空", nameof(command));

            // 1. 申请资源占用
            var owner = await ReserveCoreAsync(deviceId, "OneShot", ct).ConfigureAwait(false);
            try
            {
                // 2. 通过 DeviceService 分派命令
                return await _deviceService.ExecuteCommandAsync(deviceId, command, owner, ct)
                    .ConfigureAwait(false);
            }
            finally
            {
                // 3. 无论成功失败都释放资源
                await ReleaseCoreAsync(deviceId, owner).ConfigureAwait(false);
            }
        }

        /// <inheritdoc/>
        public async Task<DeviceCommandResult> QueryAsync(
            string deviceId, string query, CancellationToken ct = default)
        {
            if (string.IsNullOrWhiteSpace(deviceId))
                throw new ArgumentException("设备 ID 不能为空", nameof(deviceId));

            var owner = await ReserveCoreAsync(deviceId, "OneShotQuery", ct).ConfigureAwait(false);
            try
            {
                return await _deviceService.ExecuteQueryAsync(deviceId, query, owner, ct)
                    .ConfigureAwait(false);
            }
            finally
            {
                await ReleaseCoreAsync(deviceId, owner).ConfigureAwait(false);
            }
        }

        // ==================== 作用域租约模式 ====================

        /// <inheritdoc/>
        public async Task<IAutoDeviceLease> AcquireAsync(
            string deviceId, string stepName, CancellationToken ct = default)
        {
            if (string.IsNullOrWhiteSpace(deviceId))
                throw new ArgumentException("设备 ID 不能为空", nameof(deviceId));

            var owner = await ReserveCoreAsync(deviceId, stepName ?? "Step", ct).ConfigureAwait(false);
            var sessionId = Guid.NewGuid().ToString();

            Log.Info($"[AutoFacade] 设备 {deviceId} 已获得作用域租约: Session={sessionId.Substring(0, 8)}, Step={stepName}");

            var lease = new AutoDeviceLease(this, _deviceService, deviceId, sessionId, stepName ?? "Step", owner);

            // 如果底层是 LayeredResourceManager，启动心跳续期
            if (_resourceManager is LayeredResourceManager lrm)
            {
                if (lrm.TryGetGrants(owner.TokenId, out var grants))
                {
                    lease.StartHeartbeat(lrm.Coordinator, grants);
                }
            }

            return lease;
        }

        // ==================== 内部辅助 ====================

        /// <summary>
        /// 内部：申请资源占用。
        /// 使用 OwnerType.Production（自动化测试视为生产流程），
        /// 会与其他测试/维护会话互斥。
        /// </summary>
        private async Task<ResourceOwnerToken> ReserveCoreAsync(
            string deviceId, string purpose, CancellationToken ct)
        {
            var owner = new ResourceOwnerToken(OwnerType.Production, $"auto_{Guid.NewGuid():N}");
            var resourceKey = new ResourceKey(deviceId, "Generic");

            // 使用超时包装
            using (var cts = CancellationTokenSource.CreateLinkedTokenSource(ct))
            {
                cts.CancelAfter(TimeSpan.FromSeconds(DefaultLeaseTimeoutSeconds));
                try
                {
                    await _resourceManager.ReserveAsync(owner, resourceKey, cts.Token).ConfigureAwait(false);
                    Log.Debug($"[AutoFacade] 设备 {deviceId} 已预约 (purpose={purpose}, owner={owner.OwnerId})");
                }
                catch (OperationCanceledException)
                {
                    throw new TimeoutException($"设备 {deviceId} 租约申请超时（{DefaultLeaseTimeoutSeconds}s），可能被生产或维护占用");
                }
                catch (ResourceConflictException ex)
                {
                    throw new InvalidOperationException(
                        $"设备 {deviceId} 已被其他所有者占用: {ex.Message}", ex);
                }
            }

            return owner;
        }

        /// <summary>
        /// 内部：释放资源占用。
        /// </summary>
        internal async Task ReleaseCoreAsync(string deviceId, ResourceOwnerToken owner)
        {
            try
            {
                var resourceKey = new ResourceKey(deviceId, "Generic");
                await _resourceManager.ReleaseReservationAsync(owner, resourceKey, CancellationToken.None)
                    .ConfigureAwait(false);
                Log.Debug($"[AutoFacade] 设备 {deviceId} 已释放预约 (owner={owner.OwnerId})");
            }
            catch (Exception ex)
            {
                // 释放失败不阻塞主流程，仅记录
                Log.Warn($"[AutoFacade] 释放设备 {deviceId} 预约异常: {ex.Message}");
            }
        }
    }

    /// <summary>
    /// 自动化设备作用域租约实现。
    /// Dispose 时自动释放底层资源占用。
    /// 幂等：多次 Dispose 只释放一次。
    /// </summary>
    internal sealed class AutoDeviceLease : IAutoDeviceLease
    {
        private readonly AutoDeviceFacade _facade;
        private readonly IDeviceService _deviceService;
        private readonly ResourceOwnerToken _owner;
        private bool _disposed;

        // V3.0 心跳续期字段
        private LeaseGrant[] _grants = new LeaseGrant[0];
        private Timer? _beacon;
        private volatile int _renewFailures;
        private ILeaseCoordinator? _coordinator;
        public event EventHandler? LeaseLost;
        public bool HandoverRequested => false;

        public string DeviceId { get; }
        public string SessionId { get; }
        public string StepName { get; }
        public DateTime AcquiredAt { get; }
        public bool IsReleased => _disposed;

        internal AutoDeviceLease(
            AutoDeviceFacade facade,
            IDeviceService deviceService,
            string deviceId,
            string sessionId,
            string stepName,
            ResourceOwnerToken owner)
        {
            _facade = facade;
            _deviceService = deviceService;
            DeviceId = deviceId;
            SessionId = sessionId;
            StepName = stepName;
            AcquiredAt = DateTime.Now;
            _owner = owner;
        }

        internal void StartHeartbeat(ILeaseCoordinator coordinator, LeaseGrant[] grants)
        {
            _coordinator = coordinator;
            _grants = grants;
            _beacon = new Timer(_ =>
            {
                if (_disposed) return;
                try
                {
                    bool allOk = true;
                    foreach (var g in _grants)
                    {
                        if (!_coordinator.Renew(g, 30)) { allOk = false; break; }
                    }
                    if (allOk)
                        Interlocked.Exchange(ref _renewFailures, 0);
                    else
                        Interlocked.Increment(ref _renewFailures);
                    if (Volatile.Read(ref _renewFailures) >= 2) LeaseLost?.Invoke(this, EventArgs.Empty);
                }
                catch
                {
                    if (Interlocked.Increment(ref _renewFailures) >= 2) LeaseLost?.Invoke(this, EventArgs.Empty);
                }
            }, null, 8000, 8000);
        }

        public Task<DeviceCommandResult> ExecuteAsync(string command, CancellationToken ct = default)
        {
            ThrowIfReleased();
            ThrowIfStale();
            return _deviceService.ExecuteCommandAsync(DeviceId, command, _owner, ct);
        }

        public Task<DeviceCommandResult> QueryAsync(string query, CancellationToken ct = default)
        {
            ThrowIfReleased();
            ThrowIfStale();
            return _deviceService.ExecuteQueryAsync(DeviceId, query, _owner, ct);
        }

        public Task ReleaseAsync(CancellationToken ct = default)
        {
            // Dispose() 内部已处理 _beacon?.Dispose() 和 _disposed 标记
            Dispose();
            return Task.CompletedTask;
        }

        public void Dispose()
        {
            if (_disposed) return;
            _beacon?.Dispose();
            _disposed = true;
            // 同步释放（.NET 4.7.2 无 IAsyncDisposable），阻塞等待
            _facade.ReleaseCoreAsync(DeviceId, _owner).GetAwaiter().GetResult();
            GC.SuppressFinalize(this);
        }

        private void ThrowIfReleased()
        {
            if (_disposed)
                throw new ObjectDisposedException(nameof(AutoDeviceLease),
                    $"设备 {DeviceId} 的租约已释放 (Session={SessionId.Substring(0, 8)})");
        }

        private void ThrowIfStale()
        {
            if (Volatile.Read(ref _renewFailures) >= 2)
                throw new InvalidOperationException("LEASE_STALE: 租约已失效");
        }
    }
}