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;

namespace Tango.PMRGenerator.CLI
{
    class Program
    {
        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 = "..\\..\\..\\PMR\\Messages";

            using (ObservablesContext db = ObservablesContext.CreateDefault())
            {
                db.Configuration.LazyLoadingEnabled = true;
                GenerateHardwareMotors(db, pmrFolder);
                GenerateHardwareDancers(db, pmrFolder);
                GenerateHardwarePidControls(db, pmrFolder);
                GenerateHardwareDispensers(db, pmrFolder);
                GenerateHardwareWinders(db, pmrFolder);
                GenerateHardwareSpeedSensors(db, pmrFolder);
                GenerateLiquidTypes(db, pmrFolder);
                GenerateWindingMethods(db, pmrFolder);
                GenerateSpoolTypes(db, pmrFolder);
                GenerateProcessParameters(db, pmrFolder);

                GenerateColorLabColorSpaces(db, pmrFolder);
                GenerateColorLabLiquidTypes(db, pmrFolder);
                GenerateDiagnosticsValueComponents(db, pmrFolder);
                GenerateDiagnosticsMonitors(db, pmrFolder);
                GenerateDiagnosticsEventTypes(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(HardwareMotor).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, "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(HardwareDancer).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, "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(HardwarePidControl).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, "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(DispenserType).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)));
                }
            }

            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(HardwareWinder).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, "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(HardwareSpeedSensor).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, "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 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(SpoolType).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)));
                }
            }

            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(ProcessParametersTable).GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly).Where(x => x.PropertyType.IsPrimitive))
            {
                messageFile.Properties.Add(new ProtoProperty(prop.Name, CoercePropertyType(prop.PropertyType)));
            }

            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 GenerateDiagnosticsEventTypes(ObservablesContext db, String pmrFolder)
        {
            Console.WriteLine("Generating Diagnostics Event Types...");

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

            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}, Actions = {2})", field.EventTypesGroup.Name, field.EventTypesCategory.Name, String.Join(", ", field.EventTypesActions.Select(x => x.ActionType.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();
            }
        }
    }
}