using System;
using System.Collections.Generic;
using System.Linq;
using log4net;
using Plugin.DeviceDebug.Entity;
using Aging.Infrastructure.Contracts;

namespace Plugin.DeviceDebug.Model
{
    /// <summary>
    /// 调试会话管理器 - 负责状态机转换和权限校验
    /// </summary>
    public class DebugSessionManager
    {
        private static readonly ILog log = LogManager.GetLogger(typeof(DebugSessionManager));
        private readonly DeviceDebugModel _model;
        private readonly IResourceManager? _resourceManager;

        // 内存中的活跃会话缓存
        private readonly Dictionary<string, DebugSession> _activeSessions = new();

        public DebugSessionManager(DeviceDebugModel model, IResourceManager? resourceManager = null)
        {
            _model = model;
            _resourceManager = resourceManager;
        }

        /// <summary>
        /// 打开会话（ReadOnly模式）
        /// </summary>
        public DebugSession OpenSession(string deviceId, string operatorId, string operatorName, string effectiveVersion)
        {
            try
            {
                // 检查是否已有活跃会话
                var existingSession = GetActiveSessionByDevice(deviceId);
                if (existingSession != null)
                {
                    log.Warn($"设备 {deviceId} 已有活跃会话: {existingSession.SessionId}");
                    return existingSession;
                }

                var session = new DebugSession
                {
                    DeviceId = deviceId,
                    OperatorId = operatorId,
                    OperatorName = operatorName,
                    EffectiveVersion = effectiveVersion,
                    State = DebugSessionState.ReadOnly
                };

                // 持久化到数据库
                _model.CreateSession(session);

                // 更新内存缓存
                _activeSessions[session.SessionId] = session;

                log.Info($"打开会话: {session.SessionId}, 设备: {deviceId}, 操作员: {operatorName}");
                return session;
            }
            catch (Exception ex)
            {
                log.Error($"打开会话失败: {ex.Message}", ex);
                throw;
            }
        }

        /// <summary>
        /// 请求进入维护模式（ReadOnly → AcquiringMaintenance）
        /// 检查：设备是否有生产Reserved
        /// </summary>
        public bool RequestMaintenance(string sessionId)
        {
            try
            {
                if (!_activeSessions.TryGetValue(sessionId, out var session))
                {
                    log.Warn($"会话不存在: {sessionId}");
                    return false;
                }

                // 验证状态转换
                if (session.State != DebugSessionState.ReadOnly)
                {
                    log.Warn($"会话 {sessionId} 当前状态为 {session.State}，无法请求维护模式");
                    return false;
                }

                // 检查设备是否有生产Reserved（与资源预约系统集成）
                if (_resourceManager != null)
                {
                    var resourceKey = new ResourceKey(session.DeviceId, "Generic");
                    var ownerToken = new ResourceOwnerToken(OwnerType.Maintenance, session.SessionId);

                    try
                    {
                        var reservation = _resourceManager.ReserveAsync(
                            ownerToken, resourceKey, CancellationToken.None).GetAwaiter().GetResult();
                        session.ReservationRef = reservation.ReservationId;
                    }
                    catch (ResourceConflictException)
                    {
                        log.Warn($"设备 {session.DeviceId} 已被生产预约占用，拒绝维护请求");
                        return false;
                    }
                }
                else
                {
                    // 降级模式：无 ResourceManager 时允许所有请求（向后兼容）
                    log.Warn("ResourceManager 未初始化，跳过资源预约检查");
                }

                // 状态转换
                session.State = DebugSessionState.AcquiringMaintenance;

                // 持久化
                _model.UpdateSession(session);

                log.Info($"会话 {sessionId} 请求维护模式");
                return true;
            }
            catch (Exception ex)
            {
                log.Error($"请求维护模式失败: {ex.Message}", ex);
                return false;
            }
        }

        /// <summary>
        /// 激活维护模式（AcquiringMaintenance → MaintenanceActive）
        /// </summary>
        public void ActivateMaintenance(string sessionId)
        {
            try
            {
                if (!_activeSessions.TryGetValue(sessionId, out var session))
                {
                    log.Warn($"会话不存在: {sessionId}");
                    throw new InvalidOperationException($"会话不存在: {sessionId}");
                }

                // 验证状态转换
                if (session.State != DebugSessionState.AcquiringMaintenance)
                {
                    log.Warn($"会话 {sessionId} 当前状态为 {session.State}，无法激活维护模式");
                    throw new InvalidOperationException($"会话 {sessionId} 当前状态为 {session.State}，无法激活维护模式");
                }

                // 状态转换
                session.State = DebugSessionState.MaintenanceActive;

                // 持久化
                _model.UpdateSession(session);

                log.Info($"会话 {sessionId} 激活维护模式");
            }
            catch (Exception ex)
            {
                log.Error($"激活维护模式失败: {ex.Message}", ex);
                throw;
            }
        }

        /// <summary>
        /// 关闭会话（MaintenanceActive → Closing → Closed）
        /// 执行安全状态检查
        /// </summary>
        public void CloseSession(string sessionId)
        {
            try
            {
                if (!_activeSessions.TryGetValue(sessionId, out var session))
                {
                    log.Warn($"会话不存在: {sessionId}");
                    throw new InvalidOperationException($"会话不存在: {sessionId}");
                }

                // 验证状态转换（只有 MaintenanceActive 可以关闭）
                if (session.State != DebugSessionState.MaintenanceActive)
                {
                    log.Warn($"会话 {sessionId} 当前状态为 {session.State}，无法关闭");
                    throw new InvalidOperationException($"会话 {sessionId} 当前状态为 {session.State}，无法关闭");
                }

                // 状态转换: MaintenanceActive → Closing
                session.State = DebugSessionState.Closing;
                _model.UpdateSession(session);
                log.Debug($"会话 {sessionId} 进入关闭中状态");

                // 执行安全状态检查：释放资源预约
                if (_resourceManager != null && !string.IsNullOrEmpty(session.ReservationRef))
                {
                    try
                    {
                        var resourceKey = new ResourceKey(session.DeviceId, "Generic");
                        var ownerToken = new ResourceOwnerToken(OwnerType.Maintenance, session.SessionId);

                        _resourceManager.ReleaseReservationAsync(
                            ownerToken, resourceKey, CancellationToken.None).GetAwaiter().GetResult();

                        log.Info($"已释放设备 {session.DeviceId} 的资源预约");
                    }
                    catch (Exception ex)
                    {
                        log.Error($"释放资源预约失败: {ex.Message}", ex);
                        // 不阻止关闭流程，但记录警告
                    }
                }

                // 状态转换: Closing → Closed
                session.State = DebugSessionState.Closed;
                session.ClosedAt = DateTime.Now;
                _model.UpdateSession(session);

                // 从缓存中移除
                _activeSessions.Remove(sessionId);

                log.Info($"会话 {sessionId} 已关闭");
            }
            catch (Exception ex)
            {
                log.Error($"关闭会话失败: {ex.Message}", ex);
                throw;
            }
        }

        /// <summary>
        /// 故障处理（任意 → Faulted）
        /// </summary>
        public void FaultSession(string sessionId, string errorMessage)
        {
            try
            {
                if (!_activeSessions.TryGetValue(sessionId, out var session))
                {
                    log.Warn($"会话不存在: {sessionId}");
                    return;
                }

                // 记录当前状态
                var previousState = session.State;

                // 状态转换
                session.State = DebugSessionState.Faulted;

                // 持久化
                _model.UpdateSession(session);

                log.Error($"会话 {sessionId} 发生故障，从 {previousState} 转为 Faulted: {errorMessage}");
            }
            catch (Exception ex)
            {
                log.Error($"标记故障状态失败: {ex.Message}", ex);
            }
        }

        /// <summary>
        /// 标记需要恢复（任意 → RecoveryRequired）
        /// </summary>
        public void MarkRecoveryRequired(string sessionId)
        {
            try
            {
                if (!_activeSessions.TryGetValue(sessionId, out var session))
                {
                    log.Warn($"会话不存在: {sessionId}");
                    return;
                }

                // 记录当前状态
                var previousState = session.State;

                // 状态转换
                session.State = DebugSessionState.RecoveryRequired;

                // 持久化
                _model.UpdateSession(session);

                log.Warn($"会话 {sessionId} 标记为需要恢复，从 {previousState} 转为 RecoveryRequired");
            }
            catch (Exception ex)
            {
                log.Error($"标记恢复状态失败: {ex.Message}", ex);
            }
        }

        /// <summary>
        /// 验证命令是否允许执行（只有 MaintenanceActive 状态允许写操作）
        /// </summary>
        public bool ValidateCommand(string sessionId, DebugCommand command)
        {
            try
            {
                if (!_activeSessions.TryGetValue(sessionId, out var session))
                {
                    log.Warn($"会话不存在: {sessionId}");
                    return false;
                }

                // 只有 MaintenanceActive 状态允许写操作
                bool allowed = session.State == DebugSessionState.MaintenanceActive;

                if (!allowed)
                {
                    log.Warn($"会话 {sessionId} 状态为 {session.State}，拒绝执行命令: {command.CommandType}");
                }

                // 增加资源预约验证
                if (allowed && _resourceManager != null)
                {
                    var resourceKey = new ResourceKey(session.DeviceId, "Generic");
                    allowed = _resourceManager.ValidateOwner(
                        new ResourceOwnerToken(OwnerType.Maintenance, session.SessionId),
                        resourceKey);
                    if (!allowed)
                    {
                        log.Warn($"会话 {sessionId} 资源预约验证失败，拒绝执行命令: {command.CommandType}");
                    }
                }

                return allowed;
            }
            catch (Exception ex)
            {
                log.Error($"验证命令失败: {ex.Message}", ex);
                return false;
            }
        }

        /// <summary>
        /// 获取会话状态
        /// </summary>
        public DebugSessionState? GetSessionState(string sessionId)
        {
            try
            {
                if (_activeSessions.TryGetValue(sessionId, out var session))
                {
                    return session.State;
                }

                // 从数据库查询
                var dbSession = _model.GetSession(sessionId);
                return dbSession?.State;
            }
            catch (Exception ex)
            {
                log.Error($"获取会话状态失败: {ex.Message}", ex);
                return null;
            }
        }

        /// <summary>
        /// 获取设备当前会话（如果有）
        /// </summary>
        public DebugSession? GetActiveSessionByDevice(string deviceId)
        {
            try
            {
                // 先从内存缓存查找
                var cachedSession = _activeSessions.Values
                    .FirstOrDefault(s => s.DeviceId == deviceId && s.State != DebugSessionState.Closed);

                if (cachedSession != null)
                {
                    return cachedSession;
                }

                // 从数据库查询
                var activeSessions = _model.GetActiveSessionsByDevice(deviceId);
                return activeSessions.FirstOrDefault();
            }
            catch (Exception ex)
            {
                log.Error($"获取设备活跃会话失败: {ex.Message}", ex);
                return null;
            }
        }
    }
}