using CoreAgent.Domain.Interfaces.Network;
using CoreAgent.Domain.Interfaces.System.Command;
using CoreAgent.Domain.Models.Network;
using CoreAgent.Domain.Models.System;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;

namespace CoreAgent.Infrastructure.Services.Network;

/// <summary>
/// RAN API 命令处理器实现
/// 负责处理各种RAN相关的API操作命令
/// </summary>
public class RanAPICommandHandler : RanAPICommandHandlerBase, IRanPowerControlHandler, IRanGainControlHandler
{
    private readonly ILogger<RanAPICommandHandler> _logger;

    public RanAPICommandHandler(
        ILogger<RanAPICommandHandler> logger,
        ISystemCommandExecutor commandExecutor,
        IOptions<AppSettings> appSettings) 
        : base(commandExecutor, appSettings.Value)
    {
        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
    }

    /// <summary>
    /// 设置 RAN 日志配置
    /// </summary>
    /// <param name="ranEndPoint">RAN 端点信息</param>
    /// <param name="enableBcch">是否启用BCCH日志</param>
    /// <returns>是否成功设置配置</returns>
    public override async Task<bool> SetRanLogsConfigAsync(RanIPEndPoint ranEndPoint, bool enableBcch)
    {
        if (!ValidateRanEndPoint(ranEndPoint))
        {
            _logger.LogWarning("RAN 端点未配置");
            return false;
        }

        try
        {
            var configCommand = $@"{{""message"":""config_set"",""logs"":{{""bcch"":{enableBcch.ToString().ToLower()}}}}}";
            var command = $"{BuildCommandPrefix(ranEndPoint)} '{configCommand}'";
            
            _logger.LogInformation("开始设置RAN日志配置，地址: {ComAddr}, 启用BCCH: {EnableBcch}", ranEndPoint.ComAddr, enableBcch);

            var result = await ExecuteCommandAsync(command, "RAN日志配置设置");
            
            if (result.IsSuccess)
            {
                _logger.LogInformation("RAN日志配置设置成功，地址: {ComAddr}, 启用BCCH: {EnableBcch}", ranEndPoint.ComAddr, enableBcch);
                return true;
            }
            else
            {
                _logger.LogWarning("RAN日志配置设置失败，地址: {ComAddr}, 启用BCCH: {EnableBcch}, 错误: {Error}", 
                    ranEndPoint.ComAddr, enableBcch, result.Error);
                return false;
            }
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "设置RAN日志配置时发生异常，地址: {ComAddr}, 启用BCCH: {EnableBcch}", ranEndPoint.ComAddr, enableBcch);
            return false;
        }
    }

    #region 功率控制方法

    /// <summary>
    /// 设置发送功率
    /// </summary>
    /// <param name="ranEndPoint">RAN 端点信息</param>
    /// <param name="powerSettings">功率设置字典，key为端口号(int)，value为功率值(double)</param>
    /// <returns>是否成功设置功率</returns>
    public async Task<bool> SetTxPowerAsync(RanIPEndPoint ranEndPoint, Dictionary<int, double> powerSettings)
    {
        if (!ValidateRanEndPoint(ranEndPoint))
        {
            _logger.LogWarning("RAN 端点未配置");
            return false;
        }

        if (powerSettings == null || powerSettings.Count == 0)
        {
            _logger.LogWarning("功率设置字典为空或无效");
            return false;
        }

        try
        {
            var successCount = 0;
            var totalCount = powerSettings.Count;

            _logger.LogInformation("开始批量设置发送功率，地址: {ComAddr}, 端口数量: {PortCount}", ranEndPoint.ComAddr, totalCount);

            foreach (var setting in powerSettings)
            {
                var port = setting.Key;
                var setPower = setting.Value;
                
                var cmd_setPower = $"{BuildCommandPrefix(ranEndPoint)} '{{""message"":""rf"",""tx_power"":{setPower},""tx_channel_index"":{port}}}'";
                
                _logger.LogDebug("设置端口 {Port} 的发送功率值为 {SetPower}", port, setPower);

                var result = await ExecuteCommandAsync(cmd_setPower, "发送功率设置");
                
                if (result.IsSuccess)
                {
                    successCount++;
                    _logger.LogDebug("端口 {Port} 发送功率设置成功，功率值: {SetPower}", port, setPower);
                }
                else
                {
                    _logger.LogWarning("端口 {Port} 发送功率设置失败，功率值: {SetPower}, 错误: {Error}", 
                        port, setPower, result.Error);
                }
            }

            var allSuccess = successCount == totalCount;
            if (allSuccess)
            {
                _logger.LogInformation("所有端口发送功率设置成功，地址: {ComAddr}, 成功数量: {SuccessCount}/{TotalCount}", 
                    ranEndPoint.ComAddr, successCount, totalCount);
            }
            else
            {
                _logger.LogWarning("部分端口发送功率设置失败，地址: {ComAddr}, 成功数量: {SuccessCount}/{TotalCount}", 
                    ranEndPoint.ComAddr, successCount, totalCount);
            }

            return allSuccess;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "批量设置发送功率时发生异常，地址: {ComAddr}", ranEndPoint.ComAddr);
            return false;
        }
    }

    /// <summary>
    /// 设置接收功率
    /// </summary>
    /// <param name="ranEndPoint">RAN 端点信息</param>
    /// <param name="powerSettings">功率设置字典，key为端口号(int)，value为功率值(double)</param>
    /// <returns>是否成功设置功率</returns>
    public async Task<bool> SetRxPowerAsync(RanIPEndPoint ranEndPoint, Dictionary<int, double> powerSettings)
    {
        if (!ValidateRanEndPoint(ranEndPoint))
        {
            _logger.LogWarning("RAN 端点未配置");
            return false;
        }

        if (powerSettings == null || powerSettings.Count == 0)
        {
            _logger.LogWarning("功率设置字典为空或无效");
            return false;
        }

        try
        {
            var successCount = 0;
            var totalCount = powerSettings.Count;

            _logger.LogInformation("开始批量设置接收功率，地址: {ComAddr}, 端口数量: {PortCount}", ranEndPoint.ComAddr, totalCount);

            foreach (var setting in powerSettings)
            {
                var port = setting.Key;
                var setPower = setting.Value;
                
                var cmd_setPower = $"{BuildCommandPrefix(ranEndPoint)} '{{""message"":""rf"",""rx_power"":{setPower},""rx_channel_index"":{port}}}'";
                
                _logger.LogDebug("设置端口 {Port} 的接收功率值为 {SetPower}", port, setPower);

                var result = await ExecuteCommandAsync(cmd_setPower, "接收功率设置");
                
                if (result.IsSuccess)
                {
                    successCount++;
                    _logger.LogDebug("端口 {Port} 接收功率设置成功，功率值: {SetPower}", port, setPower);
                }
                else
                {
                    _logger.LogWarning("端口 {Port} 接收功率设置失败，功率值: {SetPower}, 错误: {Error}", 
                        port, setPower, result.Error);
                }
            }

            var allSuccess = successCount == totalCount;
            if (allSuccess)
            {
                _logger.LogInformation("所有端口接收功率设置成功，地址: {ComAddr}, 成功数量: {SuccessCount}/{TotalCount}", 
                    ranEndPoint.ComAddr, successCount, totalCount);
            }
            else
            {
                _logger.LogWarning("部分端口接收功率设置失败，地址: {ComAddr}, 成功数量: {SuccessCount}/{TotalCount}", 
                    ranEndPoint.ComAddr, successCount, totalCount);
            }

            return allSuccess;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "批量设置接收功率时发生异常，地址: {ComAddr}", ranEndPoint.ComAddr);
            return false;
        }
    }

    /// <summary>
    /// 设置所有端口的发送功率
    /// </summary>
    /// <param name="ranEndPoint">RAN 端点信息</param>
    /// <param name="powerValues">所有端口的功率值数组，按端口顺序排列</param>
    /// <returns>是否成功设置功率</returns>
    public async Task<bool> SetAllTxPowerAsync(RanIPEndPoint ranEndPoint, double[] powerValues)
    {
        if (!ValidateRanEndPoint(ranEndPoint))
        {
            _logger.LogWarning("RAN 端点未配置");
            return false;
        }

        if (powerValues == null || powerValues.Length == 0)
        {
            _logger.LogWarning("功率值数组为空或无效");
            return false;
        }

        try
        {
            var powerArrayJson = $"[{string.Join(",", powerValues)}]";
            var cmd_setAllPower = $"{BuildCommandPrefix(ranEndPoint)} '{{""message"":""rf"",""tx_power"":{powerArrayJson}}}'";
            
            _logger.LogInformation("开始设置所有端口发送功率，地址: {ComAddr}, 端口数量: {PortCount}, 功率值: {PowerValues}", 
                ranEndPoint.ComAddr, powerValues.Length, string.Join(",", powerValues));

            var result = await ExecuteCommandAsync(cmd_setAllPower, "所有端口发送功率设置");
            
            if (result.IsSuccess)
            {
                _logger.LogInformation("所有端口发送功率设置成功，地址: {ComAddr}, 端口数量: {PortCount}", 
                    ranEndPoint.ComAddr, powerValues.Length);
                return true;
            }
            else
            {
                _logger.LogWarning("所有端口发送功率设置失败，地址: {ComAddr}, 端口数量: {PortCount}, 错误: {Error}", 
                    ranEndPoint.ComAddr, powerValues.Length, result.Error);
                return false;
            }
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "设置所有端口发送功率时发生异常，地址: {ComAddr}, 端口数量: {PortCount}", 
                ranEndPoint.ComAddr, powerValues?.Length ?? 0);
            return false;
        }
    }

    /// <summary>
    /// 设置所有端口的接收功率
    /// </summary>
    /// <param name="ranEndPoint">RAN 端点信息</param>
    /// <param name="powerValues">所有端口的功率值数组，按端口顺序排列</param>
    /// <returns>是否成功设置功率</returns>
    public async Task<bool> SetAllRxPowerAsync(RanIPEndPoint ranEndPoint, double[] powerValues)
    {
        if (!ValidateRanEndPoint(ranEndPoint))
        {
            _logger.LogWarning("RAN 端点未配置");
            return false;
        }

        if (powerValues == null || powerValues.Length == 0)
        {
            _logger.LogWarning("功率值数组为空或无效");
            return false;
        }

        try
        {
            var powerArrayJson = $"[{string.Join(",", powerValues)}]";
            var cmd_setAllPower = $"{BuildCommandPrefix(ranEndPoint)} '{{""message"":""rf"",""rx_power"":{powerArrayJson}}}'";
            
            _logger.LogInformation("开始设置所有端口接收功率，地址: {ComAddr}, 端口数量: {PortCount}, 功率值: {PowerValues}", 
                ranEndPoint.ComAddr, powerValues.Length, string.Join(",", powerValues));

            var result = await ExecuteCommandAsync(cmd_setAllPower, "所有端口接收功率设置");
            
            if (result.IsSuccess)
            {
                _logger.LogInformation("所有端口接收功率设置成功，地址: {ComAddr}, 端口数量: {PortCount}", 
                    ranEndPoint.ComAddr, powerValues.Length);
                return true;
            }
            else
            {
                _logger.LogWarning("所有端口接收功率设置失败，地址: {ComAddr}, 端口数量: {PortCount}, 错误: {Error}", 
                    ranEndPoint.ComAddr, powerValues.Length, result.Error);
                return false;
            }
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "设置所有端口接收功率时发生异常，地址: {ComAddr}, 端口数量: {PortCount}", 
                ranEndPoint.ComAddr, powerValues?.Length ?? 0);
            return false;
        }
    }

    #endregion

    #region 增益控制方法

    /// <summary>
    /// 设置发送增益
    /// </summary>
    /// <param name="ranEndPoint">RAN 端点信息</param>
    /// <param name="gainSettings">增益设置字典，key为端口号(int)，value为增益值(double)</param>
    /// <returns>是否成功设置增益</returns>
    public async Task<bool> SetTxGainAsync(RanIPEndPoint ranEndPoint, Dictionary<int, double> gainSettings)
    {
        if (!ValidateRanEndPoint(ranEndPoint))
        {
            _logger.LogWarning("RAN 端点未配置");
            return false;
        }

        if (gainSettings == null || gainSettings.Count == 0)
        {
            _logger.LogWarning("增益设置字典为空或无效");
            return false;
        }

        try
        {
            var successCount = 0;
            var totalCount = gainSettings.Count;

            _logger.LogInformation("开始批量设置发送增益，地址: {ComAddr}, 端口数量: {PortCount}", ranEndPoint.ComAddr, totalCount);

            foreach (var setting in gainSettings)
            {
                var port = setting.Key;
                var setGain = setting.Value;
                
                var cmd_setGain = $"{BuildCommandPrefix(ranEndPoint)} '{{""message"":""rf"",""tx_gain"":{setGain},""tx_channel_index"":{port}}}'";
                
                _logger.LogDebug("设置端口 {Port} 的发送增益值为 {SetGain}", port, setGain);

                var result = await ExecuteCommandAsync(cmd_setGain, "发送增益设置");
                
                if (result.IsSuccess)
                {
                    successCount++;
                    _logger.LogDebug("端口 {Port} 发送增益设置成功，增益值: {SetGain}", port, setGain);
                }
                else
                {
                    _logger.LogWarning("端口 {Port} 发送增益设置失败，增益值: {SetGain}, 错误: {Error}", 
                        port, setGain, result.Error);
                }
            }

            var allSuccess = successCount == totalCount;
            if (allSuccess)
            {
                _logger.LogInformation("所有端口发送增益设置成功，地址: {ComAddr}, 成功数量: {SuccessCount}/{TotalCount}", 
                    ranEndPoint.ComAddr, successCount, totalCount);
            }
            else
            {
                _logger.LogWarning("部分端口发送增益设置失败，地址: {ComAddr}, 成功数量: {SuccessCount}/{TotalCount}", 
                    ranEndPoint.ComAddr, successCount, totalCount);
            }

            return allSuccess;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "批量设置发送增益时发生异常，地址: {ComAddr}", ranEndPoint.ComAddr);
            return false;
        }
    }

    /// <summary>
    /// 设置接收增益
    /// </summary>
    /// <param name="ranEndPoint">RAN 端点信息</param>
    /// <param name="gainSettings">增益设置字典，key为端口号(int)，value为增益值(double)</param>
    /// <returns>是否成功设置增益</returns>
    public async Task<bool> SetRxGainAsync(RanIPEndPoint ranEndPoint, Dictionary<int, double> gainSettings)
    {
        if (!ValidateRanEndPoint(ranEndPoint))
        {
            _logger.LogWarning("RAN 端点未配置");
            return false;
        }

        if (gainSettings == null || gainSettings.Count == 0)
        {
            _logger.LogWarning("增益设置字典为空或无效");
            return false;
        }

        try
        {
            var successCount = 0;
            var totalCount = gainSettings.Count;

            _logger.LogInformation("开始批量设置接收增益，地址: {ComAddr}, 端口数量: {PortCount}", ranEndPoint.ComAddr, totalCount);

            foreach (var setting in gainSettings)
            {
                var port = setting.Key;
                var setGain = setting.Value;
                
                var cmd_setGain = $"{BuildCommandPrefix(ranEndPoint)} '{{""message"":""rf"",""rx_gain"":{setGain},""rx_channel_index"":{port}}}'";
                
                _logger.LogDebug("设置端口 {Port} 的接收增益值为 {SetGain}", port, setGain);

                var result = await ExecuteCommandAsync(cmd_setGain, "接收增益设置");
                
                if (result.IsSuccess)
                {
                    successCount++;
                    _logger.LogDebug("端口 {Port} 接收增益设置成功，增益值: {SetGain}", port, setGain);
                }
                else
                {
                    _logger.LogWarning("端口 {Port} 接收增益设置失败，增益值: {SetGain}, 错误: {Error}", 
                        port, setGain, result.Error);
                }
            }

            var allSuccess = successCount == totalCount;
            if (allSuccess)
            {
                _logger.LogInformation("所有端口接收增益设置成功，地址: {ComAddr}, 成功数量: {SuccessCount}/{TotalCount}", 
                    ranEndPoint.ComAddr, successCount, totalCount);
            }
            else
            {
                _logger.LogWarning("部分端口接收增益设置失败，地址: {ComAddr}, 成功数量: {SuccessCount}/{TotalCount}", 
                    ranEndPoint.ComAddr, successCount, totalCount);
            }

            return allSuccess;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "批量设置接收增益时发生异常，地址: {ComAddr}", ranEndPoint.ComAddr);
            return false;
        }
    }

    /// <summary>
    /// 设置所有端口的发送增益
    /// </summary>
    /// <param name="ranEndPoint">RAN 端点信息</param>
    /// <param name="gainValues">所有端口的增益值数组，按端口顺序排列</param>
    /// <returns>是否成功设置增益</returns>
    public async Task<bool> SetAllTxGainAsync(RanIPEndPoint ranEndPoint, double[] gainValues)
    {
        if (!ValidateRanEndPoint(ranEndPoint))
        {
            _logger.LogWarning("RAN 端点未配置");
            return false;
        }

        if (gainValues == null || gainValues.Length == 0)
        {
            _logger.LogWarning("增益值数组为空或无效");
            return false;
        }

        try
        {
            var gainArrayJson = $"[{string.Join(",", gainValues)}]";
            var cmd_setAllGain = $"{BuildCommandPrefix(ranEndPoint)} '{{""message"":""rf"",""tx_gain"":{gainArrayJson}}}'";
            
            _logger.LogInformation("开始设置所有端口发送增益，地址: {ComAddr}, 端口数量: {PortCount}, 增益值: {GainValues}", 
                ranEndPoint.ComAddr, gainValues.Length, string.Join(",", gainValues));

            var result = await ExecuteCommandAsync(cmd_setAllGain, "所有端口发送增益设置");
            
            if (result.IsSuccess)
            {
                _logger.LogInformation("所有端口发送增益设置成功，地址: {ComAddr}, 端口数量: {PortCount}", 
                    ranEndPoint.ComAddr, gainValues.Length);
                return true;
            }
            else
            {
                _logger.LogWarning("所有端口发送增益设置失败，地址: {ComAddr}, 端口数量: {PortCount}, 错误: {Error}", 
                    ranEndPoint.ComAddr, gainValues.Length, result.Error);
                return false;
            }
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "设置所有端口发送增益时发生异常，地址: {ComAddr}, 端口数量: {PortCount}", 
                ranEndPoint.ComAddr, gainValues?.Length ?? 0);
            return false;
        }
    }

    /// <summary>
    /// 设置所有端口的接收增益
    /// </summary>
    /// <param name="ranEndPoint">RAN 端点信息</param>
    /// <param name="gainValues">所有端口的增益值数组，按端口顺序排列</param>
    /// <returns>是否成功设置增益</returns>
    public async Task<bool> SetAllRxGainAsync(RanIPEndPoint ranEndPoint, double[] gainValues)
    {
        if (!ValidateRanEndPoint(ranEndPoint))
        {
            _logger.LogWarning("RAN 端点未配置");
            return false;
        }

        if (gainValues == null || gainValues.Length == 0)
        {
            _logger.LogWarning("增益值数组为空或无效");
            return false;
        }

        try
        {
            var gainArrayJson = $"[{string.Join(",", gainValues)}]";
            var cmd_setAllGain = $"{BuildCommandPrefix(ranEndPoint)} '{{""message"":""rf"",""rx_gain"":{gainArrayJson}}}'";
            
            _logger.LogInformation("开始设置所有端口接收增益，地址: {ComAddr}, 端口数量: {PortCount}, 增益值: {GainValues}", 
                ranEndPoint.ComAddr, gainValues.Length, string.Join(",", gainValues));

            var result = await ExecuteCommandAsync(cmd_setAllGain, "所有端口接收增益设置");
            
            if (result.IsSuccess)
            {
                _logger.LogInformation("所有端口接收增益设置成功，地址: {ComAddr}, 端口数量: {PortCount}", 
                    ranEndPoint.ComAddr, gainValues.Length);
                return true;
            }
            else
            {
                _logger.LogWarning("所有端口接收增益设置失败，地址: {ComAddr}, 端口数量: {PortCount}, 错误: {Error}", 
                    ranEndPoint.ComAddr, gainValues.Length, result.Error);
                return false;
            }
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "设置所有端口接收增益时发生异常，地址: {ComAddr}, 端口数量: {PortCount}", 
                ranEndPoint.ComAddr, gainValues?.Length ?? 0);
            return false;
        }
    }

    #endregion
}