using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel;
using FObjBase;
using FLY.Thick.Base.IService;
using FLY.Thick.Base.OBJ_INTERFACE;
using FLY.Thick.Base.Common;
namespace FLY.Thick.Base.Client
{
    public class InitParamService : FObj, IInitParamService
    {
        IFConn mConn;
        UInt32 mServerID;

        public InitParamService()
        {
            mServerID = INITPARAM_OBJ_INTERFACE.ID;
        }

        #region 属性，成员变量的代理
        private int poslen = 8900;//扫描架长
        /// <summary>
        /// 扫描架长
        /// </summary>
        public int PosLength
        {
            get { return poslen; }
            set
            {
                poslen = value;
                NotifyPropertyChanged("PosLength");
            }
        }

        private int autoOriginInterval = 10;//自动归原点的间隔

        /// <summary>
        /// 自动归原点间距
        /// </summary>
        public int AutoOrgInterval
        {
            get { return autoOriginInterval; }
            set
            {
                if (autoOriginInterval != value)
                {
                    autoOriginInterval = value;
                    NotifyPropertyChanged("AutoOrgInterval");
                }
            }
        }

        private int posofgrid = 10;
        /// <summary>
        /// 从 flyad7 获取的
        /// </summary>
        public int PosOfGrid
        {
            get { return posofgrid; }
            set
            {
                if (posofgrid != value)
                {
                    posofgrid = value;
                    NotifyPropertyChanged("PosOfGrid");
                }
            }
        }
        private int adlag = 0;
        /// <summary>
        /// ad 滞后量  ms
        /// </summary>
        public int ADLag
        {
            get { return adlag; }
            set
            {
                if (adlag != value)
                {
                    adlag = value;
                    NotifyPropertyChanged("ADLag");
                }
            }
        }

        private double _encoder1_mmpp = 0.1;
        /// <summary>
        /// 编码器1 mm/pulse
        /// </summary>
        public double Encoder1_mmpp
        {
            get { return _encoder1_mmpp; }
            set
            {
                if (_encoder1_mmpp != value)
                {
                    _encoder1_mmpp = value;
                    NotifyPropertyChanged("Encoder1_mmpp");
                }
            }
        }

        private double speed1Scale = 1;
        /// <summary>
        /// 设置的速度，与 实际速度比例
        /// </summary>
        public double Speed1Scale
        {
            get { return speed1Scale; }
            set
            {
                if (speed1Scale != value)
                {
                    speed1Scale = value;
                    NotifyPropertyChanged("Speed1Scale");
                }
            }
        }

        private FilmVSRC filmVSrc = FilmVSRC.ROUND;
        /// <summary>
        /// 线速度来源
        /// </summary>
        public FilmVSRC FilmVSrc
        {
            get
            {
                return filmVSrc;
            }
            set
            {
                if (filmVSrc != value)
                {
                    filmVSrc = value;
                    NotifyPropertyChanged("FilmVSrc");
                }
            }
        }
        private int filmVThreshold = 5;
        /// <summary>
        /// 最小线速度 m/min
        /// </summary>
        public int FilmVThreshold
        {
            get
            {
                return filmVThreshold;
            }
            set
            {
                if (filmVThreshold != value)
                {
                    filmVThreshold = value;
                    NotifyPropertyChanged("FilmVThreshold");
                }
            }
        }
        private double _encoder2_mmpp = 0.1;

        /// <summary>
        /// 编码器2 mm/pulse
        /// </summary>
        public double Encoder2_mmpp
        {
            get { return _encoder2_mmpp; }
            set
            {
                if (_encoder2_mmpp != value)
                {
                    _encoder2_mmpp = value;
                    NotifyPropertyChanged("Encoder2_mmpp");
                }
            }
        }

        private float _encoder2_comp = 1;

        /// <summary>
        /// 编码器2 放大
        /// </summary>
        public float Encoder2_comp
        {
            get { return _encoder2_comp; }
            set
            {
                if (_encoder2_comp != value)
                {
                    _encoder2_comp = value;
                    NotifyPropertyChanged("Encoder2_comp");
                }
            }
        }
        private double mmOfR = 314;
        /// <summary>
        /// //1圈多少mm
        /// </summary>
        public double MmOfR
        {
            get
            {
                return mmOfR;
            }
            set
            {
                if (mmOfR != value)
                {
                    mmOfR = value;
                    NotifyPropertyChanged("MmOfR");
                }
            }
        }

        private DATAVALIDSRC dataValidSrc = DATAVALIDSRC.VALID;

        /// <summary>
        /// 数据有效源
        /// </summary>
        public DATAVALIDSRC DataValidSrc
        {
            get { return dataValidSrc; }
            set
            {
                if (dataValidSrc != value)
                {
                    dataValidSrc = value;
                    NotifyPropertyChanged("DataValidSrc");
                }
            }
        }



        private bool autof1f3 = false;
        /// <summary>
        /// 当数据有效状态改变，自动按F1，F3
        /// </summary>
        public bool AutoF1F3
        {
            get { return autof1f3; }
            set
            {
                if (autof1f3 != value)
                {
                    autof1f3 = value;
                    NotifyPropertyChanged("AutoF1F3");
                }
            }
        }

        private int restartdelay = 5;
        /// <summary>
        /// 当数据有效状态  无效->有效 ，等待多久重新扫描 ，单位s
        /// </summary>
        public int ReStartDelay
        {
            get { return restartdelay; }
            set
            {
                if (restartdelay != value)
                {
                    restartdelay = value;
                    NotifyPropertyChanged("ReStartDelay");
                }
            }
        }


        #region 速度
        private UInt32 velocity_scan = 8000;
        /// <summary>
        /// 扫描时速度
        /// </summary>
        public UInt32 VScan
        {
            get { return velocity_scan; }
            set
            {
                if (velocity_scan != value)
                {
                    velocity_scan = value;
                    NotifyPropertyChanged("VScan");
                }
            }
        }
        private UInt32 velocity_jog = 5000;

        /// <summary>
        /// 调试时速度，向前走，向后走
        /// </summary>
        public UInt32 VJOG
        {
            get { return velocity_jog; }
            set
            {
                if (velocity_jog != value)
                {
                    velocity_jog = value;
                    NotifyPropertyChanged("VJOG");
                }
            }
        }

        private UInt32 velocity_accuracy = 3000;
        /// <summary>
        /// 精确速度 Velocity Of Accuracy  如: 机架修正, 样品取样, 机架信息获取
        /// </summary>
        public UInt32 VAccuracy
        {
            get
            {
                return velocity_accuracy;
            }
            set
            {
                if (velocity_accuracy != value)
                {
                    velocity_accuracy = value;
                    NotifyPropertyChanged("VAccuracy");
                }
            }
        }


        private UInt32 sv = 500;
        /// <summary>
        /// 开始速度 Start Velocity
        /// </summary>
        public UInt32 SVelocity
        {
            get { return sv; }
            set
            {
                if (sv != value)
                {
                    sv = value;
                    NotifyPropertyChanged("SVelocity");
                }
            }
        }

        private UInt32 atime = 200;
        /// <summary>
        /// 加速时间
        /// </summary>
        public UInt32 ATime
        {
            get { return atime; }
            set
            {
                if (atime != value)
                {
                    atime = value;
                    NotifyPropertyChanged("ATime");
                }
            }
        }
        private UInt32 dtime = 200;
        /// <summary>
        /// 减速时间
        /// </summary>
        public UInt32 DTime
        {
            get { return dtime; }
            set
            {
                if (dtime != value)
                {
                    dtime = value;
                    NotifyPropertyChanged("DTime");
                }
            }
        }
        private UInt32 hv1 = 5000;
        /// <summary>
        /// 归0速度1
        /// </summary>
        public UInt32 HVelocity1
        {
            get { return hv1; }
            set
            {
                if (hv1 != value)
                {
                    hv1 = value;
                    NotifyPropertyChanged("HVelocity1");
                }
            }
        }
        private UInt32 hv2 = 1000;
        /// <summary>
        /// 归0速度2
        /// </summary>
        public UInt32 HVelocity2
        {
            get { return hv2; }
            set
            {
                if (hv2 != value)
                {
                    hv2 = value;
                    NotifyPropertyChanged("HVelocity2");
                }
            }
        }
        #endregion


        private bool hasProfileSample = false;
        /// <summary>
        /// 有按样标定硬件
        /// </summary>
        public bool HasProfileSample
        {
            get
            {
                return hasProfileSample;
            }
            set
            {
                if (hasProfileSample != value)
                {
                    hasProfileSample = value;
                    NotifyPropertyChanged("HasProfileSample");
                }
            }
        }


        private bool hashold = false;
        /// <summary>
        /// 有小托辊
        /// </summary>
        public bool HasHold
        {
            get
            {
                return hashold;
            }
            set
            {
                if (hashold != value)
                {
                    hashold = value;
                    NotifyPropertyChanged("HasHold");
                }
            }
        }

        #endregion

        #region INotifyPropertyChanged 成员

        public event PropertyChangedEventHandler PropertyChanged;
        protected void NotifyPropertyChanged(string propertyname)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged.Invoke(this, new PropertyChangedEventArgs(propertyname));
            }
        }
        #endregion


        public void Apply() 
        {
            INITPARAM_OBJ_INTERFACE.Pack_Params p = new INITPARAM_OBJ_INTERFACE.Pack_Params()
            {
                poslength = PosLength,
                auto_org_interval = AutoOrgInterval,
                adlag = ADLag,

                encoder1_mmpp = Encoder1_mmpp,
                speed1scale = Speed1Scale,

                filmVSrc= FilmVSrc, 
                filmVThreshold = FilmVThreshold,
                encoder2_mmpp = Encoder2_mmpp,
                mmOfR = MmOfR,
                encoder2_comp = Encoder2_comp,
                data_valid_src = DataValidSrc,
                autof1f3 = AutoF1F3,
                restartDelay = ReStartDelay,

                vscan = VScan,
                vjog = VJOG,
                vaccuracy = VAccuracy,
                svelocity = SVelocity,
                atime = ATime,
                dtime = DTime,
                hvelocity1 = HVelocity1,
                hvelocity2 = HVelocity2,

                hasProfileSample = HasProfileSample,
                hasHold = HasHold
            };


            //获取所有数据，设置推送
            CurrObjSys.SetValueEx(
                mConn, mServerID, ID, 
                INITPARAM_OBJ_INTERFACE.SET_PARAMS,
                p.ToBytes());
        }
        public override void Dispose()
        {
            CurrObjSys.ObjRemove(
                this, mConn);
        }
        public override void ConnectNotify(IFConn from)
        {
            mConn = from;
            if (from.IsConnected)
            {
                //获取所有数据，设置推送
                CurrObjSys.GetValueEx(
                    mConn, mServerID, ID, 
                    BORDERSEARCH_OBJ_INTERFACE.GET_PARAMS);
                CurrObjSys.SenseConfigEx(
                    mConn, mServerID, ID, 0xffffffff, SENSE_CONFIG.ADD);
            }
        }
        public override void PushGetValue(IFConn from, uint srcid, ushort memid, byte[] infodata)
        {
            switch (memid)
            {
                case INITPARAM_OBJ_INTERFACE.GET_PARAMS:
                    {
                        INITPARAM_OBJ_INTERFACE.Pack_Params p = new INITPARAM_OBJ_INTERFACE.Pack_Params();
                        if (!p.TryParse(infodata))
                            return;

                        PosLength = p.poslength;
                        AutoOrgInterval = p.auto_org_interval;
                        PosOfGrid = p.posOfGrid;
                        ADLag = p.adlag;

                        Encoder1_mmpp = p.encoder1_mmpp;
                        Speed1Scale = p.speed1scale;

                        FilmVSrc = p.filmVSrc;
                        FilmVThreshold = p.filmVThreshold;
                        Encoder2_mmpp = p.encoder2_mmpp;
                        Encoder2_comp = p.encoder2_comp;
                        MmOfR = p.mmOfR;
                        DataValidSrc = p.data_valid_src;

                        AutoF1F3 = p.autof1f3;
                        ReStartDelay = p.restartDelay;


                        VScan = p.vscan;
                        VJOG = p.vjog;
                        VAccuracy = p.vaccuracy;
                        SVelocity = p.svelocity;
                        ATime = p.atime;
                        DTime = p.dtime;
                        HVelocity1 = p.hvelocity1;
                        HVelocity2 = p.hvelocity2;

                        HasProfileSample = p.hasProfileSample;
                        HasHold = p.hasHold;
                    } break;

            }
        }
        public override void PushInfo(IFConn from, uint srcid, ushort infoid, byte[] infodata)
        {
            PushGetValue(from, srcid, infoid, infodata);
        }
    }
}