using FLY.Thick.Normal.IService;
using FLY.Thick.Normal.IService.IBulkDBServicePack;
using FLY.Thick.Normal.OBJ_INTERFACE;
using FObjBase;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;

namespace FLY.Thick.Normal.Client
{
    public class BulkDBServiceClient : FObj, IBulkDBService
    {
        IFConn mConn;
        UInt32 mServerID;
        public bool IsConnected { get; private set; }
        #region IBulkDBService
        /// <summary>
        /// 总数量，当它变化了，肯定有新数据
        /// </summary>
        public int Count { get; private set; } = 0;

        public int Mix { get; set; } = 6;

        public DateTime StartTime { get; private set; }

        public DateTime EndTime { get; private set; }

        public bool IsFinished { get; private set; }

        public event PropertyChangedEventHandler PropertyChanged;

        public event BulkDBTempFrameChangedEventHander TempFrameChanged;
        #endregion


        public BulkDBServiceClient() : this(FLY.Thick.Normal.OBJ_INTERFACE.OBJ_INTERFACE_ID.BULKDB_ID)
        {

        }
        public BulkDBServiceClient(UInt32 id)
        {
            mServerID = id;
        }


        #region IBulkDBService
        public void GetFrame(Pack_GetFrameRequest request, AsyncCBHandler AsyncDelegate, object AsyncContext)
        {
            string json = JsonConvert.SerializeObject(request);

            CurrObjSys.CallFunctionEx(mConn, mServerID, ID,
                BULKDB_OBJ_INTERFACE.CALL_GET_FRAME,
                Misc.Converter.StringToBytes(json),
                AsyncDelegate, AsyncContext);
        }

        public void GetHistogram(Pack_GetHistogramRequest request, AsyncCBHandler AsyncDelegate, object AsyncContext)
        {
            string json = JsonConvert.SerializeObject(request);

            CurrObjSys.CallFunctionEx(mConn, mServerID, ID,
                BULKDB_OBJ_INTERFACE.CALL_GET_HISTOGRAM,
                Misc.Converter.StringToBytes(json),
                AsyncDelegate, AsyncContext);
        }

        public void GetSample(Pack_GetSampleRequest request, AsyncCBHandler AsyncDelegate, object AsyncContext)
        {
            string json = JsonConvert.SerializeObject(request);

            CurrObjSys.CallFunctionEx(mConn, mServerID, ID,
                BULKDB_OBJ_INTERFACE.CALL_GET_SAMPLE,
                Misc.Converter.StringToBytes(json),
                AsyncDelegate, AsyncContext);
        }

        public void GetTrend(Pack_GetTrendRequest request, AsyncCBHandler AsyncDelegate, object AsyncContext)
        {
            string json = JsonConvert.SerializeObject(request);

            CurrObjSys.CallFunctionEx(mConn, mServerID, ID,
                BULKDB_OBJ_INTERFACE.CALL_GET_TREND,
                Misc.Converter.StringToBytes(json),
                AsyncDelegate, AsyncContext);
        }

        public void Apply()
        {
            BULKDB_OBJ_INTERFACE.Pack_Params p = new BULKDB_OBJ_INTERFACE.Pack_Params();
            p.Mix = Mix;
            
            string json = JsonConvert.SerializeObject(p);

            CurrObjSys.SetValueEx(mConn, mServerID, ID,
                BULKDB_OBJ_INTERFACE.SET_PARAMS,
                Misc.Converter.StringToBytes(json));
        }
        public void Finish()
        {
            CurrObjSys.CallFunctionEx(mConn, mServerID, ID,
                BULKDB_OBJ_INTERFACE.CALL_FINISH,
                null);
        }
        #endregion

        #region FObj
        public override void ConnectNotify(IFConn from)
        {
            mConn = from;
            IsConnected = from.IsConnected;
            if (from.IsConnected)
            {
                //获取所有数据，设置推送
                CurrObjSys.GetValueEx(
                    mConn, mServerID, ID,
                    BULKDB_OBJ_INTERFACE.GET_PARAMS);
                CurrObjSys.GetValueEx(
                    mConn, mServerID, ID,
                    BULKDB_OBJ_INTERFACE.GET_STATE);

                CurrObjSys.SenseConfigEx(
                    mConn, mServerID, ID,
                    0xffffffff,
                    SENSE_CONFIG.ADD);
            }
        }
        public override void PushGetValue(IFConn from, uint srcid, ushort memid, byte[] infodata)
        {
            switch (memid)
            {
                case BULKDB_OBJ_INTERFACE.GET_PARAMS:
                    {
                        string json = Misc.Converter.BytesToString(infodata);

                        var p = JsonConvert.DeserializeObject<BULKDB_OBJ_INTERFACE.Pack_Params>(json);

                        Mix = p.Mix;
                    }
                    break;
                case BULKDB_OBJ_INTERFACE.GET_STATE:
                    {
                        string json = Misc.Converter.BytesToString(infodata);

                        var p = JsonConvert.DeserializeObject<BULKDB_OBJ_INTERFACE.Pack_State>(json);
                        Count = p.Count;
                        StartTime = p.StartTime;
                        EndTime = p.EndTime;
                        IsFinished = p.IsFinished;
                    }
                    break;
            }
        }

        public override void PushInfo(IFConn from, uint srcid, ushort infoid, byte[] infodata)
        {
            switch (infoid)
            {
                case BULKDB_OBJ_INTERFACE.PUSH_TEMP_FRAME_CHANGED:
                    {
                        string json = Misc.Converter.BytesToString(infodata);
                        BulkDBTempFrameChangedEventArgs e = null;
                        try
                        {
                           e = JsonConvert.DeserializeObject<BulkDBTempFrameChangedEventArgs>(json);
                        }
                        catch(Exception ex)
                        {
                            throw new Exception($"BulkDBTempFrameChangedEventArgs 解析出错,json= {json}", ex);
                        }
                        TempFrameChanged?.Invoke(this, e);
                    }
                    break;
                default:
                    PushGetValue(from, srcid, infoid, infodata);
                    break;
            }
            
        }

        public override void PushCallFunction(IFConn from, uint srcid, uint magic, ushort funcid, byte[] retdata, object AsyncDelegate, object AsyncContext)
        {
            switch (funcid)
            {
                case BULKDB_OBJ_INTERFACE.CALL_GET_FRAME:
                    {
                        string json = Misc.Converter.BytesToString(retdata);
                        var reponse = JsonConvert.DeserializeObject<Pack_GetFrameReponse>(json);
                        ((AsyncCBHandler)(AsyncDelegate))(AsyncContext, reponse);
                    }
                    break;
                case BULKDB_OBJ_INTERFACE.CALL_GET_TREND:
                    {
                        string json = Misc.Converter.BytesToString(retdata);
                        var reponse = JsonConvert.DeserializeObject<Pack_GetTrendReponse>(json);
                        ((AsyncCBHandler)(AsyncDelegate))(AsyncContext, reponse);
                    }
                    break;
                case BULKDB_OBJ_INTERFACE.CALL_GET_HISTOGRAM:
                    {
                        string json = Misc.Converter.BytesToString(retdata);
                        var reponse = JsonConvert.DeserializeObject<Pack_GetHistogramReponse>(json);
                        ((AsyncCBHandler)(AsyncDelegate))(AsyncContext, reponse);
                    }
                    break;
                case BULKDB_OBJ_INTERFACE.CALL_GET_SAMPLE:
                    {
                        string json = Misc.Converter.BytesToString(retdata);
                        var reponse = JsonConvert.DeserializeObject<Pack_GetSampleReponse>(json);
                        ((AsyncCBHandler)(AsyncDelegate))(AsyncContext, reponse);
                    }
                    break;
            }
        }


        #endregion
    }
}