using OTSDataType;
using OTSModelSharp;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml;

namespace OTSMeasureApp._0_OTSModel.OTSDataType
{
  public  class CSpecialGrayRange:ISlo
    {
        public string rngname;
        public  CIntRange range=new CIntRange();
        public CIntRange diameterRange = new CIntRange();
        public bool ifCollectXray;
     
        public override void Serialize(bool isStoring, XmlDocument classDoc, XmlNode rootNode)
        {
            xString xname=new xString();
            xInt xStart = new xInt();
            xInt xEnd = new xInt();
            xInt xdiaStart = new xInt();
            xInt xdiaEnd = new xInt();
            xBool xIfXray = new xBool();
            Slo slo = new Slo();
            slo.Register("rngName", xname);
            slo.Register("start", xStart);
            slo.Register("end", xEnd);
            slo.Register("diameterStart", xdiaStart);
            slo.Register("diameterEnd", xdiaEnd);
            slo.Register("collectXray", xIfXray);
            if (isStoring)
            {
                xname.AssignValue(rngname);
                xStart.AssignValue(range.GetStart());
                xEnd.AssignValue(range.GetEnd());
                xdiaStart.AssignValue(diameterRange.GetStart());
                xdiaEnd.AssignValue(diameterRange.GetEnd());
                xIfXray.AssignValue(ifCollectXray);

                slo.Serialize(true, classDoc, rootNode);
            }
            else
            {
                slo.Serialize(false, classDoc, rootNode);
                rngname = xname.value();
                range.SetStart(xStart.value());
                range.SetEnd(xEnd.value());
                diameterRange.SetStart(xdiaStart.value());
                diameterRange.SetEnd(xdiaEnd.value());
                ifCollectXray = xIfXray.value();

            }
        }
    }
   public class CSpecialGrayRangeParam: ISlo
    {
        
        private List<CSpecialGrayRange> Ranges=new List<CSpecialGrayRange>();
        private bool isToRun=false;
      
        public CSpecialGrayRangeParam()
        {
        }
        
        public CSpecialGrayRangeParam Duplicate()
        { 
           CSpecialGrayRangeParam param = new CSpecialGrayRangeParam();
            param.isToRun=this.isToRun;
            var rngs = param.GetSpecialGreyRanges();
            foreach (var rng in this.Ranges)
            {
                var newrng = new CSpecialGrayRange();
                newrng.rngname = rng.rngname;
                newrng.range.SetStart(rng.range.GetStart());    
                newrng.range.SetEnd(rng.range.GetEnd());
                newrng.diameterRange.SetStart(rng.diameterRange.GetStart());
                newrng.diameterRange.SetEnd(rng.diameterRange.GetEnd());
                newrng.ifCollectXray = rng.ifCollectXray;
                rngs.Add(newrng);
            }
            param.SetSpecailGrayRanges(rngs);
            return param;
        
        }
        public bool GetIsToRun()
        {
            
            return isToRun;
        }

        public void SetIsToRun(bool value)
        {
            isToRun = value;
        }

       
        public bool IsToRun { get => isToRun; set => isToRun = value; }

        public List<CSpecialGrayRange> GetSpecialGreyRanges()
        {
            
            return Ranges;
        }

        public void SetSpecailGrayRanges(List<CSpecialGrayRange> value)
        {
            Ranges = value;
        }

        public override void Serialize(bool isStoring, XmlDocument classDoc, XmlNode rootNode)
        {
          
            Collection<CSpecialGrayRange> xRangelist = new Collection<CSpecialGrayRange>();
            xBool xtoRun = new xBool();
           

            Slo slo = new Slo();


            slo.Register("ToRun", xtoRun);
            slo.Register("GrayRangeList", xRangelist);
            if (isStoring)
            {
                xtoRun.AssignValue(isToRun);
                for (int i = 0; i < Ranges.Count; i++)
                {
                    xRangelist.addItem(Ranges[i]);
                }
               
                slo.Serialize(true, classDoc, rootNode);
            }
            else
            {
                slo.Serialize(false, classDoc, rootNode);

                isToRun = xtoRun.value();
                Ranges.Clear();
                for (int i = 0; i < xRangelist.size(); i++)
                {
                    Ranges.Add(xRangelist.getItem(i));
                }
            }
        }
        
    }
}