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);
                GenerateInsightsMonitors(db, pmrFolder);
                GenerateEventTypes(db, pmrFolder);
                GenerateBitTypes(db, pmrFolder);
                GenerateInterfaceIOs(db, pmrFolder);
                GenerateBtsrApplicationTypes(db, pmrFolder);
                GenerateBtsrYarnTypes(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 Diagnostics 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 GenerateInsightsMonitors(ObservablesContext db, string pmrFolder)
        {
            Console.WriteLine("Generating Insights Monitors...");

            ProtoMessageFile messageFile = new ProtoMessageFile();
            messageFile.Name = "InsightsMonitors";
            messageFile.Package = "Tango.PMR.Insights";

            foreach (var monitor in db.TechMonitors.ToList().OrderBy(x => x.Code))
            {
                var prop = new ProtoProperty();
                prop.Name = monitor.Name.Replace(" ", "");
                prop.Description = monitor.Description;
                prop.Type = "double";

                if (monitor.MultiChannel)
                {
                    prop.Repeated = true;
                }

                messageFile.Properties.Add(prop);
            }

            String messageString = messageFile.GenerateCode();

            File.WriteAllText(Path.Combine(pmrFolder, "Insights", 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 void GenerateBitTypes(ObservablesContext db, String pmrFolder)
        {
            Console.WriteLine("Generating BIT Types...");

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

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

            foreach (var field in db.BitTypes.ToList().OrderBy(x => x.Code))
            {
                enumFile.Fields.Add(new EnumerationField()
                {
                    Name = field.Name.Replace(" ", ""),
                    Description = field.Name,
                    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;
        }

        private static void GenerateBtsrApplicationTypes(ObservablesContext db, String pmrFolder)
        {
            Console.WriteLine("Generating BTSR Application Types...");

            ProtoEnumFile enumFile = new ProtoEnumFile();
            enumFile.Name = "BtsrApplicationType";
            enumFile.Package = "Tango.PMR.BTSR";

            enumFile.Fields.Add(new EnumerationField()
            {
                Name = "UNDEFINED_APPLICATION",
                Value = 0,
            });

            foreach (var field in db.BtsrApplicationTypes.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, "BTSR", enumFile.Name + ".proto"), enumString);
        }

        private static void GenerateBtsrYarnTypes(ObservablesContext db, String pmrFolder)
        {
            Console.WriteLine("Generating BTSR Yarn Types...");

            ProtoEnumFile enumFile = new ProtoEnumFile();
            enumFile.Name = "BtsrYarnType";
            enumFile.Package = "Tango.PMR.BTSR";

            enumFile.Fields.Add(new EnumerationField()
            {
                Name = "UNDEFINED_YARN",
                Value = 0,
            });

            foreach (var field in db.BtsrYarnTypes.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, "BTSR", enumFile.Name + ".proto"), enumString);
        }
    }
}