using DevExpress.Utils.About;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;

using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Documents;
using System.Windows.Forms;
using DW5S.App.EditForms;
using DW5S.Entity;
using DW5S.Repostory;
using Serilog;
using DevExpress.XtraBars.Customization;
using DW5S.Service;

namespace DW5S.App.UserControl
{
    public partial class CtrlSignal : DevExpress.XtraEditors.XtraUserControl
    {
        readonly List<SigInfo> listSigInfo = new List<SigInfo>();
        readonly List<SigDelay> listSigDelay = new List<SigDelay>();
        public CtrlSignal()
        {
            InitializeComponent();
        }

        private async void CtrlSignal_Load(object sender, EventArgs e)
        {
            try
            {
                gridSignal.UseDefault(listSigInfo).UseMultiSelect().UseRowNumber()
                    .UseAddAsync(AddSigInfo)
                    .UseEditAsync<SigInfo>(EditSigInfo)
                    .UseDeleteAsync<SigInfo>(DeleteSigInfo);
                gridSigDelay.UseDefault(listSigDelay).UseMultiSelect().UseRowNumber()
                   .UseAddAsync(AddSigDelay)
                   .UseEditAsync<SigDelay>(EditSigDelay)
                   .UseDeleteAsync<SigDelay>(DeleteSigDelay);

                var unitOfWork = IocContainer.UnitOfWork;
                var repsSig = unitOfWork.Of<SigInfo>();
                var items = await repsSig.GetAllAsync(p => p.FreqUp);
                listSigInfo.AddRange(items);
                var repsFixedStation = unitOfWork.Of<FixedStation>();
                var fixedStations = await repsFixedStation.FindAsync(p => p.Enable);
                foreach (var item in listSigInfo)
                {
                    if (fixedStations.Any(p => p.FreqUpHz == item.FreqUp))
                        item.IsFixedStationFreq = "✔";
                    else
                        item.IsFixedStationFreq = "✖";
                }
                //var delayItems = await db.SigDelays.ToListAsync();
                //var delayRes = delayItems.Where(w => w.SigInfoID == items.FirstOrDefault().ID);
                //listSigDelay.AddRange(delayRes);

                gridViewSignal.RefreshData();
            }
            catch (Exception ex)
            {
                IocContainer.Logger.Error(ex, "查询信号信息异常");
                DxHelper.MsgBoxHelper.ShowError("查询信号信息异常");
            }
        }
        private async Task<SigInfo> AddSigInfo()
        {
            try
            {
                SigEditor frm = new SigEditor();
                if (frm.ShowDialog() != DialogResult.OK) return null;
                var addItem = frm.info;
                var unitOfWork = IocContainer.UnitOfWork;
                var repsSig = unitOfWork.Of<SigInfo>();
                var sig = await repsSig.AddOrUpdateAsync(addItem);
                await unitOfWork.SaveAsync();
                return addItem;
            }
            catch (Exception ex)
            {
                IocContainer.Logger.Error(ex, "添加信号信息异常");
                DxHelper.MsgBoxHelper.ShowError("添加信号信息异常");
                return null;
            }
        }
        private async Task<SigInfo> EditSigInfo(SigInfo editItem)
        {
            try
            {
                SigEditor frm = new SigEditor(editItem);
                if (frm.ShowDialog() != DialogResult.OK) return null;
                editItem = frm.info;
                var unitOfWork = IocContainer.UnitOfWork;
                var repsSig = unitOfWork.Of<SigInfo>();
                var find = await repsSig.FirstOrDefaultAsync(p => p.Id == editItem.Id);
                find.FreqUp = editItem.FreqUp;
                find.FreqDown = editItem.FreqDown;
                find.SigType = editItem.SigType;
                find.Band = editItem.Band;
                find.Snr = editItem.Snr;
                find.UpdateTime = DateTime.Now;
                var sig = await repsSig.AddOrUpdateAsync(find);
                await unitOfWork.SaveAsync();

                return editItem;
            }
            catch (Exception ex)
            {
                IocContainer.Logger.Error(ex, "保存信号信息异常");
                DxHelper.MsgBoxHelper.ShowError("保存信号信息异常");
                return null;
            }
        }
        private async Task<bool> DeleteSigInfo(List<SigInfo> list)
        {
            try
            {
                var ids = list.Select(p => p.Id);
                var unitOfWork = IocContainer.UnitOfWork;
                var repsSigDelay = unitOfWork.Of<SigDelay>();
                var delayItems = await repsSigDelay.FindAsync(p => ids.Contains(p.SigInfoId));
                await repsSigDelay.DeleteAsync(delayItems);
                var repsSig = unitOfWork.Of<SigInfo>();
                var delItems = await repsSig.FindAsync(p => ids.Contains(p.Id));
                await repsSig.DeleteAsync(delItems);
                await unitOfWork.SaveAsync();

                return true;
            }
            catch (Exception ex)
            {
                IocContainer.Logger.Error(ex, "删除信号信息异常");
                DxHelper.MsgBoxHelper.ShowError("删除信号信息异常");
                return false;
            }
        }
        private async Task<SigDelay> AddSigDelay()
        {
            try
            {
                var sigInfoId = gridViewSignal.GetFocusedRow() as SigInfo;
                if (sigInfoId == null) return null;
                SigDelayEditor frm = new SigDelayEditor(sigInfoId.Id);
                if (frm.ShowDialog() != DialogResult.OK) return null;
                var addItem = frm.info;
                var unitOfWork = IocContainer.UnitOfWork;
                var repsSigDelay = unitOfWork.Of<SigDelay>();
                addItem.SigInfoId = sigInfoId.Id;
                var sig = repsSigDelay.AddOrUpdateAsync(addItem);
                await unitOfWork.SaveAsync();

                return addItem;
            }
            catch (Exception ex)
            {
                IocContainer.Logger.Error(ex, "添加转发延迟异常");
                DxHelper.MsgBoxHelper.ShowError("添加转发延迟异常");
                return null;
            }
        }
        private async Task<SigDelay> EditSigDelay(SigDelay editItem)
        {
            try
            {
                var sigInfoId = gridViewSignal.GetFocusedRow() as SigInfo;
                if (sigInfoId == null) return null;
                SigDelayEditor frm = new SigDelayEditor(editItem, sigInfoId.Id);
                if (frm.ShowDialog() != DialogResult.OK) return null;
                editItem = frm.info;
                var unitOfWork = IocContainer.UnitOfWork;
                var repsSigDelay = unitOfWork.Of<SigDelay>();
                var find = await repsSigDelay.FirstOrDefaultAsync(p => p.Id == editItem.Id);
                find.SigInfoId = editItem.SigInfoId;
                find.SatInfoSatCode = editItem.SatInfoSatCode;
                find.Delay = editItem.Delay;
                await unitOfWork.SaveAsync();

                return editItem;
            }
            catch (Exception ex)
            {
                IocContainer.Logger.Error(ex, "保存转发延迟异常");
                DxHelper.MsgBoxHelper.ShowError("保存转发延迟异常");
                return null;
            }
        }
        private async Task<bool> DeleteSigDelay(List<SigDelay> list)
        {
            try
            {
                var ids = list.Select(p => p.Id);
                var unitOfWork = IocContainer.UnitOfWork;
                var repsSigDelay = unitOfWork.Of<SigDelay>();
                var delItems = await repsSigDelay.FindAsync(p => ids.Contains(p.Id));
                await repsSigDelay.DeleteAsync(delItems);
                await unitOfWork.SaveAsync();

                return true;
            }
            catch (Exception ex)
            {
                IocContainer.Logger.Error(ex, "删除转发延迟异常");
                DxHelper.MsgBoxHelper.ShowError("删除转发延迟异常");
                return false;
            }
        }

        private async void gridViewSignal_FocusedRowObjectChanged(object sender, DevExpress.XtraGrid.Views.Base.FocusedRowObjectChangedEventArgs e)
        {
            listSigDelay.Clear();
            var sigInfoId = gridViewSignal.GetFocusedRow() as SigInfo;
            if (sigInfoId == null) return;
            var unitOfWork = IocContainer.UnitOfWork;
            var repsSigDelay = unitOfWork.Of<SigDelay>();
            var repsSat = unitOfWork.Of<SatInfo>();
            var delayItems = await repsSigDelay.FindAsync(w => w.SigInfoId == sigInfoId.Id, p => p.SatInfo.SatName);
            var sats = await repsSat.GetAllAsync();
            foreach (var delayItem in delayItems)
            {
                SigDelay sigDelay = delayItem as SigDelay;
                var satInfo = sats.FirstOrDefault(f => f.SatCode == sigDelay.SatInfoSatCode);
                if (satInfo != null)
                {
                    sigDelay.Sat = $"[{satInfo.SatLon}°]{satInfo.SatName}({satInfo.SatCode})";
                }
                listSigDelay.Add(sigDelay);
            }
            gridViewSigDelay.RefreshData();
        }

        private async void gridViewSignal_DoubleClick(object sender, EventArgs e)
        {
            var editItem = gridViewSignal.GetFocusedRow() as SigInfo;
            if (editItem == null) return;
            await EditSigInfo(editItem);
        }

        private async void gridViewSigDelay_DoubleClick(object sender, EventArgs e)
        {
            var editItem = gridViewSigDelay.GetFocusedRow() as SigDelay;
            if (editItem == null) return;
            await EditSigDelay(editItem);

        }
    }
}