PdfPig/src/UglyToad.PdfPig/Graphics/ReflectionGraphicsStateOperationFactory.cs

namespace UglyToad.PdfPig.Graphics
{
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Reflection;
    using Exceptions;
    using Operations;
    using Operations.MarkedContent;
    using Operations.TextShowing;
    using Operations.TextState;
    using Tokens;

    internal class ReflectionGraphicsStateOperationFactory : IGraphicsStateOperationFactory
    {
        private readonly IReadOnlyDictionary<string, Type> operations;

        public ReflectionGraphicsStateOperationFactory()
        {
            var assemblyTypes = Assembly.GetAssembly(typeof(ReflectionGraphicsStateOperationFactory)).GetTypes();

            var result = new Dictionary<string, Type>();

            foreach (var assemblyType in assemblyTypes)
            {
                if (!assemblyType.IsInterface && typeof(IGraphicsStateOperation).IsAssignableFrom(assemblyType))
                {
                    var symbol = assemblyType.GetField("Symbol");

                    if (symbol == null)
                    {
                        throw new InvalidOperationException("An operation type was defined without the public const Symbol being declared. Type was: " + assemblyType.FullName);
                    }

                    var value = symbol.GetValue(null).ToString();

                    result[value] = assemblyType;
                }
            }

            operations = result;
        }

        public IGraphicsStateOperation Create(OperatorToken op, IReadOnlyList<IToken> operands)
        {
            switch (op.Data)
            {
                case ShowText.Symbol:
                    if (operands.Count != 1)
                    {
                        throw new InvalidOperationException($"Attempted to create a show text operation with {operands.Count} operands.");
                    }

                    if (operands[0] is StringToken s)
                    {
                        return new ShowText(s.Data);
                    }
                    else if (operands[0] is HexToken h)
                    {
                        return new ShowText(h.Bytes.ToArray());
                    }
                    else
                    {
                        throw new InvalidOperationException($"Tried to create a show text operation with operand type: {operands[0]?.GetType().Name ?? "null"}");
                    }
                case ShowTextsWithPositioning.Symbol:
                    if (operands.Count == 0)
                    {
                        throw new InvalidOperationException("Cannot have 0 parameters for a TJ operator.");
                    }

                    if (operands.Count == 1 && operands[0] is ArrayToken arrayToken)
                    {
                        return new ShowTextsWithPositioning(arrayToken.Data);
                    }

                    var array = operands.ToArray();

                    return new ShowTextsWithPositioning(array);
                case SetFontAndSize.Symbol:
                    if (operands.Count == 2 && operands[0] is NameToken name && operands[1] is NumericToken size)
                    {
                        return new SetFontAndSize(name, size.Data);
                    }

                    var information = string.Join(", ", operands.Select(x => x.ToString()));
                    throw new PdfDocumentFormatException($"Attempted to set font with wrong number of parameters: [{information}]");
                case DesignateMarkedContentPointWithProperties.Symbol:
                    var dpName = (NameToken)operands[0];
                    if (operands[1] is DictionaryToken contentPointDictionary)
                    {
                        return new DesignateMarkedContentPointWithProperties(dpName, contentPointDictionary);
                    }
                    else if (operands[1] is NameToken contentPointName)
                    {
                        return new DesignateMarkedContentPointWithProperties(dpName, contentPointName);
                    }

                    var errorMessageDp = string.Join(", ", operands.Select(x => x.ToString()));
                    throw new PdfDocumentFormatException($"Attempted to set a marked-content point with invalid parameters: [{errorMessageDp}]");
                case BeginMarkedContentWithProperties.Symbol:
                    var bdcName = (NameToken) operands[0];
                    if (operands[1] is DictionaryToken contentSequenceDictionary)
                    {
                        return new BeginMarkedContentWithProperties(bdcName, contentSequenceDictionary);
                    }
                    else if (operands[1] is NameToken contentSequenceName)
                    {
                        return new BeginMarkedContentWithProperties(bdcName, contentSequenceName);
                    }

                    var errorMessageBdc = string.Join(", ", operands.Select(x => x.ToString()));
                    throw new PdfDocumentFormatException($"Attempted to set a marked-content sequence with invalid parameters: [{errorMessageBdc}]");
                case SetStrokeColorAdvanced.Symbol:
                    if (operands[operands.Count - 1] is NameToken scnPatternName)
                    {
                        return new SetStrokeColorAdvanced(operands.Take(operands.Count - 1).Select(x => ((NumericToken)x).Data).ToList(), scnPatternName);
                    }
                    else if(operands.All(x => x is NumericToken))
                    {
                        return new SetStrokeColorAdvanced(operands.Select(x => ((NumericToken)x).Data).ToList());
                    }

                    var errorMessageScn = string.Join(", ", operands.Select(x => x.ToString()));
                    throw new PdfDocumentFormatException($"Attempted to set a stroke color space (SCN) with invalid arguments: [{errorMessageScn}]");
                case SetNonStrokeColorAdvanced.Symbol:
                    if (operands[operands.Count - 1] is NameToken scnLowerPatternName)
                    {
                        return new SetStrokeColorAdvanced(operands.Take(operands.Count - 1).Select(x => ((NumericToken)x).Data).ToList(), scnLowerPatternName);
                    }
                    else if (operands.All(x => x is NumericToken))
                    {
                        return new SetStrokeColorAdvanced(operands.Select(x => ((NumericToken)x).Data).ToList());
                    }

                    var errorMessageScnLower = string.Join(", ", operands.Select(x => x.ToString()));
                    throw new PdfDocumentFormatException($"Attempted to set a non-stroke color space (scn) with invalid arguments: [{errorMessageScnLower}]");
            }

            if (!operations.TryGetValue(op.Data, out Type operationType))
            {
                return null;
            }

            var constructors = operationType.GetConstructors(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);

            if (constructors.Length == 0)
            {
                throw new InvalidOperationException("No constructors to invoke were found for operation type: " + operationType.FullName);
            }

            // This only works by luck...
            var constructor = constructors[0];

            if (constructor.IsPrivate)
            {
                return (IGraphicsStateOperation)operationType.GetField("Value").GetValue(null);
            }

            var parameters = constructor.GetParameters();

            var offset = 0;

            var arguments = new List<object>();

            foreach (var parameter in parameters)
            {
                if (parameter.ParameterType == typeof(decimal))
                {
                    if (operands[offset] is NumericToken numeric)
                    {
                        arguments.Add(numeric.Data);
                    }
                    else
                    {
                        throw new InvalidOperationException($"Expected a decimal parameter for operation type {operationType.FullName}. Instead got: {operands[offset]}");
                    }

                    offset++;
                }
                else if (parameter.ParameterType == typeof(int))
                {
                    if (operands[offset] is NumericToken numeric)
                    {
                        arguments.Add(numeric.Int);
                    }
                    else
                    {
                        throw new InvalidOperationException($"Expected an integer parameter for operation type {operationType.FullName}. Instead got: {operands[offset]}");
                    }

                    offset++;
                }
                else if (parameter.ParameterType == typeof(decimal[]))
                {
                    if (operands[offset] is ArrayToken arr)
                    {
                        arguments.Add(arr.Data.OfType<NumericToken>().Select(x => x.Data).ToArray());
                        offset++;
                        continue;
                    }

                    var array = new List<decimal>();
                    while (offset < operands.Count && operands[offset] is NumericToken numeric)
                    {
                        array.Add(numeric.Data);
                        offset++;
                    }

                    arguments.Add(array.ToArray());
                }
                else if (parameter.ParameterType == typeof(NameToken))
                {
                    if (operands[offset] is NameToken name)
                    {
                        arguments.Add(name);
                    }
                    else if (operands[offset] is StringToken s)
                    {
                        arguments.Add(NameToken.Create(s.Data));
                    }
                    else
                    {
                        throw new InvalidOperationException($"Expected a decimal array parameter for operation type {operationType.FullName}. Instead got: {operands[offset]}");
                    }

                    offset++;
                }
                else if (parameter.ParameterType == typeof(string))
                {
                    if (operands[offset] is StringToken stringToken)
                    {
                        arguments.Add(stringToken.Data);
                    }
                    else if (operands[offset] is HexToken hexToken)
                    {
                        arguments.Add(hexToken.Data);
                    }
                    else
                    {
                        throw new InvalidOperationException($"Expected a string parameter for operation type {operationType.FullName}. Instead got: {operands[offset]}");
                    }

                    offset++;
                }
                else
                {
                    throw new NotImplementedException($"Unsupported parameter type {parameter.ParameterType.FullName} for operation type {operationType.FullName}.");
                }
            }

            var result = constructor.Invoke(arguments.ToArray());

            return (IGraphicsStateOperation)result;
        }
    }
}