using FLY.Thick.Blowing.IService;
using FLY.Thick.Blowing.IService.IBulkDBServicePack;
using FObjBase;
using Misc;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace FLY.Thick.Blowing.Server.Model
{
    /// <summary>
    /// 提供接口，让别人获取 整理好的 当前生产，或之前生产的数据。
    /// 从LocalDb 获取数据， 或从 直接从数据获取数据
    /// 
    /// 与HistoryDb，成对。 
    /// HistoryDb 是写
    /// BulkDb 是读
    /// </summary>
    public class BulkDb : IBulkDbService
    {
        /// <summary>
        /// 本地数据库
        /// </summary>
        public LocalDb localDb;
        DbModel dbModel;
        IShareDbService shareDb;
        /// <summary>
        /// 数据库总数量，当它变化了，肯定有新数据
        /// </summary>
        public int Count { get; set; }

        /// <summary>
        /// 开始产生数据时间
        /// </summary>
        public DateTime StartTime { get; private set; }

        /// <summary>
        /// 最后产生数据时间
        /// </summary>
        public DateTime EndTime { get; private set; }

        /// <summary>
        /// 当前生产，已经结束，已经下辊了
        /// </summary>
        public bool IsFinished { get; private set; }

        /// <summary>
        /// 
        /// </summary>
        public event PropertyChangedEventHandler PropertyChanged;

        /// <summary>
        /// 动态数据推送
        /// </summary>
        public event BulkDBTempFrameChangedEventHander TempFrameChanged;

        /// <summary>
        /// 
        /// </summary>
        public BulkDb()
        {

        }

        /// <summary>
        /// 写入动态数据
        /// </summary>
        /// <param name="startIndex"></param>
        /// <param name="D"></param>
        public void SetTempFrame(int startIndex, double[] D)
        {
            TempFrameChanged?.Invoke(this, new BulkDBTempFrameChangedEventArgs() { StartIndex = startIndex, D = D });
        }



        /// <summary>
        /// 
        /// </summary>
        /// <param name="shareDb"></param>
        /// <param name="localDb"></param>
        /// <param name="dbModel"></param>
        public void Init(IShareDbService shareDb, 
             LocalDb localDb, DbModel dbModel)
        {
            this.localDb = localDb;

            this.dbModel = dbModel;
            this.shareDb = shareDb;

            LocalDBLoad();


            Misc.BindingOperations.SetBinding(localDb, "ProfileStartTime", this, "StartTime");
            Misc.BindingOperations.SetBinding(localDb, "ProfileEndTime", this, "EndTime");
            Misc.BindingOperations.SetBinding(localDb, "IsProfileFinished", this, "IsFinished");
            
            shareDb.ScanDataChanged += ShareDB_ScanDataAdded;

        }

        private void ShareDB_ScanDataAdded(object sender, IService.IShareDBServicePack.ScanDataChangedEventArgs e)
        {
            Count++;
            //await Task.Factory.StartNew(() =>
            //{
            //    var n = dBModel.sqliteHelper.ExecuteScalar($"SELECT COUNT(*) FROM {dBModel.TbScanData.TableName}");
            //    Count = System.Convert.ToInt32(n);
            //});
        }

        /// <summary>
        /// 加载数据库中最后1次订单数据到 本地
        /// </summary>
        void LocalDBLoad()
        {
            var reponse = dbModel.sqliteHelper.ExecuteScalar($"SELECT MAX(ID) FROM {dbModel.TbProfile.TableName}");
            if (reponse is DBNull)
            {
                localDb.ProfileStartTime = DateTime.MinValue;
                localDb.ProfileEndTime = DateTime.MinValue;
                localDb.IsProfileFinished = true;
            }
            else
            {
                long maxid = System.Convert.ToInt64(reponse);
                var profile = dbModel.TbProfile.Find($"WHERE ID = {maxid}").First();
                localDb.CurrProfile = profile;
                localDb.ProfileStartTime = profile.StartTime;
                localDb.ProfileEndTime = profile.EndTime;
                localDb.IsProfileFinished = profile.IsFinished;
            }
            
            var n = dbModel.sqliteHelper.ExecuteScalar($"SELECT COUNT(*) FROM {dbModel.TbScanData.TableName}");
            Count = System.Convert.ToInt32(n);
        }
        
        /// <summary>
        /// 获取N幅数据,需要异步
        /// </summary>
        /// <param name="request"></param>
        /// <param name="AsyncDelegate"></param>
        /// <param name="AsyncContext"></param>
        public async void GetFrame(Pack_GetFrameRequest request, AsyncCBHandler AsyncDelegate, object AsyncContext)
        {
            Pack_GetFrameReponse reponse = new Pack_GetFrameReponse();
            reponse.Request = request;
            reponse.Values = new List<Lc_ScanData>();
            if (request.Count > 10)//数量限制，避免死机
                request.Count = 10;

            await Task.Factory.StartNew(() =>
            {
                var db_scandatas = dbModel.TbScanData.Find($"ORDER BY ID LIMIT {request.Index},{request.Count}");
                var lc_scanDatas = Lc_AutoMapperProfile.Mapper.Map<List<Db_ScanData>, List<Lc_ScanData>>(db_scandatas);
                reponse.Values.AddRange(lc_scanDatas);
            });

            AsyncDelegate(AsyncContext, reponse);
        }

        /// <summary>
        /// 获取纵向趋势图
        /// </summary>
        /// <param name="request"></param>
        /// <param name="AsyncDelegate"></param>
        /// <param name="AsyncContext"></param>
        public async void GetTrend(Pack_GetTrendRequest request, AsyncCBHandler AsyncDelegate, object AsyncContext)
        {
            //TODO 需要异步
            Pack_GetTrendReponse reponse = new Pack_GetTrendReponse();
            reponse.Request = request;
            reponse.Values = new List<TrendValue>();
            if (request.Count > 400)//数量限制，避免死机
                request.Count = 400;
            await Task.Factory.StartNew(() =>
            {
                var db_scandatas = dbModel.TbScanData.Find($"ORDER BY ID LIMIT {request.Index},{request.Count}");
                var lc_scanDatas = Lc_AutoMapperProfile.Mapper.Map<List<Db_ScanData>, List<Lc_ScanData>>(db_scandatas);
                reponse.Values.AddRange(lc_scanDatas.Select(sd =>
                   {
                       double avg = sd.Thicks.AverageNoNull();
                       double sigma = sd.Thicks.Sigma();
                       return new TrendValue()
                       {
                           Sigma = sigma,
                           Value = avg,
                           Time = sd.Time
                       };
                   }));
            });
            AsyncDelegate(AsyncContext, reponse);
        }

        /// <summary>
        /// 完成
        /// </summary>
        public void Finish()
        {
            shareDb.FinishProfile();
        }

    }
}