using CoreUnit.Common;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.IO;
using System.Xml;
using Newtonsoft.Json;
using System.Text;
using Formatting = System.Xml.Formatting;


namespace DB.Recipe
{
    public class RecipeFieldScan
    {
        public class FieldScanParam
        {
            int m_column;
            [XmlSerializable]
            public int Column
            {
                get { return m_column; }
                set { m_column = value; }
            }
            int m_row;
            [XmlSerializable]
            public int Row
            {
                get { return m_row; }
                set { m_row = value; }
            }

            PointF m_scannerPos;
            [XmlSerializable]
            public PointF ScannerPos
            {
                get { return m_scannerPos; }
                set { m_scannerPos = value; }
            }

            bool m_enableScan;
            [XmlSerializable]
            public bool EnableScan
            {
                get { return m_enableScan; }
                set { m_enableScan = value; }
            }

            Rectangle m_imageRect;
            [XmlSerializable]
            public Rectangle ImageRect
            {
                get { return m_imageRect; }
                set { m_imageRect = value; }
            }

            PointF m_offsetPos;
            [XmlSerializable]
            public PointF OffsetPos
            {
                get { return m_offsetPos; }
                set { m_offsetPos = value; }
            }

            public FieldScanParam()
            {
                m_enableScan = true;
            }
        }

        List<FieldScanParam> m_fieldScanParams = new List<FieldScanParam>();
        public List<FieldScanParam> FieldScanParams
        {
            get { lock (this) { return m_fieldScanParams; } }
            set { lock (this) { m_fieldScanParams = value; } }
        }


        public void Reset()
        {
        }

        public void Load(string fileName)
        {
            try
            {
                XmlDocument doc = new XmlDocument();
                var extenstion = Path.GetExtension(fileName);
                if (extenstion == ".json")
                {
                    var jsonString = File.ReadAllText(fileName);
                    doc = JsonConvert.DeserializeXmlNode(jsonString, "RecipeBody");
                }
                else
                {
                    StreamReader sr = new StreamReader(fileName);
                    doc.Load(sr);
                    sr.Dispose();
                }

                XmlElement root = doc.DocumentElement;

                foreach (XmlElement node in root.ChildNodes)
                {
                    if (node.Name == "property")
                    {
                        XmlUtil.ParseProperty(node, this);
                    }

                    if(node.Name == "RecipeFieldScan")
                    {
                        var interNode = node.ChildNodes[0];

                        FieldScanParams.Clear();

                        foreach (XmlElement itemNode in interNode.ChildNodes)
                        {
                            Object param = new FieldScanParam();
                            XmlUtil.ParseProperties(itemNode, param);
                            FieldScanParams.Add((FieldScanParam)param);
                        }
                    }

                    if (node.Name == "items")
                    {
                        FieldScanParams.Clear();

                        foreach (XmlElement itemNode in node.ChildNodes)
                        {
                            Object param = new FieldScanParam();
                            XmlUtil.ParseProperties(itemNode, param);
                            FieldScanParams.Add((FieldScanParam)param);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public void Load()
        {
            FileInfo fi = new FileInfo(Properties.Settings.Default.FieldScanParamFile);

            if (!fi.Exists)
            {
                var dir = Path.GetDirectoryName(fi.FullName);
                if (!Directory.Exists(dir))
                {
                    Directory.CreateDirectory(Path.GetDirectoryName(fi.FullName));
                }
                File.Copy(@"..\..\..\External\LaserScanner\FieldScanParam.json", fi.FullName);
            }
            Load(Properties.Settings.Default.FieldScanParamFile);
        }

        public void Save()
        {
            Save(Properties.Settings.Default.FieldScanParamFile);
        }

        public void Save(string fileName)
        {
            try
            {
                using (MemoryStream stream = new MemoryStream())
                {
                    XmlTextWriter wr = new XmlTextWriter(stream, Encoding.UTF8);
                    wr.Formatting = Formatting.Indented;

                    wr.WriteStartElement("RecipeFieldScan");//1.레시피 항목

                    wr.WriteStartElement("items"); //2.Items 항목
                    foreach (FieldScanParam param in FieldScanParams)
                    {
                        wr.WriteStartElement("FieldScanParam");//3.Field Scan 항목
                        XmlUtil.WriteProperties(param, wr);
                        wr.WriteEndElement();//3.Field Scan 항목
                    }
                    wr.WriteEndElement();//2.Items 항목

                    wr.WriteEndElement();//1.레시피 항목

                    wr.Flush();

                    XmlDocument doc = new XmlDocument();
                    stream.Position = 0;
                    doc.Load(stream);

                    string jsonStr = JsonConvert.SerializeXmlNode(doc, Newtonsoft.Json.Formatting.Indented);
                    File.WriteAllText(fileName, jsonStr);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
    }
}