using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Threading.Tasks;
using XdCxRhDW.Dto;

namespace CpuCgServer
{
    public class XcorrStruct
    {
        public String file1 { get; set; }
        public String file2 { get; set; }

        public long smpStart { get; set; }           //开始样点
        public double smpCount { get; set; }           //样点数
        public double samplingRate { get; set; }    //采样率
        public double dtCenter { get; set; }        //时差中心
        public double dtRange { get; set; }         //时差范围
        public double dfRange { get; set; }         //频差范围
        public double snrThreshold { get; set; }	//信噪比门限

        public int TimeoutSeconds { get; set; }

        public XcorrStruct Copy()
        {
            XcorrStruct xItem = new XcorrStruct();
            xItem.file1 = file1;
            xItem.file2 = file2;
            xItem.smpCount = smpCount;
            xItem.samplingRate = samplingRate;
            xItem.dtCenter = dtCenter;
            xItem.dtRange = dtRange;
            xItem.dfRange = dfRange;
            xItem.smpStart = smpStart;
            xItem.snrThreshold = snrThreshold;
            return xItem;
        }

    }
    public class MultiXcorrStruct
    {
        public String file1 { get; set; }
        public String file2 { get; set; }

        public List<XcorrSmp> xcorrSmps { get; set; }
        public double samplingRate { get; set; }    //采样率
        public double dtCenter { get; set; }        //时差中心
        public double dtRange { get; set; }         //时差范围
        public double dfRange { get; set; }         //频差范围
        public double snrThreshold { get; set; }	//信噪比门限

        public int TimeoutSeconds { get; set; }
    }
    /// <summary>
    /// 时隙样点信息
    /// </summary>

    public class XcorrSmp
    {
        /// <summary>
        /// 
        /// </summary>
        /// <param name="smpStart"></param>
        /// <param name="smpCount"></param>
        public XcorrSmp(long smpStart, long smpCount)
        {
            this.smpStart = smpStart;
            this.smpCount = smpCount;
        }

        public long smpStart { get; set; }

        public long smpCount { get; set; }

        /// <summary>
        /// 54专用,避免样点转时间出现毫秒级误差
        /// </summary>
        public float TimeSeconds { get; set; }


    }
    public class XcorrUtils
    {
        Process cafp;
        Process mucafp;
        // D:/data/test/r1.dat  D:/data/test/r4.dat 1562500 -250000 20 16384 100000 1048576 11
        public async Task<CafResultDto> Calc(XcorrStruct xs)
        {
            CafResultDto res = new CafResultDto();
            cafp = new Process();
            await Task.Run(() =>
            {
                int flag = 0;
                if (xs.smpStart == 0)
                {
                    flag = 2;//文件参估,避免滑动时溢出
                    cafp.StartInfo.Arguments = $"{flag} \"{xs.file1}\" \"{xs.file2}\" {(Int64)(xs.samplingRate)} {xs.dtCenter} {xs.dtRange} {xs.dfRange} {xs.smpCount} {xs.snrThreshold}";
                }
                else
                {
                    var minStart = xs.dtRange / 2 / 1e6 * xs.samplingRate;
                    if (xs.smpStart < minStart)//滑动计算起时值必须要大于等于此数
                    {
                        xs.smpStart = (long)minStart;
                    }
                    cafp.StartInfo.Arguments = $"{flag} \"{xs.file1}\" \"{xs.file2}\" {(Int64)(xs.samplingRate)} {xs.dtCenter} {xs.dtRange} {xs.dfRange} {xs.smpStart} {xs.smpCount} {xs.snrThreshold}";
                }
                var exePath = Path.Combine(cafp.StartInfo.WorkingDirectory, "AddIns");
                cafp.StartInfo.WorkingDirectory = exePath;
                cafp.StartInfo.FileName = Path.Combine(exePath, "XcorrCpu.exe");
                cafp.StartInfo.CreateNoWindow = true;
                cafp.StartInfo.RedirectStandardError = true;
                cafp.StartInfo.RedirectStandardOutput = true;
                cafp.StartInfo.UseShellExecute = false;
                cafp.Start();
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                var suceed = cafp.WaitForExit(xs.TimeoutSeconds * 1000);
                if (!suceed)
                {
                    throw new Exception("CPU参估超时");
                }
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                var str = cafp.StandardOutput.ReadToEnd();
                res.FromLine(str);
                res.file1 = xs.file1;
                res.file2 = xs.file2;
                res.tm = (int)stopWatch.Elapsed.TotalMilliseconds;
                res.smpstart = xs.smpStart;
                res.smplen = (long)xs.smpCount;
            });
            return res;
        }

        public async Task<List<CafResultDto>> MultiCalc(MultiXcorrStruct xs)
        {
            List<CafResultDto> res = new List<CafResultDto>();
            mucafp = new Process();
            await Task.Run(() =>
            {
                int flag = 4;

                string smparg = $"{xs.xcorrSmps.Count}";
                xs.xcorrSmps.ForEach(n => smparg += $" {n.smpStart} {n.smpCount}");
                mucafp.StartInfo.Arguments = $"{flag} \"{xs.file1}\" \"{xs.file2}\" {(Int64)(xs.samplingRate)} {xs.dtCenter} {xs.dtRange} {xs.dfRange} {xs.snrThreshold} {smparg}";

                var exePath = Path.Combine(mucafp.StartInfo.WorkingDirectory, "AddIns");
                mucafp.StartInfo.WorkingDirectory = exePath;
                mucafp.StartInfo.FileName = Path.Combine(exePath, "XcorrCpu.exe");
                mucafp.StartInfo.CreateNoWindow = true;
                mucafp.StartInfo.RedirectStandardError = true;
                mucafp.StartInfo.RedirectStandardOutput = true;
                mucafp.StartInfo.UseShellExecute = false;
                mucafp.Start();
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
                bool succeed = mucafp.WaitForExit(xs.TimeoutSeconds * 1000);
                if (!succeed)
                    throw new Exception("CPU多时隙参估计算超时");
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                var str = mucafp.StandardOutput.ReadToEnd();
                var items = str.Split(";".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
                for (int i = 0; i < items.Length; i++)
                {
                    var item = items[i];
                    var cafres = item.Split(",".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
                    if (cafres.Length != 3)
                    {
                        continue;
                    }
                    CafResultDto caf = new CafResultDto();
                    caf.file1 = xs.file1;
                    caf.file2 = xs.file2;
                    caf.tm = (int)stopWatch.Elapsed.TotalMilliseconds;
                    caf.smpstart = xs.xcorrSmps[i].smpStart;
                    caf.smplen = xs.xcorrSmps[i].smpCount;
                    double snr = Math.Round(double.Parse(cafres[2]), 1);
                    if (snr == 0)
                    {
                        caf.dt = 0;
                        caf.df = 0;
                        caf.snr = 0;
                    }
                    else
                    {
                        caf.dt = Math.Round(double.Parse(cafres[0]), 3);
                        caf.df = Math.Round(double.Parse(cafres[1]), 3);
                        caf.snr = snr;
                    }
                    res.Add(caf);
                }
            });
            return res;
        }

    }
}