using CoreAgent.Domain.Interfaces.Network;
using CoreAgent.Domain.Models.Network;
using CoreAgent.Domain.Models.System;

namespace CoreAgent.Domain.Contexts;

/// <summary>
/// 蜂窝网络领域上下文
/// </summary>
public class CellularNetworkContext : IDisposable
{
    private static readonly Lazy<CellularNetworkContext> _instance = new(() => new CellularNetworkContext());
    private readonly object _lock = new();
    private CellularNetworkState _networkState;
    private NetworkCommandConfig _networkCommandConfig;
    private string _neConfigKey = string.Empty;
    public CancellationTokenSource token = new CancellationTokenSource();
    private bool _isDisposed;
    private bool _isInitialized;

    /// <summary>
    /// 获取单例实例
    /// </summary>
    public static CellularNetworkContext Instance => _instance.Value;

    private CellularNetworkContext() 
    {
        _isDisposed = false;
        _isInitialized = false;
    }

    /// <summary>
    /// 初始化上下文
    /// </summary>
    /// <param name="config">网络命令配置</param>
    public void Initialize(NetworkCommandConfig config = null)
    {
        lock (_lock)
        {
            if (_isDisposed)
            {
                throw new ObjectDisposedException(nameof(CellularNetworkContext));
            }
            
            if (_isInitialized)
            {
                return;
            }

            _networkState = new CellularNetworkState(_neConfigKey);
            _networkCommandConfig = config;
            _isInitialized = true;
        }
    }

    /// <summary>
    /// 设置网络命令配置
    /// </summary>
    /// <param name="config">网络命令配置</param>
    public void SetNetworkCommandConfig(NetworkCommandConfig config)
    {
        lock (_lock)
        {
            if (_isDisposed)
            {
                throw new ObjectDisposedException(nameof(CellularNetworkContext));
            }

            if (!_isInitialized)
            {
                throw new InvalidOperationException("上下文未初始化，请先调用Initialize方法");
            }

            _networkCommandConfig = config ?? throw new ArgumentNullException(nameof(config));
        }
    }

    /// <summary>
    /// 获取网络命令配置
    /// </summary>
    /// <returns>网络命令配置</returns>
    public NetworkCommandConfig GetNetworkCommandConfig()
    {
        lock (_lock)
        {
            if (_isDisposed)
            {
                throw new ObjectDisposedException(nameof(CellularNetworkContext));
            }

            if (!_isInitialized)
            {
                throw new InvalidOperationException("上下文未初始化");
            }

            return _networkCommandConfig ?? throw new InvalidOperationException("网络命令配置未设置");
        }
    }

    public string SetNeConfigKey(string key)
    {
        lock (_lock)
        {
            if (_isDisposed)
            {
                throw new ObjectDisposedException(nameof(CellularNetworkContext));
            }

            if (!_isInitialized)
            {
                throw new InvalidOperationException("上下文未初始化");
            }

            _neConfigKey = key ?? throw new ArgumentNullException(nameof(key));
            return _neConfigKey;
        }
    }

    public string GetNeConfigKey()
    {
        lock (_lock)
        {
            if (_isDisposed)
            {
                throw new ObjectDisposedException(nameof(CellularNetworkContext));
            }

            if (!_isInitialized)
            {
                throw new InvalidOperationException("上下文未初始化");
            }

            return _neConfigKey;
        }
    }

    /// <summary>
    /// 获取指定类型的命令配置
    /// </summary>
    /// <param name="type">命令类型</param>
    /// <returns>命令配置列表</returns>
    public List<CommandTemplateConfig> GetCommandsByType(NetworkCommandType type)
    {
        lock (_lock)
        {
            return _networkCommandConfig?.GetCommandsByType(type) ?? new List<CommandTemplateConfig>();
        }
    }

    /// <summary>
    /// 获取所有命令类型
    /// </summary>
    /// <returns>命令类型数组</returns>
    public NetworkCommandType[] GetCommandTypes()
    {
        lock (_lock)
        {
            return _networkCommandConfig?.GetCommandTypes() ?? Array.Empty<NetworkCommandType>();
        }
    }

    /// <summary>
    /// 获取网络状态
    /// </summary>
    /// <returns>网络状态</returns>
    public CellularNetworkState GetNetworkState()
    {
        lock (_lock)
        {
            if (_isDisposed)
            {
                throw new ObjectDisposedException(nameof(CellularNetworkContext));
            }

            if (!_isInitialized)
            {
                throw new InvalidOperationException("上下文未初始化");
            }

            return _networkState ?? throw new InvalidOperationException("网络状态未初始化");
        }
    }

    /// <summary>
    /// 重置上下文状态
    /// </summary>
    public void Reset()
    {
        lock (_lock)
        {
            if (_isDisposed)
            {
                throw new ObjectDisposedException(nameof(CellularNetworkContext));
            }

            if (!_isInitialized)
            {
                return;
            }

            token.Cancel();
            token = new CancellationTokenSource();
            _networkState = new CellularNetworkState(_neConfigKey);
        }
    }

    /// <summary>
    /// 释放资源
    /// </summary>
    public void Dispose()
    {
        if (_isDisposed)
        {
            return;
        }

        lock (_lock)
        {
            if (_isDisposed)
            {
                return;
            }

            token.Cancel();
            token.Dispose();
            _isInitialized = false;
            _isDisposed = true;
        }
    }
}

/// <summary>
/// 蜂窝网络状态
/// </summary>
public class CellularNetworkState
{
    /// <summary>
    /// 网络接口名称
    /// </summary>
    public string NeConfigKey { get; }

    /// <summary>
    /// 是否已初始化
    /// </summary>
    public bool IsInitialized { get; private set; }

    /// <summary>
    /// 最后启动时间
    /// </summary>
    public DateTime? LastStartTime { get; private set; }

    /// <summary>
    /// 最后停止时间
    /// </summary>
    public DateTime? LastStopTime { get; private set; }

    /// <summary>
    /// 当前运行状态
    /// </summary>
    public NetworkStatus CurrentStatus { get; private set; }

    /// <summary>
    /// 当前网络类型
    /// </summary>
    public NetworkType CurrentNetworkType { get; private set; }



    public CellularNetworkState(string _NeConfigKey)
    {
        NeConfigKey = _NeConfigKey;
        IsInitialized = false;
        CurrentStatus = NetworkStatus.Unknown;
    }

    /// <summary>
    /// 更新网络状态
    /// </summary>
    public void UpdateStatus(NetworkStatus status)
    {
        CurrentStatus = status;
    }


    /// <summary>
    /// 更新网络类型
    /// </summary>
    public void UpdateNetworkType(NetworkType type)
    {
        CurrentNetworkType = type;
    }


    /// <summary>
    /// 标记为已启动
    /// </summary>
    public void MarkAsStarted()
    {
        IsInitialized = true;
        LastStartTime = DateTime.Now;
        CurrentStatus = NetworkStatus.Connected;
    }

    /// <summary>
    /// 标记为已停止
    /// </summary>
    public void MarkAsStopped()
    {
        IsInitialized = false;
        LastStopTime = DateTime.Now;
        CurrentStatus = NetworkStatus.Disconnected;
        CurrentNetworkType = NetworkType.Unknown;
    }
}