using Google.Protobuf;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tango.Core.ExtensionMethods;
using Tango.PMR.ColorLab;


namespace Tango.ColorLib.LightInksTest.CLI
{
   
    class Program
    {
        static void Main(string[] args)
        {
            ColorLibConnector connector = new ColorLibConnector();
            //Stopwatch watch = new Stopwatch();
            //watch.Start();
            Console.WriteLine();

            //Input RGB	[127, 131, 201] 
            Console.WriteLine("Test RGB with Light Inks,  R=127, G=120, B=201");
            ConversionInput input = CreateConversionInput(PMR.ColorLab.ColorSpace.Rgb, new double[3] { 127, 120, 201 }, true);
            ConversionOutput result = connector.Convert(input);
            IsTestPassed(result, new double[7] { 11.2, 9.38, 0, 0, 0, 0, 5 });
            //Console.WriteLine($"Result Convert RGB with LightInk flag TRUE  result:\n{result.ToJsonString()}");

            Console.WriteLine("Test RGB R=127, G=120, B=201");
            input = CreateConversionInput(PMR.ColorLab.ColorSpace.Rgb, new double[3] { 127, 120, 201 }, false);
            result = connector.Convert(input);
            IsTestPassed(result, new double[4] { 11.2, 9.38, 0.5, 0 });

            Console.WriteLine("Test LAB with Light Inks L=54.2, A=22.04, B=-41.25");
            input = CreateConversionInput(PMR.ColorLab.ColorSpace.Lab, new double[3] { 54.2, 22.04, -41.25 }, true);
            result = connector.Convert(input);
            IsTestPassed(result, new double[7] { 11.2, 9.38, 0, 0, 0, 0, 5 });

            Console.WriteLine("Test LAB L=54.2, A=22.04, B=-41.25");
            input = CreateConversionInput(PMR.ColorLab.ColorSpace.Lab, new double[3] { 54.2, 22.04,-41.25 }, false);
            result = connector.Convert(input);
            IsTestPassed(result, new double[4] { 11.2, 9.38, 0.5, 0 });

            Console.WriteLine("Test LAB with Light Inks L=90.02, A=-16.27, B=27.12");
            input = CreateConversionInput(PMR.ColorLab.ColorSpace.Lab, new double[3] { 90.02, -16.27, 27.12 }, true);
            result = connector.Convert(input);
            IsTestPassed(result, new double[7] { 0, 0, 7.34, 0, 19.95, 5, 0 });

            Console.WriteLine("Test LAB L=90.02, A=-16.27, B=27.12");
            input = CreateConversionInput(PMR.ColorLab.ColorSpace.Lab, new double[3] { 90.02, -16.27, 27.12 }, false);
            result = connector.Convert(input);
            IsTestPassed(result, new double[4] {1.995, 0.5  , 7.34, 0 });

            ////// CATALOG //////////////////////////////////////////////////////////////////////////////////////////////////////
            //Console.WriteLine("Test CATALOG C=29.05, M=1, Y=0, K = 18.77");
            //input = CreateConversionInput(PMR.ColorLab.ColorSpace.Catalog, new double[4] { 29.05, 1, 0, 18.77 }, false);
            //result = connector.Convert(input);
            //IsTestPassed(result, new double[4] { 29.05, 1, 0, 18.77 });

            //Console.WriteLine("Test CATALOG with Light Inks,  C=29.05, M=1, Y=0, K = 18.77");
            //input = CreateConversionInput(PMR.ColorLab.ColorSpace.Catalog, new double[4] { 29.05, 1, 0, 18.77 }, true);
            //result = connector.Convert(input);
            //IsTestPassed(result, new double[7] { 29.05, 0, 0, 18.77, 0, 10, 0 });

            Console.WriteLine("Test CATALOG C=1, M=3, Y=30, K = 0");
            input = CreateConversionInput(PMR.ColorLab.ColorSpace.Catalog, new double[4] { 1, 3, 30, 0 }, false);
            result = connector.Convert(input);
            IsTestPassed(result, new double[4] { 1, 3, 30, 0 });

            Console.WriteLine("Test CATALOG C=1, M=3, Y=30, K = 0");
            input = CreateConversionInput(PMR.ColorLab.ColorSpace.Catalog, new double[4] { 1, 3, 30, 0 }, false);
            result = connector.Convert(input);
            IsTestPassed(result, new double[4] { 1, 3, 30, 0 });

            Console.WriteLine("Test CATALOG with Light Inks, C=1, M=3, Y=30, K = 0");
            input = CreateConversionInput(PMR.ColorLab.ColorSpace.Catalog, new double[4] { 1, 3, 30, 0 }, true);
            result = connector.Convert(input);
            IsTestPassed(result, new double[7] { 0, 0, 30, 0, 10, 30, 0 });

            //Console.WriteLine("Test CATALOG C=180, M=1, Y=3, K = 0");
            //input = CreateConversionInput(PMR.ColorLab.ColorSpace.Catalog, new double[4] { 180, 1, 3, 0 }, false);
            //result = connector.Convert(input);
            //IsTestPassed(result, new double[4] { 180, 1, 3, 0 });

            //Console.WriteLine("Test CATALOG with Light Inks,  C=180, M=1, Y=3, K = 0");
            //input = CreateConversionInput(PMR.ColorLab.ColorSpace.Catalog, new double[4] { 180, 1, 3, 0 }, true);
            //result = connector.Convert(input);
            //IsTestPassed(result, new double[7] { 180, 1, 3, 0, 0, 0, 0 });

            ///// VOLUME ////////////////////////////////////////////////////////////////////////////////////////
            Console.WriteLine("Test VOLUME with Light Inks,  C=29.05, M=1, Y=0, K = 18.77");
            input = CreateConversionInput(PMR.ColorLab.ColorSpace.Volume, new double[4] { 29.05, 1, 0, 18.77 }, true);
            result = connector.Convert(input);
            IsTestPassed(result, new double[7] { 29.05, 0, 0, 18.77, 0, 10, 0 });

            Console.WriteLine("Test VOLUME,  C=29.05, M=1, Y=0, K = 18.77");
            input = CreateConversionInput(PMR.ColorLab.ColorSpace.Volume, new double[4] { 29.05, 1, 0, 18.77 }, false);
            result = connector.Convert(input);
            IsTestPassed(result, new double[4] { 29.05, 1, 0, 18.77 });

            Console.WriteLine("Test VOLUME with Light Inks,  C=180, M=1, Y=3, K = 0");
            input = CreateConversionInput(PMR.ColorLab.ColorSpace.Volume, new double[4] { 180, 1, 3, 0 }, true);
            result = connector.Convert(input);
            IsTestPassed(result, new double[7] { 180, 1, 3, 0, 0, 0, 0 });

            Console.WriteLine("Test VOLUME ,  C=180, M=1, Y=3, K = 0");
            input = CreateConversionInput(PMR.ColorLab.ColorSpace.Volume, new double[4] { 180, 1, 3, 0 }, false);
            result = connector.Convert(input);
            IsTestPassed(result, new double[4] { 180, 1, 3, 0 });
            //watch.Stop();

            //Console.WriteLine($"Processing completed after: {watch.ElapsedMilliseconds.ToString()} milliseconds.");
            Console.WriteLine();

            Console.WriteLine("Press return to exit...");
            Console.ReadLine();
        }

        public static ConversionInput CreateConversionInput(PMR.ColorLab.ColorSpace colorSpace, double[] values, bool useLightInks)
        {
            ConversionInput input = new ConversionInput();
            input.ThreadL = 90.5033;
            input.ThreadA = 2.9299;
            input.ThreadB = -11.4033;

            input.ColorSpace = colorSpace;
            input.InputCoordinates = GetColorInputCoordinates(colorSpace, values);

            //Process Ranges
            input.ProcessRanges.Add(new ProcessRange()
            {
                MinInkUptake = 200,
                MaxInkUptake = 200,
            });

            input.ProcessRanges.Add(new ProcessRange()
            {
                MinInkUptake = 200,
                MaxInkUptake = 400,
            });

            input.ForwardData = ByteString.CopyFrom(File.ReadAllBytes(@"Sylko_IL400_BL95_C200R_1N.cct"));
            
            //RML Liquid Factors
            input.InputCoordinates.InputLiquids.Add(new InputLiquid()
            {
                LiquidType = LiquidType.Cyan,
                CalibrationData = CreateCalibrationData(colorSpace, LiquidType.Cyan),
                MaxNanoliterPerCentimeter = 200,
            });

            input.InputCoordinates.InputLiquids.Add(new InputLiquid()
            {
                LiquidType = LiquidType.Magenta,
                CalibrationData = CreateCalibrationData(colorSpace, LiquidType.Magenta),
                MaxNanoliterPerCentimeter = 200,
            });

            input.InputCoordinates.InputLiquids.Add(new InputLiquid()
            {
                LiquidType = LiquidType.Yellow,
                CalibrationData = CreateCalibrationData(colorSpace, LiquidType.Yellow),
                MaxNanoliterPerCentimeter = 200,
            });

            input.InputCoordinates.InputLiquids.Add(new InputLiquid()
            {
                LiquidType = LiquidType.Black,
                CalibrationData = CreateCalibrationData(colorSpace, LiquidType.Black),
                MaxNanoliterPerCentimeter = 200,
            });
            if (colorSpace == PMR.ColorLab.ColorSpace.Volume)
            {
                int index = 0;
                foreach (var liquid in input.InputCoordinates.InputLiquids)
                {
                    liquid.Volume = values[index++];
                }
            }
            if (useLightInks)
            {
                input.InputCoordinates.InputLiquids.Add(new InputLiquid()
                {
                    LiquidType = LiquidType.LightCyan,
                    CalibrationData = CreateCalibrationData(colorSpace, LiquidType.Cyan),
                    MaxNanoliterPerCentimeter = 200,
                });

                input.InputCoordinates.InputLiquids.Add(new InputLiquid()
                {
                    LiquidType = LiquidType.LightMagenta,
                    CalibrationData = CreateCalibrationData(colorSpace, LiquidType.Magenta),
                    MaxNanoliterPerCentimeter = 200,
                });

                input.InputCoordinates.InputLiquids.Add(new InputLiquid()
                {
                    LiquidType = LiquidType.LightYellow,
                    CalibrationData = CreateCalibrationData(colorSpace, LiquidType.Yellow),
                    MaxNanoliterPerCentimeter = 200,
                });
            }

            input.GenerateHive = false;
            input.UseLightInks = useLightInks;
            input.VMax = 5;
            return input;
        }

        public static CalibrationData CreateCalibrationData(PMR.ColorLab.ColorSpace colorSpace, PMR.ColorLab.LiquidType liquidType)
        {
            if(colorSpace == ColorSpace.Catalog && CalibrationDataSCVReader.getInstance().CalibrationDataDictionary.ContainsKey(liquidType))
            {
                return CalibrationDataSCVReader.getInstance().CalibrationDataDictionary[liquidType];
            }
            else
            {
                CalibrationData data = new CalibrationData();
                data.LiquidType = liquidType;

                for (int i = 0; i < 101; i++)
                {
                    data.CalibrationPoints.Add(new CalibrationPoint()
                    {
                        X = i,
                        Y = i,
                    });
                }
                return data;
            }
            
        }

        public static InputCoordinates GetColorInputCoordinates(PMR.ColorLab.ColorSpace colorSpace, double[] values)
        {
            InputCoordinates inputCoordinates = new InputCoordinates();

            if (colorSpace == PMR.ColorLab.ColorSpace.Rgb)
            {
                inputCoordinates.Red = (int)values[0];
                inputCoordinates.Green = (int)values[1];
                inputCoordinates.Blue = (int)values[2];
            }
            else if (colorSpace == PMR.ColorLab.ColorSpace.Lab)
            {//55.39, 40.56, 56.69
                inputCoordinates.L = values[0];
                inputCoordinates.A = values[1];
                inputCoordinates.B = values[2];
            }
            else if (colorSpace == PMR.ColorLab.ColorSpace.Cmyk || colorSpace == PMR.ColorLab.ColorSpace.Catalog)
            {
                inputCoordinates.Cyan = values[0];
                inputCoordinates.Magenta = values[1];
                inputCoordinates.Yellow = values[2];
                inputCoordinates.Key = values[3];
            }

            return inputCoordinates;

        }

        public static bool IsTestPassed(ConversionOutput result, double[] expectedValues)
        {
            List<String> errors = new List<string>();

            if (result.SingleCoordinates.OutputLiquids.Count != expectedValues.Length)
            {
                errors.Add($"Number of returned inks {result.SingleCoordinates.OutputLiquids.Count}, expected value {expectedValues.Length}");
            }

            if (errors.Count == 0)
            {
                for (int index = 0; index < expectedValues.Count(); index++)
                {
                    var liquid = result.SingleCoordinates.OutputLiquids[index];
                    if (Math.Abs(liquid.Volume - expectedValues[index]) > 0.1)
                    {
                        errors.Add($"{liquid.LiquidType} value = {liquid.Volume}. expected value = {expectedValues[index]}");
                    }
                }
            }

            if (errors.Count > 0)
            {
                Console.ForegroundColor = ConsoleColor.Red;

                foreach (var error in errors)
                {
                    Console.WriteLine(error);
                }

                Console.ForegroundColor = ConsoleColor.Gray;
                Console.WriteLine();

                return false;
            }
            else
            {
                Console.ForegroundColor = ConsoleColor.Green;
                Console.WriteLine($"Passed.");
                Console.ForegroundColor = ConsoleColor.Gray;
                Console.WriteLine();

                return true;
            }
        }
    }
}