using FLY.FeedbackRenZiJia.Common;
using FLY.FeedbackRenZiJia.IService;
using FObjBase;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace FLY.FeedbackRenZiJia.OBJ_INTERFACE
{
    public class HEATBUF_OBJ_INTERFACE
    {
        #region pack
        public class Pack_Params : IPack
        {
            
            public List<int> HeatEffectCurve;
            public int StableRange;
            public int StableRange0;
            public Double ThresholdR;
            public int ThresholdMaxMin;
            public int ThresholdSigmaMax;
            public bool IsUsedLocalKp;
            public double LocalKp;

            #region IPack 成员

            public byte[] ToBytes()
            {
                List<byte> buf = new List<byte>();

                if (HeatEffectCurve != null)
                {
                    int len = HeatEffectCurve.Count();
                    buf.AddRange(BitConverter.GetBytes(len));
                    for (int i = 0; i < len; i++)
                    {
                        buf.AddRange(BitConverter.GetBytes(HeatEffectCurve[i]));
                    }
                }
                else
                {
                    buf.AddRange(BitConverter.GetBytes(0));
                }
                buf.AddRange(BitConverter.GetBytes(StableRange));
                buf.AddRange(BitConverter.GetBytes(StableRange0));
                buf.AddRange(BitConverter.GetBytes(ThresholdR));
                buf.AddRange(BitConverter.GetBytes(ThresholdMaxMin));
                buf.AddRange(BitConverter.GetBytes(ThresholdSigmaMax));
                buf.AddRange(BitConverter.GetBytes(IsUsedLocalKp));
                buf.AddRange(BitConverter.GetBytes(LocalKp));

                return buf.ToArray();
            }

            public bool TryParse(byte[] value)
            {
                int cnt = 4;
                if (value.Length < cnt)
                    return false;

                int idx = 0;
                int len = BitConverter.ToInt32(value, idx);
                idx += 4;
                if (len > 0)
                {
                    cnt += len * 4;

                    if (value.Length < cnt)
                        return false;
                    HeatEffectCurve = new List<int>();
                    for (int i = 0; i < len; i++)
                    {
                        HeatEffectCurve.Add(BitConverter.ToInt32(value, idx));
                        idx += 4;
                    }
                }

                cnt += 4 + 4 + 8 + 4 + 4 + 1 + 8;
                if (value.Length < cnt)
                    return false;
                


                StableRange = BitConverter.ToInt32(value, idx);
                idx += 4;

                StableRange0 = BitConverter.ToInt32(value, idx);
                idx += 4;

                ThresholdR = BitConverter.ToDouble(value, idx);
                idx += 8;

                ThresholdMaxMin = BitConverter.ToInt32(value, idx);
                idx += 4;

                ThresholdSigmaMax = BitConverter.ToInt32(value, idx);
                idx += 4;

                IsUsedLocalKp = BitConverter.ToBoolean(value, idx);
                idx++;

                LocalKp = BitConverter.ToDouble(value, idx);
                idx += 8;

                return true;
            }

            #endregion
        }
        public class Pack_Status : IPack
        {
            public TimeSpan Delay;
            public bool IsIntoAutoONo;
            public EAutoONoResult AutoONoResult;

            public int BestOrgBoltNo;
            public double BestKp;
            public double MaxR;
            public double MaxMin;
            public STABILITY Stability;
            public double CurrR;
            public double Curr2Sigma;
            public double CurrBreakUp;
            public DateTime CurrTime;
            public Misc.DIRECTION CurrDirection;
            #region IPack 成员

            public byte[] ToBytes()
            {
                List<byte> buf = new List<byte>();
                buf.AddRange(BitConverter.GetBytes(Delay.Ticks));//8
                buf.AddRange(BitConverter.GetBytes(IsIntoAutoONo));//1
                buf.AddRange(BitConverter.GetBytes((int)AutoONoResult));//4

                buf.AddRange(BitConverter.GetBytes(BestOrgBoltNo));//4
                buf.AddRange(BitConverter.GetBytes(BestKp));//8
                buf.AddRange(BitConverter.GetBytes(MaxR));//8
                buf.AddRange(BitConverter.GetBytes(MaxMin));//8
                buf.AddRange(BitConverter.GetBytes((int)Stability));//4

                buf.AddRange(BitConverter.GetBytes(CurrR));//8
                buf.AddRange(BitConverter.GetBytes(Curr2Sigma));//8
                buf.AddRange(BitConverter.GetBytes(CurrBreakUp));//8

                buf.AddRange(BitConverter.GetBytes(CurrTime.Ticks));//8
                buf.AddRange(BitConverter.GetBytes((int)CurrDirection));//4
                return buf.ToArray();
            }

            public bool TryParse(byte[] value)
            {
                int cnt = 8 + 1 + 4;
                cnt += 4 + 8 + 8 + 8 + 4;
                cnt += 8 + 8 + 8;
                cnt += 8 + 4;
                if (value.Length < cnt)
                    return false;
                int idx = 0;
                Delay = new TimeSpan(BitConverter.ToInt64(value, idx));
                idx += 8;

                IsIntoAutoONo = BitConverter.ToBoolean(value, idx);
                idx += 1;

                AutoONoResult = (EAutoONoResult)BitConverter.ToInt32(value, idx);
                idx += 4;



                BestOrgBoltNo = BitConverter.ToInt32(value, idx);
                idx += 4;

                BestKp = BitConverter.ToDouble(value, idx);
                idx += 8;

                MaxR = BitConverter.ToDouble(value, idx);
                idx += 8;

                MaxMin = BitConverter.ToDouble(value, idx);
                idx += 8;

                Stability = (STABILITY)BitConverter.ToInt32(value, idx);
                idx += 4;



                CurrR = BitConverter.ToDouble(value, idx);
                idx += 8;

                Curr2Sigma = BitConverter.ToDouble(value, idx);
                idx += 8;

                CurrBreakUp = BitConverter.ToDouble(value, idx);
                idx += 8;



                CurrTime = new DateTime(BitConverter.ToInt64(value, idx));
                idx += 8;

                CurrDirection = (Misc.DIRECTION)BitConverter.ToInt32(value, idx);
                idx += 4;
                return true;
            }

            #endregion
        }
        
        public class Pack_GetHeatsDataRequest
        {
            public int bookmark;
            #region IPack 成员

            public byte[] ToBytes()
            {
                List<byte> buf = new List<byte>();
                buf.AddRange(BitConverter.GetBytes(bookmark));
                return buf.ToArray();
            }

            public bool TryParse(byte[] value)
            {
                if (value.Length < 4)
                    return false;
                int idx = 0;
                bookmark = BitConverter.ToInt32(value, idx);
                idx += 4;
                return true;
            }

            #endregion
        }

        public class Pack_GetBoltHeatRecordRequest
        {
            public int no;
            #region IPack 成员

            public byte[] ToBytes()
            {
                List<byte> buf = new List<byte>();
                buf.AddRange(BitConverter.GetBytes(no));
                return buf.ToArray();
            }

            public bool TryParse(byte[] value)
            {
                if (value.Length < 4)
                    return false;
                int idx = 0;
                no = BitConverter.ToInt32(value, idx);
                idx += 4;
                return true;
            }

            #endregion
        }
        public class Pack_BM : IPack
        {
            public int firstbm;
            public int lastbm;

            #region IPack 成员

            public byte[] ToBytes()
            {
                List<byte> buf = new List<byte>();
                buf.AddRange(BitConverter.GetBytes(firstbm));
                buf.AddRange(BitConverter.GetBytes(lastbm));
                return buf.ToArray();
            }

            public bool TryParse(byte[] value)
            {
                if (value.Length < 4 + 4)
                    return false;
                int idx = 0;
                firstbm = BitConverter.ToInt32(value, idx);
                idx += 4;
                lastbm = BitConverter.ToInt32(value, idx);
                idx += 4;
                return true;
            }

            #endregion
        }

        public class Pack_IsStables
        {
            public bool[] isStables;
            #region IPack 成员

            public byte[] ToBytes()
            {
                List<byte> buf = new List<byte>();
                if (isStables != null && isStables.Count() > 0)
                {
                    buf.AddRange(BitConverter.GetBytes(isStables.Count()));
                    for (int i = 0; i < isStables.Count(); i++)
                    {
                        buf.AddRange(BitConverter.GetBytes(isStables[i]));
                    }
                }
                else
                {
                    buf.AddRange(BitConverter.GetBytes(0));
                }
                return buf.ToArray();
            }

            public bool TryParse(byte[] value)
            {
                int cnt = 4;
                if (value.Length < cnt)
                    return false;
                int idx = 0;
                int len = BitConverter.ToInt32(value, idx);
                idx += 4;
                if (len > 0)
                {
                    cnt += len;
                    if (value.Length < cnt)
                        return false;
                    isStables = new bool[len];
                    for (int i = 0; i < len; i++)
                    {
                        isStables[i] = BitConverter.ToBoolean(value, idx);
                        idx++;
                    }
                }
                else
                {
                    isStables = null;
                }
                return true;
            }

            #endregion
        }

        #endregion

        #region Get
        /// <summary>
        /// Pack_Params
        /// </summary>
        public const UInt16 GET_PARAMS = 1;//参数
        /// <summary>
        /// Pack_Status
        /// </summary>
        public const UInt16 GET_STATE = 2;

        /// <summary>
        /// Pack_BM
        /// </summary>
        public const UInt16 GET_BM = 12;

        /// <summary>
        /// Pack_IsStables
        /// </summary>
        public const UInt16 GET_ISSTABLES = 13;

        #endregion

        #region Set
        /// <summary>
        /// Pack_Params
        /// </summary>
        public const UInt16 SET_PARAMS = 1;//参数

        #endregion

        #region Call

        /// <summary>
        /// request:Pack_GetHeatsDataRequest
        /// reponse:FlyData_FeedbackHeat
        /// </summary>
        public const UInt16 CALL_GETHEATDATA = 12;
        /// <summary>
        /// request:null
        /// reponse:null
        /// </summary>
        public const UInt16 CALL_CLEARBOLTHEAT = 13;
        /// <summary>
        /// request: Pack_GetBoltHeatRecordRequest
        /// reponse:FlyData_BoltHeatRecord
        /// </summary>
        public const UInt16 CALL_GETBOLTHEATRECORD = 14;
        #endregion

        #region Push
        /// <summary>
        /// Pack_Params
        /// </summary>
        public const UInt16 PUSH_PARAMS = 1;//参数

        /// <summary>
        /// Pack_Status
        /// </summary>
        public const UInt16 PUSH_STATE = 2;

        /// <summary>
        /// Pack_BM
        /// </summary>
        public const UInt16 PUSH_BM = 12;

        /// <summary>
        /// Pack_IsStables
        /// </summary>
        public const UInt16 PUSH_ISSTABLES = 13;
        #endregion

    }
}