OTS/OTSIncAMeasureApp/1-OTSMeasure/Measure/3-MeasureFlow/CSmplMsrResult.cs


using OTSDataType;

using System.IO;

using System.Xml;

namespace OTSModelSharp
{
 public   class CSmplMsrResult 
    {

        //----------------定义----------------------
        protected static NLog.Logger logger = null;
      
        string m_strSampleWorkingFolder;
        string m_strFieldFileSubFolder;
      

        // pathname
        string m_strRstFileName;
        string m_strdbPathName;

        CIncAFileMgr m_DBFileMgr ;
 
      public   string SMPL_MSR_RESULT_FILE_EXT = ".rst";

        // fields file sub-directory string
       public  string SMPL_MSR_RESULT_FIELDS_FILE_SUBFOLDER = "FIELD_FILES";

       public  string DBFILE_NAME = "Inclusion.db";
        // BSE file name
        public string SMPL_MSR_RESULT_FIELDS_BSE = ("Field");

        public string SMPL_MSR_RESULT_FILE_FILTER = ("Sample Measure Result Files (*.rst)|*.rst||");

    

        //----------全局定义------------------
        // sample measure result file mark
        public int SMPL_MSR_RESULT_FILE_MARK = 'S' + 'M' + 'P' + 'L' + 'M' + 'S' + 'R' + 'R' + 'E' + 'S' + 'U' + 'L' + 'T';

        // sample measure result file version
        public string SMPL_MSR_RESULT_FILE_VERSION = ("2.0.0");

        // sample measure result file extension
        //----------定义----------------------
        // file version string
        string m_strFileVersion;
        // SEM sample stage
        CSEMStageData m_pSEMStageData;
        // sample stage
        CStage m_pStage;
      
        CSEMDataGnr m_pSEMData;
        // sample setting
        COTSSample m_pSample;
        // switch
        bool m_bSwitch;
    


        public CIncAFileMgr DBFileMgr { get => m_DBFileMgr; set => m_DBFileMgr = value; }

     


        public CSmplMsrResult(string measureWorkingFolder,COTSSample a_pSample)
        {
            Init();
            logger = NLog.LogManager.GetCurrentClassLogger();
           
            m_pSample = a_pSample;

           

           
            m_strSampleWorkingFolder = measureWorkingFolder + "\\" + a_pSample.GetName();
            m_strFieldFileSubFolder = m_strSampleWorkingFolder + "\\" + SMPL_MSR_RESULT_FIELDS_FILE_SUBFOLDER;
          
            m_strRstFileName = m_strSampleWorkingFolder + "\\" + a_pSample.GetName() + SMPL_MSR_RESULT_FILE_EXT;
            m_strdbPathName = m_strFieldFileSubFolder + "\\" + DBFILE_NAME;

          
            m_DBFileMgr = new CIncAFileMgr(m_strdbPathName);
        }
        protected void Init()
        {
        
            m_strFileVersion = ("");
      
            m_pSEMStageData = new CSEMStageData();
           
            m_pStage = new CStage();
 
            m_pSEMData = new CSEMDataGnr();
      
            m_bSwitch = false;
           

        }
        protected void Cleanup()
        {
            m_pSample.GetFieldsData().Clear();
        }
        public string GetFileVersion()
        {
            return m_strFileVersion;
        }
        public void SetFileVersion(string a_strFileVersion)
        {
            m_strFileVersion = a_strFileVersion;
        }
        public COTSSample GetSample()
        {
            return m_pSample;
        }
        public void SetSample(COTSSample a_pSample)
        {
            if (a_pSample != null)
            {
                return;
            }
            m_pSample = a_pSample;

        }
        public CSEMStageData GetSEMStageData()
        {
            return m_pSEMStageData;
        }
        public void SetSEMStageData(CSEMStageData a_pSEMStageData)
        {
         
            m_pSEMStageData = a_pSEMStageData;
        }
        // sample stage
        public CStage GetStage()
        {
            return m_pStage;
        }
        public void SetStage(CStage a_pStage)
        {
            if (a_pStage != null)
            {
                return;
            }
            m_pStage = a_pStage;
        }
        // SEM condition
        public CSEMDataGnr GetSEMStage()
        {
            return m_pSEMData;
        }
        public void SetSEMStage(CSEMDataGnr a_pSEMData)
        {
            if (a_pSEMData != null)
            {
                return;
            }
            m_pSEMData = a_pSEMData;
        }

 


        public void Serialize(bool isStoring, XmlDocument classDoc, XmlNode rootNode)
        {
            xInt xnFileMark = new xInt();
            xString xnVersion = new xString();
            xBool xbSwitch = new xBool();
            Collection<Slo> xfields = new Collection<Slo>();
            Slo slo = new Slo();
            slo.Register("FileMark", xnFileMark);
            slo.Register("Version", xnVersion);
            slo.Register("Switch", xbSwitch);
            slo.Register("SEMStageData", m_pSEMStageData);
            slo.Register("Stage", m_pStage);
            slo.Register("SEMData", m_pSEMData);
            slo.Register("Sample", m_pSample);
            slo.Register("Fields", xfields);
            if (isStoring)
            {
                xnFileMark.AssignValue(SMPL_MSR_RESULT_FILE_MARK);
                xnVersion.AssignValue(SMPL_MSR_RESULT_FILE_VERSION);
                xbSwitch.AssignValue(m_bSwitch);


                slo.Serialize(true, classDoc, rootNode);
            }
            else
            {
                slo.Serialize(false, classDoc, rootNode);
                m_bSwitch = xbSwitch.value();
                m_strFileVersion = xnVersion.value();
                
            }
        }
        private bool InitFolders()
        {
           

            if (!Exists(m_strSampleWorkingFolder))
            {
                // the working directory is not exit, create it
                if (!CreateFolder(m_strSampleWorkingFolder))
                {

                    return false;
                }
               
            }

       
            // check if the field files directory exists
            if (!Exists(m_strFieldFileSubFolder))
            {
                // field files directory exists not exists, creates it
                if (!CreateFolder(m_strFieldFileSubFolder))
                {
                    // failed to create the field files directory

                    return false;
                }
            }

           
            return true;

        }
       

        // creates a folder.
        private bool CreateFolder(string a_strFolder)
        {
            // make sure the folder name string are not empty
            string strFolder = a_strFolder;
            strFolder.Trim();
            if (strFolder=="")
            {
                return false;
            }

            // if the folder exist?
            if (Exists(strFolder))
            {               
                    return true;                
            }

   
            Directory.CreateDirectory(strFolder);
            bool bRet = true;

            // return folder create result
            return bRet;
        }


        // check if the file exists or not
        private bool Exists(string a_sPath)
        {
           return Directory.Exists(a_sPath);
           
        }
       

       

        // Save 
        public bool CreateResultFiles()
        {
            InitFolders();


            XmlDocument xmlDoc = new XmlDocument();
            XmlDeclaration xmlDeclaration = xmlDoc.CreateXmlDeclaration("1.0", "utf-8", null);
            xmlDoc.AppendChild(xmlDeclaration);
            XmlElement rootNode = xmlDoc.CreateElement("XMLData");
            xmlDoc.AppendChild(rootNode);

          

            XmlNode root = xmlDoc.SelectSingleNode("XMLData");

            
            Serialize(true, xmlDoc, root);
            if (!File.Exists(m_strRstFileName))
            {
                xmlDoc.Save(m_strRstFileName);
            }
          

           
         

            m_DBFileMgr.InitFile();
            m_DBFileMgr.InitDataTable();
            return true;
        }

      



        public string GetFieldFileSubFolderStr()
        {
           
            
            // return field file sub folder string
            return m_strFieldFileSubFolder;
        }
       
       
        public void SetSEMGnr(CSEMDataGnr a_pSEMGnr)
        {
         
            if (a_pSEMGnr == null)
            {
                logger.Info("input a invalid SEM general data pointer.");
                return;
            }


           m_pSEMData= a_pSEMGnr;
        }

        public void SetSEMStage(CStage a_pStage)
        {
            //ASSERT(a_pStage);
            if (a_pStage == null)
            {
                logger.Info("input a invalid stage pointer.");
                return;
            }
      
            m_pStage= a_pStage;
        }
       
      
    }
}