using System;
using System.Collections.Generic;
using System.Text;
using Misc;
using System.Net;
using System.IO;
using System.ComponentModel;
using System.Xml.Linq;
using FLY.Thick.Base.Common;
using FLY.Thick.Base.IService;

namespace FLY.Thick.Base.Server
{
    //硬件配置参数
    public class InitParam: IInitParamService,  INotifyPropertyChanged, Misc.ISaveToXml
    {
        #region 属性，成员变量的代理
        private int poslen = 8900;//扫描架长
        /// <summary>
        /// 扫描架长
        /// </summary>
        public int PosLength
        {
            get { return poslen; }
            set
            {
                poslen = value;
                NotifyPropertyChanged("PosLength");
            }
        }
        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 int autoOriginInterval=10;//自动归原点的间隔

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

        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 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 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");
                }
            }
        }



        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");
                }
            }
        }

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

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

        private string param_path = "initparam.xml";
        public InitParam()
        {

        }
        
        public InitParam(string param_path)
        {
            if (!string.IsNullOrEmpty(param_path))
                this.param_path = param_path;

            Load();
        }
        public bool Load() 
        {
            return Misc.SaveToXmlHepler.Load(param_path, this);
        }
        public bool Save() 
        {
            return Misc.SaveToXmlHepler.Save(param_path, this);
        }


        #region INotifyPropertyChanged 成员
        protected void NotifyPropertyChanged(string propertyName) 
        {
            if (PropertyChanged != null)    
                PropertyChanged.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }
        public event PropertyChangedEventHandler PropertyChanged;

        #endregion

        #region ISaveToXml 成员

        public string[] GetSavePropertyNames()
        {
            return new string[]{
                "PosLength",
                "AutoOrgInterval",
                
                "VScan",
                "VJOG",
                "VAccuracy",
                "SVelocity","ATime","DTime","HVelocity1","HVelocity2",
        
                "Encoder1_mmpp",

                "FilmVSrc",
                "FilmVThreshold",
                "Encoder2_mmpp",
                "Encoder2_comp",
                "MmOfR",
                "DataValidSrc",

                "AutoF1F3",
                "ReStartDelay",

                "HasProfileSample",
                "HasHold"
            };
            
        }

        #endregion


        public void Apply()
        {
            Save();
        }
    }
    
    
}
