using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using static OTSDataType.otsdataconst;

namespace OTSDataType
{
    public class COTSXRayParam : ISlo
    {
        // x-ray scan mode
        const OTS_X_RAY_SCAN_MODE DEFAULE_XRAY_SCAN_MODE = OTS_X_RAY_SCAN_MODE.PointMode;

        // search x-ray low counts cut off
        const int DEFAULE_XRAY_LOW_COUNT = 800;

        // search x-ray speed
        //const OTS_IMAGE_SCANSPEED_OPTIONS DEFAULE_SEARCH_XRAY_SPEED = OTS_IMAGE_SCANSPEED_OPTIONS.meddium;

        // analysis x-ray speed
        //const OTS_IMAGE_SCANSPEED_OPTIONS DEFAULE_ANALYSIS_XRAY_SPEED = OTS_IMAGE_SCANSPEED_OPTIONS.meddium;

        // x-ray expect counts 
        //const int DEFAULE_XRAY_EXP_COUNT = 4500;

        // x-ray speed search
        //const int DEFAULE_XRAY_SEARCH_MID_TIME = 20;

        // x-ray speed analysis
        const int DEFAULE_XRAY_ANALY_MID_TIME = 1000;

        //const double DEFAULE_XRAY_QUANTIFY_MINSIZE = 50;

        //const int DEFAULE_FASTXRAYTIME = 100;
        const int Default_Xray_Limit = 50;
        private OTS_X_RAY_SCAN_MODE m_nScanMode;

      
        private int m_nAnalyLowestCount;
        //private int m_nMidSearchAQTime;
        private int m_nMidAnalyAQTime;
        //private double m_nQutantifyMinSize;
        //private int m_nFastXrayTime;

        private bool m_nUsingXray;
        private bool m_UseFilter;
        bool m_ZeroElementProcess;

        private int m_XrayLimit;
        //private double m_xrayStep;

        //public double XrayStep { get => m_xrayStep; set => m_xrayStep = value; }

        void Init()
        {
            m_nScanMode = DEFAULE_XRAY_SCAN_MODE;
    
        
            m_nAnalyLowestCount = DEFAULE_XRAY_LOW_COUNT;
            //m_nMidSearchAQTime = DEFAULE_XRAY_SEARCH_MID_TIME;
            m_nMidAnalyAQTime = DEFAULE_XRAY_ANALY_MID_TIME;
            //m_nQutantifyMinSize = DEFAULE_XRAY_QUANTIFY_MINSIZE;
            //m_nFastXrayTime = DEFAULE_FASTXRAYTIME;
            m_XrayLimit = Default_Xray_Limit;
            //m_xrayStep = 0;
        }
        public COTSXRayParam()
        {
            Init();
        }
        // duplication
        void Duplicate(COTSXRayParam a_oSource)
        {

            // copy data over
            m_nScanMode = a_oSource.m_nScanMode;

            //m_nAnalySpeed = a_oSource.m_nAnalySpeed;
            m_nAnalyLowestCount = a_oSource.m_nAnalyLowestCount;
            //m_nMidSearchAQTime = a_oSource.m_nMidSearchAQTime;
            m_nMidAnalyAQTime = a_oSource.m_nMidAnalyAQTime;
            //m_nQutantifyMinSize = a_oSource.m_nQutantifyMinSize;
            //m_nFastXrayTime = a_oSource.m_nFastXrayTime;

            m_nUsingXray = a_oSource.m_nUsingXray;
            m_UseFilter = a_oSource.m_UseFilter;
            m_ZeroElementProcess = a_oSource.m_ZeroElementProcess;
            m_XrayLimit = a_oSource.m_XrayLimit;
            //m_xrayStep = a_oSource.m_xrayStep;
        }
        // copy constructor
        public COTSXRayParam(COTSXRayParam a_oSource)
        {       // copy data over
            Duplicate(a_oSource);
        }
        // ==operator
        public bool Equals(COTSXRayParam a_oSource)
        {
            // return test result
            return m_nScanMode == a_oSource.m_nScanMode &&
   
                //m_nAnalySpeed == a_oSource.m_nAnalySpeed &&
                m_nAnalyLowestCount == a_oSource.m_nAnalyLowestCount &&
                //m_nMidSearchAQTime == a_oSource.m_nMidSearchAQTime &&
                m_nMidAnalyAQTime == a_oSource.m_nMidAnalyAQTime &&
                //m_nQutantifyMinSize == a_oSource.m_nQutantifyMinSize &&
                //m_nFastXrayTime == a_oSource.m_nFastXrayTime &&
           
                m_nUsingXray == a_oSource.m_nUsingXray &&
                m_UseFilter == a_oSource.m_UseFilter&&
                m_ZeroElementProcess == a_oSource.m_ZeroElementProcess;
        }



        public OTS_X_RAY_SCAN_MODE GetScanMode() { return m_nScanMode; }
        public void SetScanMode(OTS_X_RAY_SCAN_MODE a_nVal) { m_nScanMode = a_nVal; }



     

        public int GetAnalyExpCount() { return m_nAnalyLowestCount; }
        public void SetAnalyExpCount(int a_nVal) { m_nAnalyLowestCount = a_nVal; }

        //public int GetMidSearchAQTime() { return m_nMidSearchAQTime; }
        //public void SetMidSearchAQTime(int a_nMidSearchAQTime) { m_nMidSearchAQTime = a_nMidSearchAQTime; }
    


        public int GetMidAnalyAQTime() { return m_nMidAnalyAQTime; }
        public void SetMidAnalyAQTime(int a_nMidAnalyAQTime) { m_nMidAnalyAQTime = a_nMidAnalyAQTime; }
     


        //public double GetFeatureModeMinSize() { return m_nQutantifyMinSize; }
        //public void SetQuantifyMinSize(double a_nQuantifyMinSize)
        //{
        //    m_nQutantifyMinSize = a_nQuantifyMinSize;
        //}
        //public int GetFastXrayTime() { return m_nFastXrayTime; }
        //public void SetFastXrayTime(int a_nFastXrayTime)
        //{
        //    m_nFastXrayTime = a_nFastXrayTime;
        //}
        public int GetXrayLimit() { return m_XrayLimit; }
        public void SetXrayLimit(int a_xrayLimit)
        {
            m_XrayLimit = a_xrayLimit;
        }

        public bool GetUsingXray() { return m_nUsingXray; }
        public void SetUsingXray(bool a_nUsingXray)
        {
            m_nUsingXray = a_nUsingXray;
        }

        public bool GetUseFilter() { return m_UseFilter; }
        public void SetUseFilter(bool a_UseFilter)
        {
            m_UseFilter = a_UseFilter;
        }

        public bool GetZeroelementprocess() { return m_ZeroElementProcess; }
        public void SetZeroelementprocess(bool a_Zeroelementprocess)
        {
            m_ZeroElementProcess = a_Zeroelementprocess;
        }

        public override void Serialize(bool isStoring, XmlDocument classDoc, XmlNode rootNode)
        {
            xString xnScanMode = new xString();
    
            xInt xnAnalyExpCount = new xInt();
        
            xInt xnMidAnalyAQTime = new xInt();

            xInt xSmallPartAQTime = new xInt();

            xDouble xQuantifyMinSize = new xDouble();

            xBool xnUsingXray = new xBool();

            xBool xnUseFilter = new xBool();

            xInt xXrayLimit = new xInt();
            //xDouble xXrayStep = new xDouble();
            xBool xZeroElementProcess = new xBool();

            Slo slo = new Slo();

            slo.Register("ScanMode", xnScanMode);
    
            slo.Register("AnalyExpCount", xnAnalyExpCount);
   
            slo.Register("MidAnalyAQTime", xnMidAnalyAQTime);

            slo.Register("SmallPartAQTime", xSmallPartAQTime);

            slo.Register("QuantifyMinSize", xQuantifyMinSize);

            slo.Register("UsingXray", xnUsingXray);

            slo.Register("UseFilter", xnUseFilter);

            slo.Register("XrayLimit", xXrayLimit);

            //slo.Register("XrayStep", xXrayStep);

            slo.Register("ZeroElementProcess", xZeroElementProcess);


            if (isStoring)
            {
                xnScanMode.AssignValue((int)m_nScanMode+":"+m_nScanMode.ToString());
    
                xnAnalyExpCount.AssignValue(m_nAnalyLowestCount);
            
                xnMidAnalyAQTime.AssignValue(m_nMidAnalyAQTime);

                //xSmallPartAQTime.AssignValue(m_nFastXrayTime);

                //xQuantifyMinSize.AssignValue(m_nQutantifyMinSize);

                xnUsingXray.AssignValue(m_nUsingXray);

                xnUseFilter.AssignValue(m_UseFilter);

                xXrayLimit.AssignValue(m_XrayLimit);
                xZeroElementProcess.AssignValue(m_ZeroElementProcess);
                //xXrayStep.AssignValue(m_xrayStep);

                slo.Serialize(true, classDoc, rootNode);
            }
            else
            {
                slo.Serialize(false, classDoc, rootNode);

                m_nScanMode = (OTS_X_RAY_SCAN_MODE)Convert.ToInt32( xnScanMode.value().Split(':')[0]);
         
                m_nAnalyLowestCount = xnAnalyExpCount.value();
             
                m_nMidAnalyAQTime = xnMidAnalyAQTime.value();

                //m_nFastXrayTime = xSmallPartAQTime.value();

                //m_nQutantifyMinSize = xQuantifyMinSize.value();

                m_nUsingXray = xnUsingXray.value();

                m_UseFilter = xnUseFilter.value();

                m_XrayLimit = xXrayLimit.value();
                m_ZeroElementProcess = xZeroElementProcess.value();
                //m_xrayStep = xXrayStep.value();
            }
        }
    }
}