using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;

namespace RealTimeGraphEx.Models
{
    public class RealTimeGraphExReachPolygon
    {
        public List<Point> Points { get; set; }
        public List<double> ActualValues { get; set; }

        public int TotalPoints
        {
            get { return Points.Count; }
        }

        public RealTimeGraphExReachPolygon()
        {
            Points = new List<Point>();
            ActualValues = new List<double>();
        }

        public Point Add(double xValue, double yValue, double actualValue)
        {
            var p = new Point(xValue, yValue);
            Points.Add(p);
            ActualValues.Add(actualValue);
            return p;
        }

        public Point Replace(double xValue, double yValue, double actualValue, int index)
        {
            var p = new Point(xValue, yValue);
            Points.RemoveAt(index);
            Points.Insert(index, p);
            ActualValues.RemoveAt(index);
            ActualValues.Insert(index, actualValue);

            return p;
        }

        public void RemoveFromStart(int count)
        {
            lock (Points)
            {
                Points.RemoveRange(0, count);
                ActualValues.RemoveRange(0, count);

                double offSet = Points[0].X;

                for (int i = 0; i < Points.Count; i++)
                {
                    Points[i] = new Point(Points[i].X - offSet, Points[i].Y);
                }
            }
        }

        public void ClearPoints()
        {
            Points.Clear();
        }

        public void ClearActualPoints()
        {
            ActualValues.Clear();
        }

        public List<Point> ToPolygonPointsFill(double width, double heightpre { line-height: 125%; }
td.linenos .normal { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
span.linenos { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
td.linenos .special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
.highlight .hll { background-color: #ffffcc }
.highlight .c { color: #888888 } /* Comment */
.highlight .err { color: #a61717; background-color: #e3d2d2 } /* Error */
.highlight .k { color: #008800; font-weight: bold } /* Keyword */
.highlight .ch { color: #888888 } /* Comment.Hashbang */
.highlight .cm { color: #888888 } /* Comment.Multiline */
.highlight .cp { color: #cc0000; font-weight: bold } /* Comment.Preproc */
.highlight .cpf { color: #888888 } /* Comment.PreprocFile */
.highlight .c1 { color: #888888 } /* Comment.Single */
.highlight .cs { color: #cc0000; font-weight: bold; background-color: #fff0f0 } /* Comment.Special */
.highlight .gd { color: #000000; background-color: #ffdddd } /* Generic.Deleted */
.highlight .ge { font-style: italic } /* Generic.Emph */
.highlight .ges { font-weight: bold; font-style: italic } /* Generic.EmphStrong */
.highlight .gr { color: #aa0000 } /* Generic.Error */
.highlight .gh { color: #333333 } /* Generic.Heading */
.highlight .gi { color: #000000; background-color: #ddffdd } /* Generic.Inserted */
.highlight .go { color: #888888 } /* Generic.Output */
.highlight .gp { color: #555555 } /* Generic.Prompt */
.highlight .gs { font-weight: bold } /* Generic.Strong */
.highlight .gu { color: #666666 } /* Generic.Subheading */
.highlight .gt { color: #aa0000 } /* Generic.Traceback */
.highlight .kc { color: #008800; font-weight: bold } /* Keyword.Constant */
.highlight .kd { color: #008800; font-weight: bold } /* Keyword.Declaration */
.highlight .kn { color: #008800; font-weight: bold } /* Keyword.Namespace */
.highlight .kp { color: #008800 } /* Keyword.Pseudo */
.highlight .kr { color: #008800; font-weight: bold } /* Keyword.Reserved */
.highlight .kt { color: #888888; font-weight: bold } /* Keyword.Type */
.highlight .m { color: #0000DD; font-weight: bold } /* Literal.Number */
.highlight .s { color: #dd2200; background-color: #fff0f0 } /* Literal.String */
.highlight .na { color: #336699 } /* Name.Attribute */
.highlight .nb { color: #003388 } /* Name.Builtin */
.highlight .nc { color: #bb0066; font-weight: bold } /* Name.Class */
.highlight .no { color: #003366; font-weight: bold } /* Name.Constant */
.highlight .nd { color: #555555 } /* Name.Decorator */
.highlight .ne { color: #bb0066; font-weight: bold } /* Name.Exception */
.highlight .nf { color: #0066bb; font-weight: bold } /* Name.Function */
.highlight .nl { color: #336699; font-style: italic } /* Name.Label */
.highlight .nn { color: #bb0066; font-weight: bold } /* Name.Namespace */
.highlight .py { color: #336699; font-weight: bold } /* Name.Property */
.highlight .nt { color: #bb0066; font-weight: bold } /* Name.Tag */
.highlight .nv { color: #336699 } /* Name.Variable */
.highlight .ow { color: #008800 } /* Operator.Word */
.highlight .w { color: #bbbbbb } /* Text.Whitespace */
.highlight .mb { color: #0000DD; font-weight: bold } /* Literal.Number.Bin */
.highlight .mf { color: #0000DD; font-weight: bold } /* Literal.Number.Float */
.highlight .mh { color: #0000DD; font-weight: bold } /* Literal.Number.Hex */
.highlight .mi { color: #0000DD; font-weight: bold } /* Literal.Number.Integer */
.highlight .mo { color: #0000DD; font-weight: bold } /* Literal.Number.Oct */
.highlight .sa { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Affix */
.highlight .sb { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Backtick */
.highlight .sc { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Char */
.highlight .dl { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Delimiter */
.highlight .sd { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Doc */
.highlight .s2 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Double */
.highlight .se { color: #0044dd; background-color: #fff0f0 } /* Literal.String.Escape */
.highlight .sh { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Heredoc */
.highlight .si { color: #3333bb; background-color: #fff0f0 } /* Literal.String.Interpol */
.highlight .sx { color: #22bb22; background-color: #f0fff0 } /* Literal.String.Other */
.highlight .sr { color: #008800; background-color: #fff0ff } /* Literal.String.Regex */
.highlight .s1 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Single */
.highlight .ss { color: #aa6600; background-color: #fff0f0 } /* Literal.String.Symbol */
.highlight .bp { color: #003388 } /* Name.Builtin.Pseudo */
.highlight .fm { color: #0066bb; font-weight: bold } /* Name.Function.Magic */
.highlight .vc { color: #336699 } /* Name.Variable.Class */
.highlight .vg { color: #dd7700 } /* Name.Variable.Global */
.highlight .vi { color: #3333bb } /* Name.Variable.Instance */
.highlight .vm { color: #336699 } /* Name.Variable.Magic */
.highlight .il { color: #0000DD; font-weight: bold } /* Literal.Number.Integer.Long */
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using Tango.CodeGeneration;
using Tango.BL.Entities;
using Tango.BL;
using static Tango.Core.Components.DataBaseDescriptionsHelper;
using Tango.Core.Components;
using System.ComponentModel.DataAnnotations.Schema;
using Newtonsoft.Json;

namespace Tango.PMRGenerator.CLI
{
    class Program
    {
        private static List<DbDescription> _dbDescriptions;

        static void Main(string[] args)
        {
            Console.Title = "Tango PMR Generator";

            Console.WriteLine("Generating PMR's...");
            Console.WriteLine();

            Environment.CurrentDirectory = Path.GetDirectoryName(Assembly.GetEntryAssembly().Location);
            String pmrFolder = Path.GetFullPath("..\\..\\..\\..\\PMR\\Messages");

            using (ObservablesContext db = ObservablesContext.CreateDefault())
            {
                db.Database.Connection.Open();

                _dbDescriptions = DataBaseDescriptionsHelper.GetDescriptions(db.Database.Connection);

                db.Configuration.LazyLoadingEnabled = true;
                GenerateHardwareMotors(db, pmrFolder);
                GenerateHardwareDancers(db, pmrFolder);
                GenerateHardwarePidControls(db, pmrFolder);
                GenerateHardwareDispensers(db, pmrFolder);
                GenerateHardwareWinders(db, pmrFolder);
                GenerateHardwareSpeedSensors(db, pmrFolder);
                GenerateHardwareBlowers(db, pmrFolder);
                GenerateHardwareBreakSensors(db, pmrFolder);
                GenerateLiquidTypes(db, pmrFolder);
                GenerateWindingMethods(db, pmrFolder);
                GenerateSpoolTypes(db, pmrFolder);
                GenerateProcessParameters(db, pmrFolder);
                GenerateHeaterTypes(db, pmrFolder);
                GenerateValves(db, pmrFolder);
                GenerateValvesStates(db, pmrFolder);

                GenerateColorLabColorSpaces(db, pmrFolder);
                GenerateColorLabLiquidTypes(db, pmrFolder);
                GenerateDiagnosticsValueComponents(db, pmrFolder);
                GenerateDiagnosticsMonitors(db, pmrFolder);
                GenerateEventTypes(db, pmrFolder);
                GenerateInterfaceIOs(db, pmrFolder);
            }

            Console.WriteLine("Done");
        }

        private static void GenerateHardwareMotors(ObservablesContext db, String pmrFolder)
        {
            Console.WriteLine("Generating Hardware Motor Types...");

            ProtoEnumFile enumFile = new ProtoEnumFile();
            enumFile.Name = "HardwareMotorType";
            enumFile.Package = "Tango.PMR.Hardware";

            foreach (var field in db.HardwareMotorTypes.ToList().OrderBy(x => x.Code))
            {
                enumFile.Fields.Add(new EnumerationField()
                {
                    Name = field.Name.Replace(" ", ""),
                    Value = field.Code,
                    Description = field.Description,
                });
            }

            Console.WriteLine("Generating Hardware Motor...");
            ProtoMessageFile messageFile = new ProtoMessageFile();
            messageFile.Name = "HardwareMotor";
            messageFile.Package = "Tango.PMR.Hardware";
            messageFile.Imports.Add("HardwareMotorType.proto");

            messageFile.Properties.Add(new ProtoProperty("HardwareMotorType", "HardwareMotorType"));

            foreach (var prop in typeof(HardwareMotorBase).GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly).Where(x => x.PropertyType.IsPrimitive && x.Name != "Active"))
            {
                messageFile.Properties.Add(new ProtoProperty(prop.Name, CoercePropertyType(prop.PropertyType), GetDbDescription<HardwareMotorBase>(prop)));
            }

            String enumString = enumFile.GenerateCode();
            String messageString = messageFile.GenerateCode();

            File.WriteAllText(Path.Combine(pmrFolder, "Hardware", enumFile.Name + ".proto"), enumString);
            File.WriteAllText(Path.Combine(pmrFolder, "Hardware", messageFile.Name + ".proto"), messageString);
        }

        private static void GenerateHardwareDancers(ObservablesContext db, String pmrFolder)
        {
            Console.WriteLine("Generating Hardware Dancer Types...");

            ProtoEnumFile enumFile = new ProtoEnumFile();
            enumFile.Name = "HardwareDancerType";
            enumFile.Package = "Tango.PMR.Hardware";

            foreach (var field in db.HardwareDancerTypes.ToList().OrderBy(x => x.Code))
            {
                enumFile.Fields.Add(new EnumerationField()
                {
                    Name = field.Name.Replace(" ", ""),
                    Value = field.Code,
                    Description = field.Description,
                });
            }

            Console.WriteLine("Generating Hardware Dancer...");

            ProtoMessageFile messageFile = new ProtoMessageFile();
            messageFile.Name = "HardwareDancer";
            messageFile.Package = "Tango.PMR.Hardware";
            messageFile.Imports.Add("HardwareDancerType.proto");

            messageFile.Properties.Add(new ProtoProperty("HardwareDancerType", "HardwareDancerType"));

            foreach (var prop in typeof(HardwareDancerBase).GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly).Where(x => x.PropertyType.IsPrimitive && x.Name != "Active"))
            {
                messageFile.Properties.Add(new ProtoProperty(prop.Name, CoercePropertyType(prop.PropertyType), GetDbDescription<HardwareDancerBase>(prop)));
            }

            String enumString = enumFile.GenerateCode();
            String messageString = messageFile.GenerateCode();

            File.WriteAllText(Path.Combine(pmrFolder, "Hardware", enumFile.Name + ".proto"), enumString);
            File.WriteAllText(Path.Combine(pmrFolder, "Hardware", messageFile.Name + ".proto"), messageString);
        }

        private static void GenerateHardwarePidControls(ObservablesContext db, String pmrFolder)
        {
            Console.WriteLine("Generating Hardware PID Control Types...");

            ProtoEnumFile enumFile = new ProtoEnumFile();
            enumFile.Name = "HardwarePidControlType";
            enumFile.Package = "Tango.PMR.Hardware";

            foreach (var field in db.HardwarePidControlTypes.ToList().OrderBy(x => x.Code))
            {
                enumFile.Fields.Add(new EnumerationField()
                {
                    Name = field.Name.Replace(" ", ""),
                    Value = field.Code,
                    Description = field.Description,
                });
            }

            Console.WriteLine("Generating Hardware PID Control...");

            ProtoMessageFile messageFile = new ProtoMessageFile();
            messageFile.Name = "HardwarePidControl";
            messageFile.Package = "Tango.PMR.Hardware";
            messageFile.Imports.Add("HardwarePidControlType.proto");

            messageFile.Properties.Add(new ProtoProperty("HardwarePidControlType", "HardwarePidControlType"));

            foreach (var prop in typeof(HardwarePidControlBase).GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly).Where(x => x.PropertyType.IsPrimitive && x.Name != "Active"))
            {
                messageFile.Properties.Add(new ProtoProperty(prop.Name, CoercePropertyType(prop.PropertyType), GetDbDescription<HardwarePidControlBase>(prop)));
            }

            String enumString = enumFile.GenerateCode();
            String messageString = messageFile.GenerateCode();

            File.WriteAllText(Path.Combine(pmrFolder, "Hardware", enumFile.Name + ".proto"), enumString);
            File.WriteAllText(Path.Combine(pmrFolder, "Hardware", messageFile.Name + ".proto"), messageString);
        }

        private static void GenerateHardwareDispensers(ObservablesContext db, String pmrFolder)
        {
            Console.WriteLine("Generating Hardware Dispenser Types...");

            ProtoEnumFile enumFile = new ProtoEnumFile();
            enumFile.Name = "HardwareDispenserType";
            enumFile.Package = "Tango.PMR.Hardware";

            foreach (var field in db.DispenserTypes.ToList().OrderBy(x => x.Code))
            {
                enumFile.Fields.Add(new EnumerationField()
                {
                    Name = field.Name.Replace(" ", ""),
                    Value = field.Code,
                });
            }

            Console.WriteLine("Generating Hardware Dispenser...");

            ProtoMessageFile messageFile = new ProtoMessageFile();
            messageFile.Name = "HardwareDispenser";
            messageFile.Package = "Tango.PMR.Hardware";
            messageFile.Imports.Add("HardwareDispenserType.proto");

            messageFile.Properties.Add(new ProtoProperty("HardwareDispenserType", "HardwareDispenserType"));

            messageFile.Properties.Add(new ProtoProperty("Index", "int32"));

            foreach (var prop in typeof(DispenserTypeBase).GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly).Where(x => x.PropertyType.IsPrimitive))
            {
                if (prop.Name != "Name" && prop.Name != "Code")
                {
                    messageFile.Properties.Add(new ProtoProperty(prop.Name, CoercePropertyType(prop.PropertyType), GetDbDescription<DispenserTypeBase>(prop)));
                }
            }

            foreach (var prop in typeof(DispenserBase).GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly).Where(x => x.PropertyType.IsPrimitive))
            {
                if (prop.Name != nameof(Dispenser.IsInstalled))
                {
                    messageFile.Properties.Add(new ProtoProperty(prop.Name, CoercePropertyType(prop.PropertyType), GetDbDescription<DispenserBase>(prop)));
                }
            }

            String enumString = enumFile.GenerateCode();
            String messageString = messageFile.GenerateCode();

            File.WriteAllText(Path.Combine(pmrFolder, "Hardware", enumFile.Name + ".proto"), enumString);
            File.WriteAllText(Path.Combine(pmrFolder, "Hardware", messageFile.Name + ".proto"), messageString);
        }

        private static void GenerateHardwareWinders(ObservablesContext db, String pmrFolder)
        {
            Console.WriteLine("Generating Hardware Winder Types...");

            ProtoEnumFile enumFile = new ProtoEnumFile();
            enumFile.Name = "HardwareWinderType";
            enumFile.Package = "Tango.PMR.Hardware";

            foreach (var field in db.HardwareWinderTypes.ToList().OrderBy(x => x.Code))
            {
                enumFile.Fields.Add(new EnumerationField()
                {
                    Name = field.Name.Replace(" ", ""),
                    Value = field.Code,
                    Description = field.Description,
                });
            }

            Console.WriteLine("Generating Hardware Winder...");
            ProtoMessageFile messageFile = new ProtoMessageFile();
            messageFile.Name = "HardwareWinder";
            messageFile.Package = "Tango.PMR.Hardware";
            messageFile.Imports.Add("HardwareWinderType.proto");

            messageFile.Properties.Add(new ProtoProperty("HardwareWinderType", "HardwareWinderType"));

            foreach (var prop in typeof(HardwareWinderBase).GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly).Where(x => x.PropertyType.IsPrimitive && x.Name != "Active"))
            {
                messageFile.Properties.Add(new ProtoProperty(prop.Name, CoercePropertyType(prop.PropertyType), GetDbDescription<HardwareWinderBase>(prop)));
            }

            String enumString = enumFile.GenerateCode();
            String messageString = messageFile.GenerateCode();

            File.WriteAllText(Path.Combine(pmrFolder, "Hardware", enumFile.Name + ".proto"), enumString);
            File.WriteAllText(Path.Combine(pmrFolder, "Hardware", messageFile.Name + ".proto"), messageString);
        }

        private static void GenerateHardwareSpeedSensors(ObservablesContext db, String pmrFolder)
        {
            Console.WriteLine("Generating Hardware Speed Sensor Types...");

            ProtoEnumFile enumFile = new ProtoEnumFile();
            enumFile.Name = "HardwareSpeedSensorType";
            enumFile.Package = "Tango.PMR.Hardware";

            foreach (var field in db.HardwareSpeedSensorTypes.ToList().OrderBy(x => x.Code))
            {
                enumFile.Fields.Add(new EnumerationField()
                {
                    Name = field.Name.Replace(" ", ""),
                    Value = field.Code,
                    Description = field.Description,
                });
            }

            Console.WriteLine("Generating Hardware Speed Sensor...");
            ProtoMessageFile messageFile = new ProtoMessageFile();
            messageFile.Name = "HardwareSpeedSensor";
            messageFile.Package = "Tango.PMR.Hardware";
            messageFile.Imports.Add("HardwareSpeedSensorType.proto");

            messageFile.Properties.Add(new ProtoProperty("HardwareSpeedSensorType", "HardwareSpeedSensorType"));

            foreach (var prop in typeof(HardwareSpeedSensorBase).GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly).Where(x => x.PropertyType.IsPrimitive && x.Name != "Active"))
            {
                messageFile.Properties.Add(new ProtoProperty(prop.Name, CoercePropertyType(prop.PropertyType), GetDbDescription<HardwareSpeedSensorBase>(prop)));
            }

            String enumString = enumFile.GenerateCode();
            String messageString = messageFile.GenerateCode();

            File.WriteAllText(Path.Combine(pmrFolder, "Hardware", enumFile.Name + ".proto"), enumString);
            File.WriteAllText(Path.Combine(pmrFolder, "Hardware", messageFile.Name + ".proto"), messageString);
        }

        private static void GenerateHardwareBlowers(ObservablesContext db, String pmrFolder)
        {
            Console.WriteLine("Generating Hardware Blower Types...");

            ProtoEnumFile enumFile = new ProtoEnumFile();
            enumFile.Name = "HardwareBlowerType";
            enumFile.Package = "Tango.PMR.Hardware";

            foreach (var field in db.HardwareBlowerTypes.ToList().OrderBy(x => x.Code))
            {
                enumFile.Fields.Add(new EnumerationField()
                {
                    Name = field.Name.Replace(" ", ""),
                    Value = field.Code,
                    Description = field.Description,
                });
            }

            Console.WriteLine("Generating Hardware Blowers...");
            ProtoMessageFile messageFile = new ProtoMessageFile();
            messageFile.Name = "HardwareBlower";
            messageFile.Package = "Tango.PMR.Hardware";
            messageFile.Imports.Add("HardwareBlowerType.proto");

            messageFile.Properties.Add(new ProtoProperty("HardwareBlowerType", "HardwareBlowerType"));

            foreach (var prop in typeof(HardwareBlowerBase).GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly).Where(x => x.PropertyType.IsPrimitive && x.Name != "Active"))
            {
                messageFile.Properties.Add(new ProtoProperty(prop.Name, CoercePropertyType(prop.PropertyType), GetDbDescription<HardwareBlowerBase>(prop)));
            }

            String enumString = enumFile.GenerateCode();
            String messageString = messageFile.GenerateCode();

            File.WriteAllText(Path.Combine(pmrFolder, "Hardware", enumFile.Name + ".proto"), enumString);
            File.WriteAllText(Path.Combine(pmrFolder, "Hardware", messageFile.Name + ".proto"), messageString);
        }

        private static void GenerateHardwareBreakSensors(ObservablesContext db, String pmrFolder)
        {
            Console.WriteLine("Generating Hardware Break Sensor Types...");

            ProtoEnumFile enumFile = new ProtoEnumFile();
            enumFile.Name = "HardwareBreakSensorType";
            enumFile.Package = "Tango.PMR.Hardware";

            foreach (var field in db.HardwareBreakSensorTypes.ToList().OrderBy(x => x.Code))
            {
                enumFile.Fields.Add(new EnumerationField()
                {
                    Name = field.Name.Replace(" ", ""),
                    Value = field.Code,
                    Description = field.Description,
                });
            }

            Console.WriteLine("Generating Hardware Break Sensor...");
            ProtoMessageFile messageFile = new ProtoMessageFile();
            messageFile.Name = "HardwareBreakSensor";
            messageFile.Package = "Tango.PMR.Hardware";
            messageFile.Imports.Add("HardwareBreakSensorType.proto");

            messageFile.Properties.Add(new ProtoProperty("HardwareBreakSensorType", "HardwareBreakSensorType"));

            foreach (var prop in typeof(HardwareBreakSensorBase).GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly).Where(x => x.PropertyType.IsPrimitive && x.Name != "Active"))
            {
                messageFile.Properties.Add(new ProtoProperty(prop.Name, CoercePropertyType(prop.PropertyType), GetDbDescription<HardwareBreakSensorBase>(prop)));
            }

            String enumString = enumFile.GenerateCode();
            String messageString = messageFile.GenerateCode();

            File.WriteAllText(Path.Combine(pmrFolder, "Hardware", enumFile.Name + ".proto"), enumString);
            File.WriteAllText(Path.Combine(pmrFolder, "Hardware", messageFile.Name + ".proto"), messageString);
        }

        private static void GenerateLiquidTypes(ObservablesContext db, String pmrFolder)
        {
            Console.WriteLine("Generating Dispenser Liquid Types...");

            ProtoEnumFile enumFile = new ProtoEnumFile();
            enumFile.Name = "DispenserLiquidType";
            enumFile.Package = "Tango.PMR.Printing";

            foreach (var field in db.LiquidTypes.ToList().OrderBy(x => x.Code))
            {
                enumFile.Fields.Add(new EnumerationField()
                {
                    Name = field.Name.Replace(" ", ""),
                    Value = field.Code,
                });
            }

            String enumString = enumFile.GenerateCode();

            File.WriteAllText(Path.Combine(pmrFolder, "Printing", enumFile.Name + ".proto"), enumString);
        }

        private static void GenerateWindingMethods(ObservablesContext db, String pmrFolder)
        {
            Console.WriteLine("Generating Winding Methods...");

            ProtoEnumFile enumFile = new ProtoEnumFile();
            enumFile.Name = "JobWindingMethod";
            enumFile.Package = "Tango.PMR.Printing";

            foreach (var field in db.WindingMethods.ToList().OrderBy(x => x.Code))
            {
                enumFile.Fields.Add(new EnumerationField()
                {
                    Name = field.Name.Replace(" ", ""),
                    Value = field.Code,
                    Description = field.Description,
                });
            }

            String enumString = enumFile.GenerateCode();

            File.WriteAllText(Path.Combine(pmrFolder, "Printing", enumFile.Name + ".proto"), enumString);
        }

        private static void GenerateHeaterTypes(ObservablesContext db, String pmrFolder)
        {
            Console.WriteLine("Generating Heater Types...");

            ProtoEnumFile enumFile = new ProtoEnumFile();
            enumFile.Name = "HeaterType";
            enumFile.Package = "Tango.PMR.Diagnostics";

            foreach (var field in db.TechHeaters.ToList().OrderBy(x => x.Code))
            {
                enumFile.Fields.Add(new EnumerationField()
                {
                    Name = field.Name.Replace(" ", ""),
                    Value = field.Code,
                });
            }

            String enumString = enumFile.GenerateCode();

            File.WriteAllText(Path.Combine(pmrFolder, "Diagnostics", enumFile.Name + ".proto"), enumString);
        }

        private static void GenerateValves(ObservablesContext db, string pmrFolder)
        {
            Console.WriteLine("Generating Valve Types...");

            ProtoEnumFile enumFile = new ProtoEnumFile();
            enumFile.Name = "ValveType";
            enumFile.Package = "Tango.PMR.Diagnostics";

            foreach (var field in db.TechValves.ToList().OrderBy(x => x.Code))
            {
                enumFile.Fields.Add(new EnumerationField()
                {
                    Name = field.Name.Replace(" ", ""),
                    Value = field.Code,
                });
            }

            String enumString = enumFile.GenerateCode();

            File.WriteAllText(Path.Combine(pmrFolder, "Diagnostics", enumFile.Name + ".proto"), enumString);
        }

        private static void GenerateValvesStates(ObservablesContext db, string pmrFolder)
        {
            Console.WriteLine("Generating Valve State Codes...");

            ProtoEnumFile enumFile = new ProtoEnumFile();
            enumFile.Name = "ValveStateCode";
            enumFile.Package = "Tango.PMR.Diagnostics";

            List<String> states = new List<string>();

            foreach (var item in db.TechValves.ToList().OrderBy(x => x.Code))
            {
                if (!states.Contains(item.State1))
                {
                    states.Add(item.State1);
                }

                if (!states.Contains(item.State2))
                {
                    states.Add(item.State2);
                }
            }

            int code = 0;

            foreach (var state in states)
            {
                enumFile.Fields.Add(new EnumerationField()
                {
                    Name = state.Replace(" ", ""),
                    Value = code++,
                });
            }

            String enumString = enumFile.GenerateCode();

            File.WriteAllText(Path.Combine(pmrFolder, "Diagnostics", enumFile.Name + ".proto"), enumString);
        }

        private static void GenerateSpoolTypes(ObservablesContext db, String pmrFolder)
        {
            Console.WriteLine("Generating Spool Types...");

            ProtoEnumFile enumFile = new ProtoEnumFile();
            enumFile.Name = "JobSpoolType";
            enumFile.Package = "Tango.PMR.Printing";

            foreach (var field in db.SpoolTypes.ToList().OrderBy(x => x.Code))
            {
                enumFile.Fields.Add(new EnumerationField()
                {
                    Name = field.Name.Replace(" ", ""),
                    Value = field.Code,
                });
            }

            Console.WriteLine("Generating Spool...");
            ProtoMessageFile messageFile = new ProtoMessageFile();
            messageFile.Name = "JobSpool";
            messageFile.Package = "Tango.PMR.Printing";
            messageFile.Imports.Add("JobSpoolType.proto");

            messageFile.Properties.Add(new ProtoProperty("JobSpoolType", "JobSpoolType"));

            foreach (var prop in typeof(SpoolTypeBase).GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly).Where(x => x.PropertyType.IsPrimitive))
            {
                if (prop.Name != "Name" && prop.Name != "Code")
                {
                    messageFile.Properties.Add(new ProtoProperty(prop.Name, CoercePropertyType(prop.PropertyType)));
                }
            }

            foreach (var prop in typeof(SpoolBase).GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly).Where(x => x.PropertyType.IsPrimitive))
            {
                messageFile.Properties.Add(new ProtoProperty(prop.Name, CoercePropertyType(prop.PropertyType)));
            }

            String enumString = enumFile.GenerateCode();
            String messageString = messageFile.GenerateCode();

            File.WriteAllText(Path.Combine(pmrFolder, "Printing", enumFile.Name + ".proto"), enumString);
            File.WriteAllText(Path.Combine(pmrFolder, "Printing", messageFile.Name + ".proto"), messageString);
        }

        private static void GenerateProcessParameters(ObservablesContext db, String pmrFolder)
        {
            Console.WriteLine("Generating Process Parameters...");
            ProtoMessageFile messageFile = new ProtoMessageFile();
            messageFile.Name = "ProcessParameters";
            messageFile.Package = "Tango.PMR.Printing";

            foreach (var prop in typeof(ProcessParametersTableBase).GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly).Where(x => x.PropertyType.IsPrimitive))
            {
                messageFile.Properties.Add(new ProtoProperty(prop.Name, CoercePropertyType(prop.PropertyType), GetDbDescription<ProcessParametersTableBase>(prop)));
            }

            String messageString = messageFile.GenerateCode();

            File.WriteAllText(Path.Combine(pmrFolder, "Printing", messageFile.Name + ".proto"), messageString);
        }

        private static void GenerateColorLabColorSpaces(ObservablesContext db, String pmrFolder)
        {
            Console.WriteLine("Generating ColorLab Color Spaces...");

            ProtoEnumFile enumFile = new ProtoEnumFile();
            enumFile.Name = "ColorSpace";
            enumFile.Package = "Tango.PMR.ColorLab";

            foreach (var field in db.ColorSpaces.ToList().OrderBy(x => x.Code))
            {
                enumFile.Fields.Add(new EnumerationField()
                {
                    Name = field.Name.Replace(" ", ""),
                    Value = field.Code,
                });
            }

            String enumString = enumFile.GenerateCode();

            File.WriteAllText(Path.Combine(pmrFolder, "ColorLab", enumFile.Name + ".proto"), enumString);
        }

        private static void GenerateColorLabLiquidTypes(ObservablesContext db, String pmrFolder)
        {
            Console.WriteLine("Generating ColorLab Liquid Types...");

            ProtoEnumFile enumFile = new ProtoEnumFile();
            enumFile.Name = "LiquidType";
            enumFile.Package = "Tango.PMR.ColorLab";

            foreach (var field in db.LiquidTypes.ToList().OrderBy(x => x.Code))
            {
                enumFile.Fields.Add(new EnumerationField()
                {
                    Name = field.Name.Replace(" ", ""),
                    Value = field.Code,
                });
            }

            String enumString = enumFile.GenerateCode();

            File.WriteAllText(Path.Combine(pmrFolder, "ColorLab", enumFile.Name + ".proto"), enumString);
        }

        private static void GenerateDiagnosticsValueComponents(ObservablesContext db, String pmrFolder)
        {
            Console.WriteLine("Generating Diagnostics Value Component...");

            ProtoEnumFile enumFile = new ProtoEnumFile();
            enumFile.Name = "ValueComponent";
            enumFile.Package = "Tango.PMR.Diagnostics";

            foreach (var field in db.TechControllers.ToList().OrderBy(x => x.Code))
            {
                enumFile.Fields.Add(new EnumerationField()
                {
                    Name = field.Name.Replace(" ", ""),
                    Description = field.Description + String.Format(" (Min = {0}, Max = {1})", field.Min, field.Max),
                    Value = field.Code,
                });
            }

            String enumString = enumFile.GenerateCode();

            File.WriteAllText(Path.Combine(pmrFolder, "Diagnostics", enumFile.Name + ".proto"), enumString);
        }

        private static void GenerateDiagnosticsMonitors(ObservablesContext db, String pmrFolder)
        {
            Console.WriteLine("Generating Monitors...");

            ProtoMessageFile messageFile = new ProtoMessageFile();
            messageFile.Name = "DiagnosticsMonitors";
            messageFile.Package = "Tango.PMR.Diagnostics";

            messageFile.Imports.Add("DoubleArray.proto");

            foreach (var monitor in db.TechMonitors.ToList().OrderBy(x => x.Code))
            {
                var prop = new ProtoProperty();
                prop.Name = monitor.Name.Replace(" ", "");
                prop.Description = monitor.Description + String.Format(" (Min = {0}, Max = {1}, PPF = {2})", monitor.Min, monitor.Max, monitor.PointsPerFrame);
                prop.Repeated = true;

                if (!monitor.MultiChannel)
                {
                    prop.Type = "double";
                }
                else
                {
                    prop.Type = "DoubleArray";
                    prop.Description += String.Format(" Channel Count = {0}", monitor.ChannelCount);
                }

                messageFile.Properties.Add(prop);
            }

            String messageString = messageFile.GenerateCode();

            File.WriteAllText(Path.Combine(pmrFolder, "Diagnostics", messageFile.Name + ".proto"), messageString);
        }

        private static void GenerateInterfaceIOs(ObservablesContext db, String pmrFolder)
        {
            Console.WriteLine("Generating Interface IOs...");

            ProtoEnumFile enumFile = new ProtoEnumFile();
            enumFile.Name = "InterfaceIOs";
            enumFile.Package = "Tango.PMR.Diagnostics";

            foreach (var tech_io in db.TechIos.OrderBy(x => x.Code))
            {
                enumFile.Fields.Add(new EnumerationField()
                {
                    Name = tech_io.Name.Replace(" ", ""),
                    Description = $"Designator: {tech_io.Designator}",
                    Value = tech_io.Code,
                });
            }

            String enumString = enumFile.GenerateCode();

            File.WriteAllText(Path.Combine(pmrFolder, "Diagnostics", enumFile.Name + ".proto"), enumString);
        }

        private static void GenerateEventTypes(ObservablesContext db, String pmrFolder)
        {
            Console.WriteLine("Generating Event Types...");

            ProtoEnumFile enumFile = new ProtoEnumFile();
            enumFile.Name = "EventType";
            enumFile.Package = "Tango.PMR.Diagnostics";

            enumFile.Fields.Add(new EnumerationField()
            {
                Name = "None",
                Description = "Must contain a 0 value",
                Value = 0,
            });

            foreach (var field in db.EventTypes.ToList().OrderBy(x => x.Code))
            {
                enumFile.Fields.Add(new EnumerationField()
                {
                    Name = field.Name.Replace(" ", ""),
                    Description = field.Description + String.Format(" (Group = {0}, Category = {1})", field.Group.ToString(), field.Category.ToString()),
                    Value = field.Code,
                });
            }

            String enumString = enumFile.GenerateCode();

            File.WriteAllText(Path.Combine(pmrFolder, "Diagnostics", enumFile.Name + ".proto"), enumString);
        }

        private static String CoercePropertyType(Type type)
        {
            if (type == typeof(bool))
            {
                return "bool";
            }
            else
            {
                return type.Name.ToLower();
            }
        }

        private static String GetDbDescription<T>(PropertyInfo prop)
        {
            String tableName = typeof(T).GetCustomAttribute<TableAttribute>().Name;
            String columnName = prop.GetCustomAttribute<ColumnAttribute>().Name;

            var db_des = _dbDescriptions.FirstOrDefault(x => x.TableName == tableName && x.ColumnName == columnName);

            if (db_des != null)
            {
                DbPropertyExtensionModel rangeDescription = null;

                try
                {
                    rangeDescription = JsonConvert.DeserializeObject<DbPropertyExtensionModel>(db_des.ColumnDescription);
                }
                catch { }

                if (rangeDescription == null)
                {
                    return db_des.ColumnDescription.ToLines().Take(1).Concat(db_des.ColumnDescription.ToLines().Skip(1).Select(x => "//" + x)).Join(Environment.NewLine);
                }
            }

            return null;
        }
    }
}