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

namespace FLY.FeedbackRenZiJia.OBJ_INTERFACE
{
    public class FEEDBACK_OBJ_INTERFACE
    {
        #region pack
        public class Pack_Params : IPack
        {
            public int step;
            public int delay;
            public bool hasCheck;
            public bool HasCheckFilmVelocity;
            #region IPack 成员

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

            public bool TryParse(byte[] value)
            {
                if (value.Length < (4+4+1))
                    return false;

                int idx = 0;

                step = BitConverter.ToInt32(value, idx);
                idx += 4;
                delay = BitConverter.ToInt32(value, idx);
                idx += 4;
                hasCheck = BitConverter.ToBoolean(value, idx);
                idx += 1;
                HasCheckFilmVelocity = BitConverter.ToBoolean(value, idx);
                idx += 1;
                return true;
            }

            #endregion
        }
        public class Pack_CallSmoothRequest:IPack
        {
            public double thresholdHeatSigma;
            #region IPack 成员

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

            public bool TryParse(byte[] value)
            {
                if (value.Length < ( 8 ))
                    return false;

                int idx = 0;

                thresholdHeatSigma = BitConverter.ToDouble(value, idx);
                idx += 8;
                return true;
            }

            #endregion
        }
        public class Pack_Status : IPack 
        {
            public int channelcnt;
            public int nbolts;

            public bool isConnected;

            public DateTime lastChangedTime;



            #region IPack 成员

            public byte[] ToBytes()
            {
                List<byte> buf = new List<byte>();
                buf.AddRange(BitConverter.GetBytes(channelcnt));
                buf.AddRange(BitConverter.GetBytes(nbolts));

                buf.AddRange(BitConverter.GetBytes(isConnected));

                

                buf.AddRange(BitConverter.GetBytes(lastChangedTime.Ticks));



                return buf.ToArray();
            }

            public bool TryParse(byte[] value)
            {
                if (value.Length < (4+4+1+8))
                    return false;
                int idx = 0;
                channelcnt = BitConverter.ToInt32(value, idx);
                idx += 4;
                nbolts = BitConverter.ToInt32(value, idx);
                idx += 4;

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

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

                return true;
            }

            #endregion
        }

        public class Pack_Enable : IPack 
        {
            public bool enable;

            #region IPack 成员

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

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

            #endregion
        }
        public class Pack_Error : IPack 
        {
            public bool hasFan;
            public bool hasEletric;
            public int checkno;
            public bool[] bads = null;

            #region IPack 成员

            public byte[] ToBytes()
            {
                List<byte> buf = new List<byte>();
                buf.AddRange(BitConverter.GetBytes(hasFan));
                buf.AddRange(BitConverter.GetBytes(hasEletric));
                buf.AddRange(BitConverter.GetBytes(checkno));
                if (bads != null)
                {
                    buf.AddRange(BitConverter.GetBytes(bads.Length));
                    for (int i = 0; i < bads.Length; i++)
                    {
                        buf.AddRange(BitConverter.GetBytes(bads[i]));
                    }
                }
                else 
                {
                    int len = 0;
                    buf.AddRange(BitConverter.GetBytes(len));
                }
                return buf.ToArray();
            }

            public bool TryParse(byte[] value)
            {
                int cnt = 1*2+4*2;
                if (value.Length < cnt)
                    return false;
                int idx = 0;
                hasFan = BitConverter.ToBoolean(value, idx);
                idx += 1;
                hasEletric = BitConverter.ToBoolean(value, idx);
                idx += 1;
                checkno = BitConverter.ToInt32(value, idx);
                idx += 4;
                int len = BitConverter.ToInt32(value, idx);
                idx += 4;

                cnt+=len;
                if (value.Length < cnt)
                    return false;
                if (len == 0)
                {
                    bads = null;
                }
                else
                {
                    bads = new bool[len];
                    for (int i = 0; i < len; i++)
                    {
                        bads[i] = BitConverter.ToBoolean(value, idx);
                        idx++;
                    }
                }
                return true;
            }

            #endregion
        }

        public class Pack_StringList : IPack
        {
            public List<string> list;
            #region IPack 成员

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

                byte[] bs;

                buf.AddRange(BitConverter.GetBytes(list.Count()));
                for (int i = 0; i < list.Count(); i++)
                {
                    bs = Misc.Converter.StringToBytes(list[i]);
                    buf.AddRange(BitConverter.GetBytes(bs.Count()));
                    buf.AddRange(bs);
                }
                return buf.ToArray();
            }
            /// <summary>
            /// 返回由字节数组中指定位置的9个字节转换来的数据。
            /// </summary>
            /// <param name="value"></param>
            /// <returns></returns>
            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;
                cnt += len * 4;
                if (value.Length < cnt)
                    return false;
                if (list == null)
                    list = new List<string>();
                list.Clear();
                for (int i = 0; i < len; i++)
                {
                    int l = BitConverter.ToInt32(value, idx);
                    idx += 4;
                    cnt += l;
                    if (value.Length < cnt)
                        return false;

                    string s = Misc.Converter.BytesToString(value, idx, l);
                    idx += l;
                    list.Add(s);
                }
                return true;
            }


            #endregion
        }
        public class Pack_String
        {
            public string data;
            #region IPack 成员

            public byte[] ToBytes()
            {
                List<byte> buf = new List<byte>();
                if (data != null)
                {
                    byte[] bs = Misc.Converter.StringToBytes(data);
                    buf.AddRange(BitConverter.GetBytes(bs.Length));
                    buf.AddRange(bs);
                }
                else
                {
                    buf.AddRange(BitConverter.GetBytes(0));
                }

                return buf.ToArray();
            }
            /// <summary>
            /// 返回由字节数组中指定位置的9个字节转换来的数据。
            /// </summary>
            /// <param name="value"></param>
            /// <returns></returns>
            public bool TryParse(byte[] value, int index, int count)
            {
                int cnt = 4;
                if (value.Length < cnt)
                    return false;

                int idx = 0;
                int len = BitConverter.ToInt32(value, idx);
                idx += 4;

                cnt += len;
                if (value.Length < cnt)
                    return false;
                if (len <= 0)
                    data = null;
                else
                {
                    data = Misc.Converter.BytesToString(value, idx, len);
                    idx += len;
                }
                return true;
            }

            public bool TryParse(byte[] value)
            {
                return TryParse(value, 0, value.Length);
            }
            #endregion
        }

        public class Pack_Undo : IPack
        {
            public int undo_idx;

            #region IPack 成员

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

            public bool TryParse(byte[] value)
            {
                if (value.Length < 4)
                    return false;
                int idx = 0;
                undo_idx = BitConverter.ToInt32(value, idx);
                idx += 4;
                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_Error
        /// </summary>
        public const UInt16 GET_ERROR = 8;

        /// <summary>
        /// Pack_Enable
        /// </summary>
        public const UInt16 GET_CHECKENABLE = 9;

        /// <summary>
        /// Pack_Enable
        /// </summary>
        public const UInt16 GET_ENABLE = 10;

        /// <summary>
        /// Pack_String
        /// </summary>
        public const UInt16 GET_PRODUCTNAME = 11;

        /// <summary>
        /// Pack_undo
        /// </summary>
        public const UInt16 GET_UNDOIDX = 13;
        #endregion

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


        /// <summary>
        /// Pack_Enable
        /// </summary>
        public const UInt16 SET_CHECKENABLE = 9;

        /// <summary>
        /// Pack_Enable
        /// </summary>
        public const UInt16 SET_ENABLE = 10;
        #endregion

        #region Call
        
        /// <summary>
        /// request:Pack_String
        /// reponse:null 
        /// </summary>
        public const UInt16 CALL_SAVEHEATS = 7;

        /// <summary>
        /// request:Pack_String
        /// reponse:null
        /// </summary>
        public const UInt16 CALL_LOADHEATS = 8;
 
        /// <summary>
        /// request:null ;
        /// reponse:Pack_StringList
        /// </summary>
        public const UInt16 CALL_GETLIST = 10;
        /// <summary>
        /// request:Pack_String ;
        /// reponse:null
        /// </summary>
        public const UInt16 CALL_DEL = 11;

        /// <summary>
        /// request:null
        /// reponse:null
        /// </summary>
        public const UInt16 CALL_UNDO = 13;

        #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_Error
        /// </summary>
        public const UInt16 PUSH_ERROR = 8;

        /// <summary>
        /// Pack_Enable
        /// </summary>
        public const UInt16 PUSH_CHECKENABLE = 9;

        /// <summary>
        /// Pack_Enable
        /// </summary>
        public const UInt16 PUSH_ENABLE = 10;


        /// <summary>
        /// Pack_String
        /// </summary>
        public const UInt16 PUSH_PRODUCTNAME = 11;

        /// <summary>
        /// Pack_undo
        /// </summary>
        public const UInt16 PUSH_UNDOIDX = 13;
        #endregion

    }
}