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

using OTSModelSharp;
using System.Xml;
using OTSModelSharp.ResourceManage;
using static OTSModelSharp.ResourceManage.ResourceID;
using OTSMeasureApp;
using OTSMeasureApp._0_OTSModel.OTSDataType;

namespace OTSDataType
{

    public class COTSSample : ISlo
    {
        const string NOT_APPLIED = "N/A";
        private string m_strName;
        private string m_strHoleName;
        //private bool m_bParamLock;
     
        private bool m_bSwitch;
    
        private CSampleParam m_poMsrParams;
        private CDomain m_poMsrArea;
        private CSEMFieldData m_poSEMDataMsr;
        private CMsrSampleStatus m_Status;
        private CMsrResultItems m_poMsrResults;
        //private MEMBRANE_TYPE m_membraneType;
        private List<COTSField> m_listFieldData;
        public CFieldPositionHelper pFieldMgr=new CFieldPositionHelper();
        public COTSSample()
        {
            // initialization
            Init();
        }
        void Init()
        {
            m_strName = "";
            m_strHoleName = "";
           
            m_bSwitch = true;
          
            m_poMsrParams = new CSampleParam();
            m_poMsrArea = new CDomain();
            m_poSEMDataMsr = new CSEMFieldData();
            m_Status = new CMsrSampleStatus();
            m_poMsrResults = new CMsrResultItems();
           
            m_listFieldData = new List<COTSField>();
           
        }
       
      

        public CDomain GetMsrDomain() { return m_poMsrArea; }
       
  
        // calculate scan field size
        public void CalculateScanFieldSize(double a_dPixelSize,ref int scanFieldWidth,ref int scanFieldHeight)
        {
    
                // get image size
                OTS_IMAGE_RESULOTION_OPTIONS nImageSizeId = m_poMsrParams.GetImageScanParam().GetImageResulotion();
                long nResulotionId = RESOLUTION_ID_FIRST_TIE + (long)nImageSizeId;
                int nImagewidth = otsdataconst.RESOLUTION_VALUE[nResulotionId].Width;
                int nHeight = RESOLUTION_VALUE[nResulotionId].Height;

                // calculate scan field size
                scanFieldWidth = (int)((a_dPixelSize * (double)nImagewidth) + 0.5);
                scanFieldHeight= (int)((a_dPixelSize * (double)nHeight) + 0.5);
           
        }
        public bool GetBSESize(out int a_nWidth, out int a_nHeight)
        {
            // scan parameters
            CSampleParam pMsrParam = GetMsrParams();

            COTSImgScanPrm pImgScanParam = pMsrParam.GetImageScanParam();


            // get image size
            OTS_IMAGE_RESULOTION_OPTIONS nImageSizeId = pImgScanParam.GetImageResulotion();
            int nResulotionId = RESOLUTION_ID_FIRST_TIE + (int)nImageSizeId;
            Size sizePixelImage = RESOLUTION_VALUE[nResulotionId];

            // get scan field size
            a_nWidth = sizePixelImage.Width;
            a_nHeight = sizePixelImage.Height;

            return true;
        }
        // name
        public string GetName() { return m_strName; }
        public void SetName(string a_strName) { m_strName = a_strName; }

        // sample hole
        public string GetSampleHoleName() { return m_strHoleName; }
        public void SetSampleHoleName(string a_strHoleName) { m_strHoleName = a_strHoleName; }

        // param modify lock
        //public bool GetParamLock() { return m_bParamLock; }
        //public void SetParamLock(bool a_bParamLock) { m_bParamLock = a_bParamLock; }

        // switch
        public bool GetSwitch() { return m_bSwitch; }
        public void SetSwitch(bool a_bSwitch) { m_bSwitch = a_bSwitch; }

        // measurement parameter 
        public CSampleParam GetMsrParams() { return m_poMsrParams; }
        public void SetMsrParams(CSampleParam a_poMsrParams)
        {
            m_poMsrParams = a_poMsrParams;
        }

        // measurement area

        public void SetMsrDomain(CDomain a_poMsrArea)
        {
            m_poMsrArea = a_poMsrArea;
        }

        // SEM data (measurement)
        public CSEMFieldData GetSEMDataMsr() { return m_poSEMDataMsr; }
        public void SetSEMDataMsr(CSEMFieldData a_poSEMDataMsr)
        {
            m_poSEMDataMsr = a_poSEMDataMsr;
        }

        // measure status
        public CMsrSampleStatus GetMsrStatus() { return m_Status; }
        public void SetMsrStatus(CMsrSampleStatus a_poMsrStatus)
        {
            m_Status = a_poMsrStatus;
        }
        // fields
        public List<COTSField> GetFieldsData() { return m_listFieldData; }
        public void SetFieldsData(List<COTSField> a_listFieldData)
        {
            m_listFieldData = a_listFieldData;
            for (int i = 0; i < m_listFieldData.Count; i++)
            {
                m_listFieldData[i].SetId(i);
                m_listFieldData[i].Sample = this;
            }
            var mySemdata = GetSEMDataMsr();

            mySemdata.SetTotalFields(m_listFieldData.Count);
        }
       
        public void AddNewField(PointF centerPoint ,int measureSequence)

        {
            var pixelsize = CalculatePixelSize();
            var newfld = new COTSField(centerPoint, pixelsize);
            newfld.SetMeasureSequence(measureSequence);
            int nNewFieldId;
            nNewFieldId =GetIdForANewField();
            newfld.SetId(nNewFieldId);
            newfld.Sample = this;

           
            m_listFieldData.Add(newfld);

            var mySemdata = GetSEMDataMsr();

            mySemdata.SetTotalFields(m_listFieldData.Count);
          

        }
        public void AddNewField(COTSField newfld)

        {
            
            int nNewFieldId;
            nNewFieldId = GetIdForANewField();
            newfld.SetId(nNewFieldId);
            newfld.Sample = this;


            m_listFieldData.Add(newfld);

            var mySemdata = GetSEMDataMsr();

            mySemdata.SetTotalFields(m_listFieldData.Count);


        }
        public void ClearFields()
        {
            m_listFieldData.Clear();
        }
        public void SetFieldEnable(Point OTScoord, bool enable)
        {
            foreach (var fld in m_listFieldData)
            {
                if (fld.GetOTSRect().PointInRect(OTScoord))
                { 
                   fld.Enable = enable;
                    if (enable == false)
                    {
                        NLog.LogManager.GetCurrentClassLogger().Info("Field " + fld.GetId() + " Disabled");
                    }
                }
            
            }
        
        }
        public int GetIdForANewField()
        {
            List<COTSField> listFieldData = GetFieldsData();
            // new field id
            int nNewFieldId = listFieldData.Count;

            do
            {
                bool iffound = false;
                COTSField cOTSFieldData;
                for (int i = 0; i < listFieldData.Count; i++)
                {
                    cOTSFieldData = listFieldData[i];
                    if (cOTSFieldData.GetId() == nNewFieldId)
                    {
                        iffound = true;
                    }
                }

                if (iffound == true)
                {
                    ++nNewFieldId;
                }
                else
                {
                    break;
                }

            } while (true);



            return nNewFieldId;
        }
        // measure results
        public CMsrResultItems GetMsrResults() { return m_poMsrResults; }
        public void SetMsrResults(CMsrResultItems a_poMsrResults)
        {
            m_poMsrResults = a_poMsrResults;
        }

        // has measure results test
        public bool HasMeasureResult()
        {
            // result items is not empty
            bool bHasResult = (m_poMsrResults.GetResultItems().Count != 0);
            return bHasResult;
        }
       

        public bool IsThisPointInMeasureArea(Point p)
        {
            
            return pFieldMgr.IsThisPointInMeasureArea(p,this.GetMsrDomain().GetClrDomainObj());


        }
       
        public double CalculatePixelSize()
        {
            // pixel size 
            double dPixelSize = 0.0;

            // make sure SEM is valid
            if (m_poSEMDataMsr != new CSEMFieldData())
            {
                // get scan field size
                int nScanFieldSize = m_poSEMDataMsr.GetScanFieldSize();

                // get image size
                OTS_IMAGE_RESULOTION_OPTIONS nImageSizeId = m_poMsrParams.GetImageScanParam().GetImageResulotion();
                long nResulotionId = RESOLUTION_ID_FIRST_TIE + (long)nImageSizeId;
                int nImageSize = RESOLUTION_VALUE[nResulotionId].Width;

                // calculate pixel size 
                dPixelSize = (double)nScanFieldSize / (double)nImageSize;
            }

            // return pixel size 
            return dPixelSize;
        }

       

       

        // calculate field area
        public double CalculateAFieldArea()
        {

            // pixel size 
            double dAFieldArea = 0.0;

            // make sure SEM is valid
            if (m_poSEMDataMsr != new CSEMFieldData())
            {
                // get image size
                OTS_IMAGE_RESULOTION_OPTIONS nImageSizeId = m_poMsrParams.GetImageScanParam().GetImageResulotion();
                long nResulotionId = RESOLUTION_ID_FIRST_TIE + (long)nImageSizeId;
                int nWidth = RESOLUTION_VALUE[nResulotionId].Width;
                int nHeight = RESOLUTION_VALUE[nResulotionId].Height;
                // pixel size (micros)
                double dPixelSize = CalculatePixelSize();
               

                // calculate pixel size 
                dAFieldArea = (double)nWidth * nHeight * dPixelSize * dPixelSize * 0.000001;// mm^2
            }

            // return pixel size 
            return dAFieldArea;

        }

        public double GetTotalToMeasureArea()
        {
            double totalArea;
            if (m_poMsrArea.GetShape() == DOMAIN_SHAPE.RECTANGLE)
            {
                totalArea = m_poMsrArea.GetRectDomain().Width * m_poMsrArea.GetRectDomain().Height * 0.000001;


            }
            else if (m_poMsrArea.GetShape() == DOMAIN_SHAPE.ROUND)
            {

                totalArea = (m_poMsrArea.GetRectDomain().Width / 2) * (m_poMsrArea.GetRectDomain().Width / 2) * 3.14159 * 0.000001;

            }
            else 
            {
                double singleFldarea= CalculateAFieldArea();
                totalArea = m_listFieldData.Count * singleFldarea;
            
            }
            return totalArea ;
        
        }
        public bool InitFieldPosData(  out List<Point> lisFieldPos, out Size iSzie)
        {
            lisFieldPos = new List<Point>();
            iSzie = new Size();

           

            CDomain pMsrArea = this.GetMsrDomain();


            COTSImgScanPrm pImgScanParam = this.GetMsrParams().GetImageScanParam();
            COTSImageProcParam pImgProcParam = this.GetMsrParams().GetImageProcessParam();

            CSEMFieldData pSEMDataMsr = this.GetSEMDataMsr();


            List<PointF> listPoint = new List<PointF>();
            listPoint.Clear();

            //calculate all the field position point in OTS coordination.
            if (!pFieldMgr.Init(pMsrArea, pImgScanParam, pImgProcParam.GetOverlapParam(), pSEMDataMsr, listPoint))
            {
                return false;
            }
            lisFieldPos = pFieldMgr.GetFieldCentrePoints();



            var oValue = new COTSRect();
            if (!pFieldMgr.GetOTSRectByIndex(0, ref oValue))
            {
                return false;
            }
            iSzie = new Size((int)oValue.GetWidth(), (int)oValue.GetHeight());


            return true;
        }



        public override void Serialize(bool isStoring, XmlDocument classDoc, XmlNode rootNode)
        {
            xString xstrSampleName = new xString();
            xString xstrHoleName = new xString();
            //xBool xParamLock = new xBool();
            xBool xSwitch = new xBool();
            xDouble xTotalArea = new xDouble();
         
            Collection<COTSField> fielddata = new Collection<COTSField>();
            Slo slo = new Slo();
            slo.Register("SampleName", xstrSampleName);
            slo.Register("HoleName", xstrHoleName);
            //slo.Register("ParamLock", xParamLock);
            slo.Register("Switch", xSwitch);
         
            slo.Register("MsrArea", m_poMsrArea);
            slo.Register("MsrParams", m_poMsrParams);
            slo.Register("SEMDataMsr", m_poSEMDataMsr);
            slo.Register("TotalArea", xTotalArea);
            slo.Register("AllFields", fielddata);
            if (isStoring)
            {
                xstrSampleName.AssignValue(m_strName);
                xstrHoleName.AssignValue(m_strHoleName);
                //xParamLock.AssignValue(m_bParamLock);
                xSwitch.AssignValue(m_bSwitch);
                xTotalArea.AssignValue(this.GetTotalToMeasureArea());
                foreach (var f in m_listFieldData)
                {
                    fielddata.addItem(f);
                }
              
                slo.Serialize(true, classDoc, rootNode);
            }
            else
            {
                slo.Serialize(false, classDoc, rootNode);
                m_strName = xstrSampleName.value();
                m_strHoleName = xstrHoleName.value();
                //m_bParamLock = xParamLock.value();
                m_bSwitch = xSwitch.value();
                int i = 0;
                foreach (var f in fielddata.m_vCollection)
                {
                    var fld = (COTSField)f;
                    int w, h;
                    this.GetBSESize(out w,out h);
                    fld.ImgWidth = w;fld.ImgHeight = h;
                    fld.SetPixelSize(CalculatePixelSize());
                    fld.SetId(i);
                    i++;
                    m_listFieldData.Add(fld);
                }
            }
        }
    }
}