DecoratorLogger_5Parse

using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

namespace AOP
{
    public class CallerClass
    {
        public List<FunctionInvocationData> GetFunctions(string filePath)
        {
            var fileContain = File.ReadAllText(filePath); //use IFileSystemInteractor instead (see my previous blog posts)
            var parser = new SimpleInvocationJsonParser(
                new ComplexInvocationJsonParser(
                    new ObsoleteInvocationFileParser(
                        new NullInvocationParser()))); //chaining three actual decorators and one NullObject
            var functions = parser.Parse(fileContain);
            return functions;
        }
    }

    public interface IInvocationFileParser
    {
        List<FunctionInvocationData> Parse(string fileContain);
    }

    public class ComplexInvocationJsonParser : IInvocationFileParser
    {
        private readonly IInvocationFileParser _innerParser;
        public ComplexInvocationJsonParser(IInvocationFileParser innerParser)
        {
            _innerParser = innerParser;
        }

        public List<FunctionInvocationData> Parse(string fileContain)
        {
            try
            {
                if (string.IsNullOrEmpty(fileContain))
                {
                    return new List<FunctionInvocationData>();
                }

                var functions = JsonConvert.DeserializeObject<List<FunctionInvocationData>>(fileContain);
                return functions; //deserialized correctly, return
            }
            catch
            {
                return _innerParser.Parse(fileContain); //format invalid, try with another parser
            }
        }
    }

    public class SimpleInvocationJsonParser : IInvocationFileParser
    {
        private readonly IInvocationFileParser _innerParser;
        public SimpleInvocationJsonParser(IInvocationFileParser innerParser)
        {
            _innerParser = innerParser;
        }

        public List<FunctionInvocationData> Parse(string fileContain)
        {
            try
            {
                if (string.IsNullOrEmpty(fileContain))
                {
                    return new List<FunctionInvocationData>();
                }
                using (var file = new StringReader(fileContain))
                {
                    using (var reader = new JsonTextReader(file))
                    {
                        var jToken = JToken.ReadFrom(reader);
                        var rawFunctions = (Dictionary<string, string>[])jToken.ToObject(typeof(Dictionary<string, string>[]));
                        var functions = ToInvocationData(rawFunctions);
                        return functions;
                    }
                }
            }
            catch
            {
                return _innerParser.Parse(fileContain);
            }
        }

        private List<FunctionInvocationData> ToInvocationData(Dictionary<string, string>[] rawFunctions)
        {
            var functions = new List<FunctionInvocationData>();

            (...) //do parsing from strings to custom objects

            return functions;
        }
    }

    public class ObsoleteInvocationFileParser : IInvocationFileParser
    {

        private readonly IInvocationFileParser _innerParser;

        public ObsoleteInvocationFileParser(IInvocationFileParser innerParser)
        {
            _innerParser = innerParser;
        }


        public List<FunctionInvocationData> Parse(string fileContain)
        {
            if (string.IsNullOrEmpty(fileContain))
            {
                return new List<FunctionInvocationData>();
            }

            try
            {
                (...) //magic related to obsolete way of storing functions in plain text
                return functions;
            }
            catch
            {
                return _innerParser.Parse(fileContain);
            }
        }
    }

    public class NullInvocationParser : IInvocationFileParser
    {
        public List<FunctionInvocationData> Parse(string fileContain)
        {
            return new List<FunctionInvocationData>();
        }
    }


    [DebuggerDisplay("{FunctionName} | '{Parameters.Count}' params")]
    public class FunctionInvocationData
    {
        public string FunctionName { get; }
        public List<FunctionInvocationParam> Parameters { get; }

        public FunctionInvocationData(string functionName, List<FunctionInvocationParam> parameters = null)
        {
            FunctionName = functionName;
            Parameters = parameters ?? new List<FunctionInvocationParam>();
        }

        public void AddParam(string paramName)
        {
            Parameters.Add(new FunctionInvocationParam(paramName, string.Empty));
        }

        public void AddParam(string paramName, string paramValue)
        {
            Parameters.Add(new FunctionInvocationParam(paramName, paramValue));
        }

        public override string ToString()
        {
            return $"{FunctionName} with params: {string.Join(",", Parameters)}";
        }
    }

    [DebuggerDisplay("{Name}:{Value}")]
    public class FunctionInvocationParam
    {
        public string Name { get; }
        public string Value { get; }

        public FunctionInvocationParam(string name, string value)
        {
            Name = name;
            Value = value;
        }

        public override string ToString()
        {
            return $"{Name}={Value}";
        }
    }
}