using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using DevExpress.Xpo;
using Ips.AdcAlgorithm;
using Ips.Library.Basic;
using Ips.Library.Entity;
using Ips.Library.LocLib;
using Ips.Library.Signals;
using Ips.Sps.Scheduling.Entities;
using Ips.Sps.TskResults.Pases;
using Ips.Sps.Tsks;

namespace Ips.Sps.Scheduling.SigAds
{
    public abstract class AdWorkerBase
    {
        public AdWorkerBase(RunTsk Tsk)
        {
            this.CurrentTsk = Tsk;
            _adController = new AdcController();
        }

        public RunTsk CurrentTsk { get; protected set; }
        protected IAdController _adController;

        public event EventHandler<AdSigGroupStartEventArgs> AdSigGroupStart;

        public event EventHandler<AdSigCompletedEventArgs> AdSigCompleted;

        public event EventHandler<AdSigGroupCompletedEventArgs> AdSigGroupCompleted;

        public abstract void Execute(CancellationToken token);

        protected virtual void OnAdSigGroupStart(AdSigGroupStartEventArgs arg)
        {
            AdSigGroupStart?.Invoke(this, arg);
        }

        protected virtual void OnAdSigCompleted(AdSigCompletedEventArgs arg)
        {
            AdSigCompleted?.Invoke(this, arg);
        }

        protected virtual void OnAdSigGroupCompleted(AdSigGroupCompletedEventArgs arg)
        {
            AdSigGroupCompleted?.Invoke(this, arg);
        }

        protected virtual ExeResult<AdcResult> ExecuteAdc(RunAdCard adCard, RunSig sig, CancellationToken token)
        {
            var adcAndCfq = AdSigUtil.GetAdcAndCfqOptions(adCard, sig, true);
            if (adcAndCfq.AdOptions == null) return null;
            if (adcAndCfq.CfOptions.IsNotNullOrEmpty()) AdSigUtil.SetCfqList(adcAndCfq.CfOptions, token);
            var adcOpt = adcAndCfq.AdOptions;
            adcOpt.StartTime = DateTime.Now.AddSeconds(AdcConst.MinWaitTime);
            if (sig.HasSample)
            {
                var sigSamples = sig.SigSamples.Where(m => m.Fs == sig.Fs && (m.EndSec - m.StartSec) >= sig.SigLen);
                if (sigSamples.IsNotNullOrEmpty())
                {
                    int startSec = adcOpt.StartTime.Second;
                    int endSec = startSec + sig.SigLen;
                    if (!sigSamples.Any(m => m.StartSec <= startSec && m.EndSec >= startSec))
                    {
                        adcOpt.StartTime.AddMinutes(1).ClearSecond().AddSeconds(sigSamples.Min(m => m.StartSec));
                    }
                }
            }
            IpsLogger.Info($"信号频点：{sig.SigFreq.E6m()}开始采集，任务：【{CurrentTsk.TskName}】,开始时间:{adcOpt.StartTime:yyyy-MM-dd HH:mm:ss}");
            ExeResult<AdcResult> adcRes = null;
            try
            {
                adcRes = _adController.StartAdc(adcOpt, null, token).Result;
            }
            catch (Exception ex)
            {
                ex.HandleCancelEx(error =>
                {
                    IpsLogger.Error("执行采集出错",error);
                }, exCancel =>
                {
                    IpsLogger.Error("采集取消或超时退出，" + exCancel.Message);
                });
                Thread.Sleep(2000);
            }
            IpsLogger.Info($"信号频点：{sig.SigFreq.E6m()}采集完成，任务：【{CurrentTsk.TskName}】");
            return adcRes;
        }

        protected virtual ExeResult<AdcResult> ExecuteDdc(RunAdCard adCard, List<RunSig> allSig, List<DxSig> dxSig, bool isKeep, Action<AdcResult> resultCallback, CancellationToken token)
        {
            AdcOptionsBuilder optionsBuilder = new AdcOptionsBuilder();
            optionsBuilder.SetCard(adCard.CardType, adCard.ClockType, adCard.TriggerMode, adCard.DdcFreq, adCard.ClockFreq, adCard.Mutil, adCard.StorePath);
            optionsBuilder.SetStart(DateTime.MinValue, allSig.Max(m => m.SigLen));
            adCard.Channels.ForEach(ch =>
            {
                if (ch.FixCenter)
                    optionsBuilder.SetChannel(ch.AntCode, ch.AdcCode, ch.ChNum, ch.CenterFreq);
            });
            FreqPointInfo mainSatFreq = null;
            allSig.ForEach(sig =>
            {
                if (sig.MainSatId > 0)
                {
                    var ch = adCard.Channels.Find(m => m.Sats.Any(m => m.SatId == sig.MainSatId));
                    if (ch != null)
                    {
                        var sat = ch.Sats.Find(m => m.SatId == sig.MainSatId);
                        mainSatFreq = SigCalcUtil.GetFreqPointBySigFreq(sig.SigFreq, sat.SatType, sat.SatTurn, ch.FrqTurn);
                        optionsBuilder.AddSignal(ch.AntCode, ch.AdcCode, ch.ChNum, mainSatFreq.DownFreq, sig.BandWidth, sat.SatNum.ToString(), mainSatFreq.UpFreq);
                    }
                }
                sig.AdjaSatIds.ForEach(adjaSatId =>
                {
                    var ch = adCard.Channels.Find(m => m.Sats.Any(m => m.SatId == adjaSatId));
                    if (ch != null)
                    {
                        var sat = ch.Sats.Find(m => m.SatId == adjaSatId);
                        var adjaSatFreq = SigCalcUtil.GetFreqPointBySigFreq(mainSatFreq?.UpFreq ?? sig.SigFreq, sat.SatType, sat.SatTurn, ch.FrqTurn);
                        optionsBuilder.AddSignal(ch.AntCode, ch.AdcCode, ch.ChNum, adjaSatFreq.DownFreq, sig.BandWidth, sat.SatNum.ToString(), adjaSatFreq.UpFreq);
                    }
                });
            });
            dxSig.ForEach(dxSig =>
            {
                dxSig.AdjaSatIds.ForEach(adjaSatId =>
                {
                    var ch = adCard.Channels.Find(m => m.Sats.Any(m => m.SatId == adjaSatId));
                    if (ch != null)
                    {
                        var sat = ch.Sats.Find(m => m.SatId == adjaSatId);
                        var adjaSatFreq = SigCalcUtil.GetFreqPointBySigFreq(dxSig.SigFreq, sat.SatType, sat.SatTurn, ch.FrqTurn);
                        optionsBuilder.AddDXSignal(ch.AntCode, ch.AdcCode, ch.ChNum, adjaSatFreq.DownFreq, dxSig.BandWidth, (int)dxSig.SigType, adjaSatFreq.UpFreq);
                    }
                });
            });
            var adcOptions = optionsBuilder.Build();
            adcOptions.UseGpuDdc = SpsConst.UseGpuDdc;
            adcOptions.Real = adcOptions.Mutil < 2;
            adcOptions.StartTime = DateTime.Now.AddSeconds(AdcConst.MinWaitTime);
            AdSigUtil.SetAdCardFreq(adCard, adcOptions, token);
            ExeResult<AdcResult> adcResult = null;
            try
            {
                if (!isKeep)
                {
                    adcResult = _adController.StartDdcOne(adcOptions, null, token).Result;
                }
                else
                {
                    var ddcController = new AdgController();
                    adcResult = ddcController.StartDdcKeep(adcOptions, resultCallback, null, token).Result;
                }
            }
            catch (Exception ex)
            {
                ex.HandleCancelEx(error =>
                {
                    IpsLogger.Error("执行采集出错", error);
                }, exCancel =>
                {
                    IpsLogger.Error("采集取消或超时退出，" + exCancel.Message);
                });
                Thread.Sleep(2000);
            }
          
            return adcResult;
        }

        protected virtual Pas CreatePas(RunTsk tsk, AdSigGroup adGroup, RunSig sig, RunSat sat, RunAdCard adCard, RunAdCh adCh, SignalFile adFile, UnitOfWork uow)
        {
            Pas pas = uow != null ? new Pas(uow) : new Pas();
            pas.TskId = tsk.TskId;
            pas.GroupTime = adGroup.GroupTime;
            pas.SigId = sig.SigId;
            pas.EmtId = sig.EmtId;
            pas.SigTime = adFile.SigTime.ClearMillisecond();
            pas.SigFreq = sig.SigFreq;
            pas.BandWidth = sig.BandWidth;
            pas.CreateTime = DateTime.Now;

            pas.SatId = sat.SatId;
            pas.SatNum = sat.SatNum;
            pas.UpFreq = sig.SigFreq;
            pas.DownFreq = adFile.SigFreq;
            pas.SigCategory = sig.SigCategory;
            pas.SigType = sig.SigType;
            pas.SigLen = sig.SigLen;
            pas.Fs = SigCalcUtil.CalcFs(adCard.ClockFreq, sig.BandWidth, adCard.Mutil);
            pas.SatCode = sat.SatCode;
            pas.AdCardId = adCard.CardId;
            pas.AdChId = adCh.ChId;
            pas.ChNum = adFile.ChNum;
            pas.FolderName = adFile.DirectoryName;
            pas.FileName = adFile.FileName;
            pas.AntId = adCh.AntId;
            pas.AntLon = adCh.AntLon;
            pas.AntLat = adCh.AntLat;
            pas.AntAlt = adCh.AntAlt;

            return pas;
        }

        protected virtual AdSigResult WrapSigAdResult(RunTsk runTsk, AdSigGroup adGroup, RunAdCard adCard, RunSig sig, AdcResult adRes)
        {
            AdSigResult result = new AdSigResult(adGroup.TskId, adGroup.GroupTime, sig, adRes.StartTime);
            if (adRes == null || adRes.FileList.IsNullOrEmpty())
                return result;
            result.AdFileDownloadUrl = adRes.FileList.First().DownloadUrl;
            using var uow = new UnitOfWork();
            {
                foreach (var satid in sig.GetSatList())
                {
                    var adch = adCard.Channels.Find(m => m.Sats.Any(sat => sat.SatId == satid));
                    if (adch == null) continue;
                    var sat = adch.Sats.Find(m => m.SatId == satid);
                    var adFile = adRes.FileList.Find(m => m.ChNum == adch.ChNum && m.SigFreq == sig.SigFreq && m.BandWidth == sig.BandWidth);
                    if (adFile == null) continue;
                    var pas = CreatePas(CurrentTsk, adGroup, sig, sat, adCard, adch, adFile, uow);

                    result.PasList.Add(pas);
                }
                uow.CommitChanges();
            }
            return result;
        }
    }
}