using NLog;
using OrpaonEMS.Core.EventHandMsg;
using OrpaonEMS.Core;
using OrpaonEMS.Model;
using Prism.Mvvm;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Timers;
using System.Collections.ObjectModel;
using OrpaonEMS.App.Models;

namespace OrpaonEMS.App.Services
{
    /// <summary>
    /// 数据分析模型
    /// 数据统计模型
    /// </summary>
    public class PwAnalyzeService : BindableBase
    {
        /// <summary>
        /// 周期定时器
        /// </summary>
        private System.Timers.Timer CycleTimer { get; set; }

        public ILogService LogService { get; }

        /// <summary>
        /// 实例化函数
        /// </summary>
        public PwAnalyzeService(ILogService logService,
            IFreeSql freeSql,
            ConfigDataService configDataService,
            SolarEnergyService solarEnergyService,
            InPowerPCSDataService inPowerPCSDataService)
        {

            LogService = logService;
            this.freeSql = freeSql;
            ConfigDataService = configDataService;
            SolarEnergyService = solarEnergyService;
            InPowerPCSDataService = inPowerPCSDataService;

            //10秒触发一次
            CycleTimer = new System.Timers.Timer(10000);
            CycleTimer.Elapsed += CycleAction;
            CycleTimer.AutoReset = true;
            CycleTimer.Enabled = true;

            LogService.Info($"时间:{DateTime.Now.ToString()}-【PwAnalyze-开始了");

            _CurMinInfo = DateTime.Now.Minute;

            LoadInitialHourDataByDb();
            //LoadInitStartData();

        }

        /// <summary>
        /// 周期调用这个方法
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        /// <exception cref="NotImplementedException"></exception>
        private void CycleAction(object? sender, ElapsedEventArgs e)
        {
            try
            {
                //如果Execute执行的是一个很耗时的方法，会导致方法未执行完毕，定时器又启动了一个线程来执行Execute方法
                CycleTimer.Stop(); //先关闭定时器

                ////先给值
                //CurHourInfo = DateTime.Now.Hour;

                CurMinInfo = DateTime.Now.Minute;
                CurDayInfo = DateTime.Now.Day;
                CurMonthInfo = DateTime.Now.Month;
                CurYearInfo = DateTime.Now.Year;

                CycleTimer.Start(); //执行完毕后再开启器
            }
            catch (Exception ex)
            {
                CycleTimer.Start(); //执行完毕后再开启器
                LogService.Info($"时间:{DateTime.Now.ToString()}-【PwAnalyze-CycleAction】-{ex.Message}");
            }
        }


        private ObservableCollection<HourData> _ListLastHourData = new ObservableCollection<HourData>();
        /// <summary>
        /// 日小数数据集合
        /// </summary>
        public ObservableCollection<HourData> ListLastHourData
        {
            get { return _ListLastHourData; }
            set { _ListLastHourData = value; RaisePropertyChanged(); }
        }

        #region 年月日 时分 触发动作

        private int _CurMinInfo;
        /// <summary>
        /// 当前的分钟信息
        /// 用分钟用于触发小时的数据
        /// </summary>
        private int CurMinInfo
        {
            get { return _CurMinInfo; }
            set
            {
                EsAnalyse.TotalChargPw = InPowerPCSDataService.AccChargPw;
                EsAnalyse.TotalDisChargPw = InPowerPCSDataService.AccDisChargPw;
                //日充放电量
                EsAnalyse.DayChargPw = InPowerPCSDataService.AccChargPw - EsAnalyse.DayStartPointChargPw;
                EsAnalyse.DayDisChargPw = InPowerPCSDataService.AccDisChargPw - EsAnalyse.DayStartPointDisChargPw;
                //月充放电量
                EsAnalyse.MonthChargPw = EsAnalyse.TotalChargPw - EsAnalyse.MonthStartPointChargPw;
                EsAnalyse.MonthDisChargPw = EsAnalyse.TotalDisChargPw - EsAnalyse.MonthStartPointDisChargPw;
                //年充放电量
                EsAnalyse.YearChargPw = EsAnalyse.TotalChargPw - EsAnalyse.YearStartPointChargPw;
                EsAnalyse.YearDisChargPw = EsAnalyse.TotalDisChargPw - EsAnalyse.YearStartPointDisChargPw;

                SolarAnalyse.TotalChargPw = SolarEnergyService.AccPw;
                SolarAnalyse.DayChargPw = SolarEnergyService.AccPw - SolarAnalyse.DayStartPointPw;
                SolarAnalyse.MonthChargPw = SolarEnergyService.AccPw - SolarAnalyse.MonthStartPointPw;
                SolarAnalyse.YearChargPw = SolarEnergyService.AccPw - SolarAnalyse.YearStartPointPw;

                CoolAnalyse.DayPw = 1;
                CoolAnalyse.DayRunTime = 1;
                CoolAnalyse.DayActionCount = 1;


                if (_CurMinInfo != value)
                {
                    //DayChargPw = energyStorage.AcrelMeters.TotalInPWh - DayStartPointChargPw;
                    //DayDisChargPw = energyStorage.AcrelMeters.TotalOutPWh - DayStartPointDisChargPw;
                    _CurMinInfo = value;
                    //分钟改变和分钟数据为0那么需要触发小时保存数据
                    if (value == 59)
                    {
                        RecordHourData();
                    }
                }
            }
        }

        //private int _CurHourInfo;
        ///// <summary>
        ///// 当前的小时信息
        ///// 用户触发天的信息
        ///// </summary>
        //private int CurHourInfo
        //{
        //    get { return _CurHourInfo; }
        //    set
        //    {
        //        if (_CurHourInfo != value)
        //        {
        //            //小时改变和那么需要触发天的数据获取
        //            if (value == 0)
        //            {
        //                StartDayInfo();
        //            }
        //            _CurHourInfo = value;
        //        }
        //    }
        //}


        private int _CurDayInfo;
        /// <summary>
        /// 当前的天的信息
        /// </summary>
        private int CurDayInfo
        {
            get { return _CurDayInfo; }
            set
            {
                if (_CurDayInfo != value)
                {
                    var DayInitData = GetHistoryDataInfo(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, 0);
                    if (DayInitData != null)
                    {
                        //不为空的话，则赋值。获取本月第一个小时的数据作为本月的初始数据信息
                        EsAnalyse.DayStartPointChargPw = DayInitData.EsHourPointChargValue;
                        EsAnalyse.DayStartPointDisChargPw = DayInitData.EsHourPointDisChargValue;

                        SolarAnalyse.DayStartPointPw = DayInitData.SolarHourPointValue;
                    }
                    else
                    {
                        EsAnalyse.DayStartPointChargPw = GetEsAccChargPw();
                        EsAnalyse.DayStartPointDisChargPw = GetEsAccDisChargPw();

                        SolarAnalyse.DayStartPointPw = SolarEnergyService.AccPw;
                    }
                    _CurDayInfo = value;
                }
            }
        }

        private int _CurMonthInfo;
        /// <summary>
        /// 当前的月的信息
        /// </summary>
        private int CurMonthInfo
        {
            get { return _CurMonthInfo; }
            set
            {
                if (_CurMonthInfo != value)
                {
                    //月的改变和那么需要触月的数据获取
                    //需要获取当前月的第一天的数据信息
                    var MonthInitData = GetHistoryDataInfo(DateTime.Now.Year, DateTime.Now.Month, 1, 0);
                    if (MonthInitData != null)
                    {
                        //不为空的话，则赋值。获取本月第一个小时的数据作为本月的初始数据信息
                        EsAnalyse.MonthStartPointChargPw = MonthInitData.EsHourPointChargValue;
                        EsAnalyse.MonthStartPointDisChargPw = MonthInitData.EsHourPointDisChargValue;

                        SolarAnalyse.MonthStartPointPw = MonthInitData.SolarHourPointValue;
                    }
                    else
                    {
                        EsAnalyse.MonthStartPointChargPw = GetEsAccChargPw();
                        EsAnalyse.MonthStartPointDisChargPw = GetEsAccDisChargPw();

                        SolarAnalyse.MonthStartPointPw = SolarEnergyService.AccPw;
                    }
                    _CurMonthInfo = value;
                }
            }
        }


        private int _CurYearInfo;
        /// <summary>
        /// 当前的年的信息
        /// </summary>
        private int CurYearInfo
        {
            get { return _CurYearInfo; }
            set
            {
                if (_CurYearInfo != value)
                {
                    //var data = new DateTime(DateTime.Now.Year, 1, 1, 0, 0, 1).ToString("yyyy-MM-dd");

                    //需要获取当前年的第一天的数据信息
                    var YearInitData = GetHistoryDataInfo(DateTime.Now.Year, 1, 1, 0);
                    if (YearInitData != null)
                    {
                        //不为空的话，则赋值。获取新年第一个小时的数据作为本年的初始数据信息
                        EsAnalyse.YearStartPointChargPw = YearInitData.EsHourPointChargValue;
                        EsAnalyse.YearStartPointDisChargPw = YearInitData.EsHourPointDisChargValue;

                        SolarAnalyse.YearStartPointPw = YearInitData.SolarHourPointValue;
                    }
                    else
                    {
                        EsAnalyse.YearStartPointChargPw = GetEsAccChargPw();
                        EsAnalyse.YearStartPointDisChargPw = GetEsAccDisChargPw();

                        SolarAnalyse.YearStartPointPw = SolarEnergyService.AccPw;
                    }

                    _CurYearInfo = value;
                }
            }
        }

        /// <summary>
        /// ConfigDbData Category数据
        /// </summary>
        private string Category { get; set; } = "PwAnalyze";

        /// <summary>
        /// 关闭App的操作信息 防止信息丢失
        /// 保存日初始数据
        /// 保存月度的初始数据
        /// 保存年度的初始数据
        /// -----舍弃
        /// </summary>
        private void CloseAppAction()
        {
            try
            {
                ////ConfigDbData freeSql
                //var data = freeSql.Select<ConfigDbData>().Where(a => a.Category == Category && a.Name == "1").ToList();
                //if (data.Count > 0)
                //{
                //储能
                freeSql.Update<ConfigDbData>()
                    .Set(a => a.Value, EsAnalyse.DayStartPointChargPw.ToString("f2"))
                    .Set(a => a.CreateTime, DateTime.Now)
                    .Where(a => a.Category == Category && a.Name == "DayStartPointChargPw")
                    .ExecuteAffrows();

                freeSql.Update<ConfigDbData>()
                    .Set(a => a.Value, EsAnalyse.DayStartPointDisChargPw.ToString("f2"))
                    .Set(a => a.CreateTime, DateTime.Now)
                    .Where(a => a.Category == Category && a.Name == "DayStartPointDisChargPw")
                    .ExecuteAffrows();

                freeSql.Update<ConfigDbData>()
                   .Set(a => a.Value, EsAnalyse.MonthStartPointChargPw.ToString("f2"))
                   .Set(a => a.CreateTime, DateTime.Now)
                   .Where(a => a.Category == Category && a.Name == "MonthStartPointChargPw")
                   .ExecuteAffrows();

                freeSql.Update<ConfigDbData>()
                  .Set(a => a.Value, EsAnalyse.MonthStartPointDisChargPw.ToString("f2"))
                  .Set(a => a.CreateTime, DateTime.Now)
                  .Where(a => a.Category == Category && a.Name == "MonthStartPointDisChargPw")
                  .ExecuteAffrows();

                freeSql.Update<ConfigDbData>()
                  .Set(a => a.Value, EsAnalyse.YearStartPointChargPw.ToString("f2"))
                  .Set(a => a.CreateTime, DateTime.Now)
                  .Where(a => a.Category == Category && a.Name == "YearStartPointChargPw")
                  .ExecuteAffrows();

                freeSql.Update<ConfigDbData>()
                  .Set(a => a.Value, EsAnalyse.YearStartPointDisChargPw.ToString("f2"))
                  .Set(a => a.CreateTime, DateTime.Now)
                  .Where(a => a.Category == Category && a.Name == "YearStartPointDisChargPw")
                  .ExecuteAffrows();

                //光伏
                freeSql.Update<ConfigDbData>()
                  .Set(a => a.Value, SolarAnalyse.DayStartPointPw.ToString("f2"))
                  .Set(a => a.CreateTime, DateTime.Now)
                  .Where(a => a.Category == Category && a.Name == "DayStartPointPw")
                  .ExecuteAffrows();

                freeSql.Update<ConfigDbData>()
                 .Set(a => a.Value, SolarAnalyse.MonthStartPointPw.ToString("f2"))
                 .Set(a => a.CreateTime, DateTime.Now)
                 .Where(a => a.Category == Category && a.Name == "MonthStartPointPw")
                 .ExecuteAffrows();

                freeSql.Update<ConfigDbData>()
                 .Set(a => a.Value, SolarAnalyse.YearStartPointPw.ToString("f2"))
                 .Set(a => a.CreateTime, DateTime.Now)
                 .Where(a => a.Category == Category && a.Name == "YearStartPointPw")
                 .ExecuteAffrows();
                //}
            }
            catch (Exception ex)
            {
                LogService.Info($"时间:{DateTime.Now.ToString()}-【CloseAppAction】-{ex.Message}");
            }
        }


        /// <summary>
        /// 获取初始的数据
        /// -----舍弃
        /// </summary>
        private void LoadInitStartData()
        {
            try
            {
                EsAnalyse.DayStartPointChargPw = double.Parse(freeSql.Select<ConfigDbData>().Where(a => a.Category == Category && a.Name == "DayStartPointChargPw").First().Value);
                EsAnalyse.DayStartPointDisChargPw = double.Parse(freeSql.Select<ConfigDbData>().Where(a => a.Category == Category && a.Name == "DayStartPointDisChargPw").First().Value);
                EsAnalyse.MonthStartPointChargPw = double.Parse(freeSql.Select<ConfigDbData>().Where(a => a.Category == Category && a.Name == "MonthStartPointChargPw").First().Value);
                EsAnalyse.MonthStartPointDisChargPw = double.Parse(freeSql.Select<ConfigDbData>().Where(a => a.Category == Category && a.Name == "MonthStartPointDisChargPw").First().Value);
                EsAnalyse.YearStartPointChargPw = double.Parse(freeSql.Select<ConfigDbData>().Where(a => a.Category == Category && a.Name == "YearStartPointChargPw").First().Value);
                EsAnalyse.YearStartPointDisChargPw = double.Parse(freeSql.Select<ConfigDbData>().Where(a => a.Category == Category && a.Name == "YearStartPointDisChargPw").First().Value);

                SolarAnalyse.DayStartPointPw = double.Parse(freeSql.Select<ConfigDbData>().Where(a => a.Category == Category && a.Name == "DayStartPointPw").First().Value);
                SolarAnalyse.MonthStartPointPw = double.Parse(freeSql.Select<ConfigDbData>().Where(a => a.Category == Category && a.Name == "MonthStartPointPw").First().Value);
                SolarAnalyse.YearStartPointPw = double.Parse(freeSql.Select<ConfigDbData>().Where(a => a.Category == Category && a.Name == "YearStartPointPw").First().Value);

            }
            catch (Exception ex)
            {
                LogService.Info($"时间:{DateTime.Now.ToString()}-【CloseAppAction】-{ex.Message}");
            }
        }

        #endregion

        /// <summary>
        /// 上个小时保存的数据
        /// 保存的上个小时的数据
        /// </summary>
        private HourData LastHourEnergyData { get; set; }

        private IFreeSql freeSql { get; set; }
        /// <summary>
        /// 当前的配置服务
        /// </summary>
        public ConfigDataService ConfigDataService { get; }
        public SolarEnergyService SolarEnergyService { get; }
        public InPowerPCSDataService InPowerPCSDataService { get; }

        /// <summary>
        /// 记录小时数据
        /// </summary>
        private void RecordHourData()
        {
            try
            {
                ////小时充电量
                //var HourCharg = LastHourEnergyData != null ? energyStorage.AcrelMeters.TotalInPWh - LastHourEnergyData.Point_HourCharg : energyStorage.AcrelMeters.TotalInPWh;
                ////小时放电量
                //var HourDisCharg = LastHourEnergyData != null ? energyStorage.AcrelMeters.TotalOutPWh - LastHourEnergyData.Point_HourDisCharg : energyStorage.AcrelMeters.TotalOutPWh;

                var InsertData = freeSql.Insert<HourData>(new HourData()
                {
                    //WorkDay = int.Parse(DateTime.Now.ToString("yyyyMMdd")),
                    //Month = int.Parse(DateTime.Now.ToString("yyyyMM")),
                    //Year = int.Parse(DateTime.Now.ToString("yyyy")),
                    WorkDay = DateTime.Now.Day,
                    Month = DateTime.Now.Month,
                    Year = DateTime.Now.Year,
                    HourInfo = DateTime.Now.Hour,
                    
                    EsHourPointChargValue = GetEsAccChargPw(),
                    EsHourPointDisChargValue = GetEsAccDisChargPw(),
                    EsHourCharg = GetEsHourCharg(),
                    EsHourDisCharg = GetEsHourDisCharg(),
                    EsElePrice = ConfigDataService.CurPeakValleyConfig.Price,
                    EsHourRevenue = 0,

                    SolarHourPointValue = SolarEnergyService.AccPw,
                    SolarHourCharg = GetSolarHour(),
                    SolarElePrice = ConfigDataService.CurPeakValleyConfig.Price,
                    SolarHourRevenue = 0,
                }).ExecuteInserted();

                Console.WriteLine($"{DateTime.Now.ToString()}：小时数据触发");
                //保存小时数据成功
                if (InsertData.Count > 0)
                {
                    LastHourEnergyData = InsertData.FirstOrDefault();
                    ListLastHourData = GetDayHourData();

                }
            }
            catch (Exception ex)
            {
                LogService.Info($"时间:{DateTime.Now.ToString()}-【RecordHourData】-{ex.Message}");
            }


        }


        ///// <summary>
        ///// 开始一天的数据信息
        ///// 做数据的清除
        ///// 做开始数据的记录
        ///// </summary>
        //private void StartDayInfo()
        //{
        //    //EsAnalyse.DayStartPointChargPw = energyStorage.AcrelMeters.TotalInPWh;
        //    //EsAnalyse.DayStartPointDisChargPw = energyStorage.AcrelMeters.TotalOutPWh;
        //    EsAnalyse.DayStartPointChargPw = InPowerPCSDataService.AccChargPw;
        //    EsAnalyse.DayStartPointDisChargPw = InPowerPCSDataService.AccDisChargPw;
        //    SolarAnalyse.DayStartPointPw = SolarEnergyService.AccPw;

        //}


        /// <summary>
        /// 获取小时数据
        /// </summary>
        public ObservableCollection<HourData> GetDayHourData()
        {
            try
            {
                //获取最近12个小时的数据
                var Data = freeSql.Select<HourData>().OrderByDescending(a => a.CreateTime).Take(24).ToList();

                //可以计算这个里面的数据 比如汇总和计算小时电价等数据
                //foreach (var itemHour in Data)
                //{
                //    itemHour.HourValue = itemHour.HourDisCharg - itemHour.HourCharg;
                //}

                return new ObservableCollection<HourData>(Data);
            }
            catch (Exception ex)
            {
                LogService.Info($"时间:{DateTime.Now.ToString()}-【ExitPeakValley】-{ex.Message}");
                return new ObservableCollection<HourData>();
            }
        }

        /// <summary>
        /// 加载初始的数据
        /// </summary>
        /// <returns></returns>
        public void LoadInitialHourDataByDb()
        {
            //如果程序中间中断了一天，那么最新的作为上一个一个小时的数据，那么这个小时的数据会比较大，这个也没有问题，确保总数对的上即可。
            var FirstData = freeSql.Select<HourData>().OrderByDescending(a => a.CreateTime).Take(24).ToList();
            if (FirstData.Count > 0)
            {
                LastHourEnergyData = FirstData!.FirstOrDefault();
                ListLastHourData = new ObservableCollection<HourData>(FirstData);
            }
            else
            {
                LastHourEnergyData = new HourData();
            }
        }
        

        #region 统计信息

        /// <summary>
        /// 获取储能的总充电数据
        /// 取决于使用哪个数据仪表/PCS，封装成方法，方便替换
        /// </summary>
        /// <returns></returns>
        private double GetEsAccChargPw()
        {
            return InPowerPCSDataService.AccChargPw;
        }

        /// <summary>
        /// 获取储能的小时收益数据
        /// </summary>
        /// <returns></returns>
        private double GetEsHourRevenue(double price)
        {
            return (GetEsHourCharg() - GetEsHourDisCharg()) * price;
        }

        /// <summary>
        /// 获取储能的总放电数据
        /// 取决于使用哪个数据仪表/PCS，封装成方法，方便替换
        /// </summary>
        /// <returns></returns>
        private double GetEsAccDisChargPw()
        {
            return InPowerPCSDataService.AccDisChargPw;
        }

        /// <summary>
        /// 获取储能的充电小时数据
        /// </summary>
        /// <returns></returns>
        private double GetEsHourCharg()
        {
            return GetEsAccChargPw() - LastHourEnergyData.EsHourPointChargValue;
        }

        /// <summary>
        /// 获取储能的放电小时数据
        /// </summary>
        /// <returns></returns>
        private double GetEsHourDisCharg()
        {
            return GetEsAccDisChargPw() - LastHourEnergyData.EsHourPointDisChargValue;
        }

        /// <summary>
        /// 获取光伏的放电小时数据
        /// </summary>
        /// <returns></returns>
        private double GetSolarHour()
        {
            return SolarEnergyService.AccPw - LastHourEnergyData.SolarHourPointValue;

        }

        ///// <summary>
        ///// 新的一年，年的初始信息
        ///// </summary>
        ///// <returns></returns>
        //private void LoadYearInit()
        //{
        //    //获取今年第一天的数据历史信息
        //    freeSql.Select<HourData>().Where(a => a.Year == DateTime.Now.Year && a.Month ==)

        //}

        /// <summary>
        /// 获取年月日的信息
        /// </summary>
        /// <returns></returns>
        private HourData GetHistoryDataInfo(int Year, int Month, int Day, int hour)
        {
            //获取今年第一天的数据历史信息
            var Data = freeSql.Select<HourData>().Where(a => a.Year == Year && a.Month == Month && a.WorkDay == Day && a.HourInfo == hour).ToList();
            if (Data.Count > 0)
            {
                return Data.FirstOrDefault();
            }

            return null;
        }


        /// <summary>
        /// 光伏统计模型
        /// </summary>
        public SolarAnalyse SolarAnalyse { get; set; } = new SolarAnalyse();

        /// <summary>
        /// 储能统计模型
        /// </summary>
        public EsAnalyse EsAnalyse { get; set; } = new EsAnalyse();

        /// <summary>
        /// 液冷统计模型
        /// </summary>
        public CoolAnalyse CoolAnalyse { get; set; } = new CoolAnalyse();

        #endregion
    }
}