using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using System.Web.Http;
using XdCxRhDW.Api;
using XdCxRhDW.Dto;
using XdCxRhDW.WebApi;

namespace XdCxRhDW.App.Controllers
{
    /// <summary>
    /// 检测参估功能相关接口
    /// </summary>
    public class DetectCgController : BaseController
    {
        /// <summary>
        /// CPU参估计算(需要先上传文件)
        /// </summary>
        /// <param name="dto">CPU参估参数</param>
        /// <returns></returns>
        [HttpPost]
        public async Task<AjaxResult<CpuCgResDto>> CpuCgCalc(CpuCgDto dto)
        {
            dto.file1 = GetLocalFile(dto.file1);
            dto.file2 = GetLocalFile(dto.file2);
            XcorrStruct xItem = new XcorrStruct();
            xItem.file1 = dto.file1;
            xItem.file2 = dto.file2;
            xItem.samplingRate = dto.samplingRate;
            xItem.dtCenter = dto.dtCenter;
            xItem.dtRange = dto.dtRange;
            xItem.dfRange = dto.dfRange;
            FileInfo file1 = new FileInfo(dto.file1);
            FileInfo file2 = new FileInfo(dto.file2);
            long totalsamp = file1.Length < file2.Length ? file1.Length / 4 : file2.Length / 4;
            //样点数为0时计算所有样本
            if (dto.smpCount == 0)
            {
                xItem.smpCount = (int)totalsamp - dto.smpStart;
            }
            else if (dto.smpCount > 0 && dto.smpCount < 1)
            {
                xItem.smpCount = (int)(totalsamp * dto.smpCount);
            }
            else
            {
                xItem.smpCount = dto.smpCount;
            }
            xItem.smpStart = dto.smpStart;
            xItem.snrThreshold = dto.snrThreshold;

            CpuCgResDto resDto = new CpuCgResDto();
            try
            {
                XcorrUtils xcorr = new XcorrUtils();
                var result = await xcorr.Calc(xItem);
                //开始计算
                if (result.flag == -2)
                {
                    Serilog.Log.Error("参估计算内部错误!");
                    return Error<CpuCgResDto>("参估计算内部错误!");
                }
                else if (result.flag == -1)
                {
                    Serilog.Log.Error("参估计算所需数据超出文件范围!");
                    return Error<CpuCgResDto>("参估计算所需数据超出文件范围!");
                }
                resDto.TimeMs = result.tm;
                resDto.Smpstart = result.smpstart;
                resDto.Smplen = result.smplen;
                if (result.flag == 1)
                {
                    resDto.Dt = result.dt.Value;
                    resDto.Df = result.df.Value;
                    resDto.Snr = result.snr.Value;
                }


            }
            catch (Exception ex)
            {
                Serilog.Log.Error(ex, "执行CPU参估异常");
                return Error<CpuCgResDto>($"执行CPU参估异常");
            }
            return Success(resDto);

        }


        /// <summary>
        /// CPU参估多个时隙的参估计算(需要先上传文件)
        /// </summary>
        /// <param name="dto">CPU多时隙参估参数模型</param>
        /// <returns>返回结果个数始终和传入的时隙个数相同</returns>
        [HttpPost]
        public async Task<AjaxResult<List<CpuCgResDto>>> CpuCgMultiCalc(CpuCgMultiDto dto)
        {
            dto.file1 = GetLocalFile(dto.file1);
            dto.file2 = GetLocalFile(dto.file2);
            XcorrStruct xItem = new XcorrStruct();
            xItem.file1 = dto.file1;
            xItem.file2 = dto.file2;
            xItem.samplingRate = dto.samplingRate;
            xItem.dtCenter = dto.dtCenter;
            xItem.dtRange = dto.dtRange;
            xItem.dfRange = dto.dfRange;
            xItem.snrThreshold = dto.snrThreshold;

            List<CpuCgResDto> resDtos = new List<CpuCgResDto>();
            foreach (var smpItem in dto.smpPositions)
            {
                XcorrUtils xcorr = new XcorrUtils();
                xItem.smpStart = smpItem.smpStart;
                xItem.smpCount = smpItem.smpCount;
                CpuCgResDto resDto = new CpuCgResDto();
                resDto.Smpstart = xItem.smpStart;
                resDto.Smplen = (long)xItem.smpCount;
                try
                {
                    var result = await xcorr.Calc(xItem);
                    //开始计算
                    if (result.flag == -2)
                    {
                        resDto.Dt = 0;
                        resDto.Df = 0;
                        resDto.Snr = 0;
                        resDtos.Add(resDto);
                        Serilog.Log.Error("参估计算内部错误!");
                    }
                    else if (result.flag == -1)
                    {
                        resDto.Dt = 0;
                        resDto.Df = 0;
                        resDto.Snr = 0;
                        resDtos.Add(resDto);
                        Serilog.Log.Error("参估计算所需数据超出文件范围!");
                    }
                    else
                    {
                        resDto.TimeMs = result.tm;
                        if (result.flag == 1)
                        {
                            resDto.Dt = result.dt.Value;
                            resDto.Df = result.df.Value;
                            resDto.Snr = result.snr.Value;
                            resDtos.Add(resDto);
                        }
                        else
                        {
                            resDto.Dt = 0;
                            resDto.Df = 0;
                            resDto.Snr = 0;
                            resDtos.Add(resDto);
                        }
                    }
                }
                catch (Exception ex)
                {
                    resDto.Dt = 0;
                    resDto.Df = 0;
                    resDto.Snr = 0;
                    resDtos.Add(resDto);
                    Serilog.Log.Error(ex, "执行CPU参估异常");
                }
            }
            return Success(resDtos);

        }

        /// <summary>
        /// GPU参估计算(需要先上传文件)
        /// </summary>
        /// <param name="dto">GPU参估参数</param>
        /// <returns></returns>
        [HttpPost]
        public async Task<AjaxResult<List<GpuCgResponseDto>>> GpuCgCalc(GpuCgRequestDto dto)
        {
            dto.file1 = GetLocalFile(dto.file1);
            dto.file2 = GetLocalFile(dto.file2);
            FileInfo file1 = new FileInfo(dto.file1);
            FileInfo file2 = new FileInfo(dto.file2);
            long totalsamp = file1.Length < file2.Length ? file1.Length / 4 : file2.Length / 4;
            //样点数为0时计算所有样本
            if (dto.smpCount == 0)
            {
                dto.smpCount = totalsamp;
            }
            else if (dto.smpCount > 0 && dto.smpCount < 1)
            {
                dto.smpCount = (long)(totalsamp * dto.smpCount);
            }
            CpuCgResDto resDto = new CpuCgResDto();
            try
            {
                var result = await Task.Run(() =>
                {
                    return GpuCgHelper.Calc(dto.file1, dto.file2, dto.samplingRate, dto.smpCount,
                  dto.dtCenter, dto.dtRange, dto.dfRange, dto.snrThreshold, dto.TimeoutSeconds);
                });
                return Success(result);
            }
            catch (Exception ex)
            {
                Serilog.Log.Error(ex, "执行GPU参估异常");
                return Error<List<GpuCgResponseDto>>($"执行GPU参估异常");
            }
        }

        /// <summary>
        /// 信号检测(支持DAMA、IBS、能量检测)(需要先上传文件)
        /// </summary>
        /// <param name="dto">信号检测参数</param>
        /// <returns></returns>
        [HttpPost]
        public async Task<AjaxResult<List<DetectResDto>>> DetectCalc(DetectDto dto)
        {
        
            try
            {
                dto.file1 = GetLocalFile(dto.file1);
                List<DetectResDto> list = new List<DetectResDto>();
                List<DmcResult> dmcResults = new List<DmcResult>();
                XcorrUtils xcorr = new XcorrUtils();
                if (dto.dmcType.HasFlag(DmcType.DAMA))
                {
                    var dmcResult = await xcorr.DmcCheckAsync(dto.file1, dto.fsHz, DmcType.DAMA, dto.band);
                    dmcResults.AddRange(dmcResult);
                }
                if (dto.dmcType.HasFlag(DmcType.IBS))
                {
                    var dmcResult = await xcorr.DmcCheckAsync(dto.file1, dto.fsHz, DmcType.IBS, dto.band);
                    dmcResults.AddRange(dmcResult);
                }
                if (dto.dmcType.HasFlag(DmcType.Ky5758))
                {
                    var dmcResult = await xcorr.DmcCheckAsync(dto.file1, dto.fsHz, DmcType.Ky5758, dto.band);
                    dmcResults.AddRange(dmcResult);
                }

                foreach (var dmcItem in dmcResults)
                {
                    DetectResDto detectRes = new DetectResDto(dmcItem.Start, dmcItem.Length, dmcItem.UserName);
                    detectRes.ModType = dmcItem.ModType;
                    detectRes.DmcType = dmcItem.DmcType;
                    detectRes.File1 = dto.file1;
                    detectRes.TimeMs = dmcItem.Times;
                    list.Add(detectRes);
                }
                return Success(list);
            }
            catch (Exception ex)
            {
                Serilog.Log.Error(ex, $"{dto.dmcType}检测异常");
                return Error<List<DetectResDto>>($"{dto.dmcType}检测异常");
            }
        }

        /// <summary>
        /// 信号识别(调制类型、调制速率、频偏)
        /// </summary>
        /// <param name="dto">信号检测参数</param>
        /// <returns></returns>
        [HttpPost]
        public async Task<AjaxResult<List<SignalProcResDto>>> SignalProc(SignalProcDto dto)
        {
            return await Task.Run(() =>
             {
                 try
                 {
                     dto.File = GetLocalFile(dto.File);
                     List<SignalProcResDto> list = new List<SignalProcResDto>();
                     var res = SignalProcHelper.SigalEst(dto.File, dto.Fs
                          , dto.Smps.Select(p => (int)p.smpStart).ToArray()
                          , dto.Smps.Select(p => (int)p.smpCount).ToArray());
                     foreach (var item in res)
                     {
                         SignalProcResDto resItem = new SignalProcResDto()
                         {
                             Ffc = item.Ffc,
                             Rate = item.Rate,
                             ModType = (EnumSignalTypeDto)(int)item.SignalType
                         };
                         list.Add(resItem);
                     }
                     return Success(list);
                 }
                 catch (Exception ex)
                 {
                     Serilog.Log.Error(ex, "信号识别算法执行异常");
                     return Error<List<SignalProcResDto>>($"信号识别算法执行异常");
                 }
             });

        }

        /// <summary>
        /// 文件变采样(需要先上传文件)
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public async Task<AjaxResult<ResampleResponseDto>> Resample(ResampleRequestDto dto)
        {
            var res = await Task.Run(() =>
             {
                 try
                 {
                     string fileIn = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "wwwroot", dto.File);
                     string fileOut = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "wwwroot", Guid.NewGuid() + ".dat");
                     var val = Gcd(dto.FsHz, dto.OutFsHz);//最大公约数
                     var insertFactor = dto.OutFsHz / val;
                     var extFactor = dto.FsHz / val;
                     var outFile = ReSampleHelper.Resample(fileIn, fileOut, insertFactor, extFactor, dto.TimeoutSeconds);
                     if (!string.IsNullOrWhiteSpace(outFile))
                     {
                         if (!File.Exists(outFile))
                             return Error<ResampleResponseDto>("变采样后的文件未能生成");
                         else
                             return Success(new ResampleResponseDto() { File = Path.GetFileName(outFile), OutFsHz = dto.OutFsHz });
                     }
                     else
                     {
                         return Error<ResampleResponseDto>("变采样算法返回失败");
                     }
                 }
                 catch (Exception ex)
                 {
                     Serilog.Log.Error(ex, "变采样算法执行异常");
                     return Error<ResampleResponseDto>("变采样算法执行异常");
                 }
             });
            return res;
        }

        //求最大公约数
        private int Gcd(int M, int N)
        {
            int Rem;
            while (N > 0)
            {
                Rem = M % N;
                M = N;
                N = Rem;
            }
            return M;
        }
    }
}