source: addons/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/ExpressionTable.cs

namespace HeuristicLab.Problems.ProgramSynthesis.Push.Expressions {
  using System;
  using System.Collections.Generic;
  using System.Linq;

  using Attributes;
  using Data.Pool;

  using HeuristicLab.Problems.ProgramSynthesis.Base.Extensions;

  using Stack;

  public static class ExpressionTable {
    public static readonly IReadOnlyDictionary<Type, Expression> StatelessExpressionTable;
    public static readonly IReadOnlyDictionary<Type, Func<Expression>> StatefulExpressionFactory;
    public static readonly IReadOnlyList<string> ExpressionNames;
    public static readonly int ExpressionCount;

    private static readonly Dictionary<int, string> indexToNameTable = new Dictionary<int, string>();
    private static readonly Dictionary<Type, string> typeToNameTable = new Dictionary<Type, string>();
    private static readonly Dictionary<string, Type> nameToTypeTable = new Dictionary<string, Type>();
    private static readonly Dictionary<StackTypes, IList<string>> stackTypeToNamesTable = new Dictionary<StackTypes, IList<string>>();
    private static readonly Dictionary<StackTypes, IList<string>> stackDependencyToNamesTable = new Dictionary<StackTypes, IList<string>>();
    private static readonly Dictionary<Type, PushExpressionAttribute> typeToAttributeTable = new Dictionary<Type, PushExpressionAttribute>();
    private static readonly List<Expression> inExpressionTable = new List<Expression>();

    public static readonly IReadOnlyList<Type> StatelessExpressionTypes;
    public static readonly IReadOnlyList<Type> StatefulExpressionTypes;

    static ExpressionTable() {
      StatelessExpressionTypes = GetExpressionTypes(typeof(StatelessExpression)).ToList();
      StatefulExpressionTypes = GetExpressionTypes(typeof(StatefulExpression<>)).ToList();

      StatelessExpressionTable = GetStatelessExpressionTable();
      StatefulExpressionFactory = GetStatefulExpressionFactory();

      ExpressionNames = StatelessExpressionTable.Keys
        .Concat(StatefulExpressionFactory.Keys)
        .Where(t => typeToNameTable.ContainsKey(t))
        .Select(type => typeToNameTable[type])
        .ToList();

      ExpressionCount = StatelessExpressionTable.Count + StatefulExpressionFactory.Count;
    }

    public static IReadOnlyDictionary<int, string> IndexToNameTable { get { return indexToNameTable; } }
    public static IReadOnlyDictionary<Type, string> TypeToNameTable { get { return typeToNameTable; } }
    public static IReadOnlyDictionary<string, Type> NameToTypeTable { get { return nameToTypeTable; } }
    public static IReadOnlyList<Expression> InExpressionTable { get { return inExpressionTable; } }
    public static IReadOnlyDictionary<StackTypes, IList<string>> StackTypeToNamesTable { get { return stackTypeToNamesTable; } }
    public static IReadOnlyDictionary<StackTypes, IList<string>> StackDependencyToNamesTable { get { return stackDependencyToNamesTable; } }
    public static IReadOnlyDictionary<Type, PushExpressionAttribute> TypeToAttributeTable { get { return typeToAttributeTable; } }

    private static Dictionary<Type, Expression> GetStatelessExpressionTable() {
      var dictionary = new Dictionary<Type, Expression>();

      foreach (var type in StatelessExpressionTypes) {
        var expression = Activator.CreateInstance(type) as Expression;
        var attribute = (PushExpressionAttribute)Attribute.GetCustomAttribute(type, typeof(PushExpressionAttribute));

        typeToAttributeTable.Add(type, attribute);
        dictionary.Add(type, expression);

        indexToNameTable.Add(indexToNameTable.Keys.Count, attribute.Name);
        typeToNameTable.Add(type, attribute.Name);
        nameToTypeTable.Add(attribute.Name, type);

        if (attribute.IsInExpression) {
          // ReSharper disable once AssignNullToNotNullAttribute
          // ReSharper disable once PossibleInvalidOperationException
          inExpressionTable.Insert(attribute.InExpressionNr.Value - 1, expression);
        }

        if (!stackTypeToNamesTable.ContainsKey(attribute.StackType)) {
          stackTypeToNamesTable.Add(attribute.StackType, new List<string>());
        }

        stackTypeToNamesTable[attribute.StackType].Add(attribute.Name);

        var dependencies = attribute.StackType | attribute.AdditionalStackDependencies;
        if (!stackDependencyToNamesTable.ContainsKey(dependencies)) {
          stackDependencyToNamesTable.Add(dependencies, new List<string>());
        }

        stackDependencyToNamesTable[dependencies].Add(attribute.Name);
      }

      return dictionary;
    }

    private static Dictionary<Type, Func<Expression>> GetStatefulExpressionFactory() {
      var dictionary = new Dictionary<Type, Func<Expression>>();

      foreach (var type in StatefulExpressionTypes) {
        // Make a NewExpression that calls the ctor
        var newExp = System.Linq.Expressions.Expression.New(type);

        // Create a lambda with the New expression as body
        var creator = System.Linq.Expressions.Expression.Lambda<Func<Expression>>(newExp).Compile();
        var attribute = (PushExpressionAttribute)Attribute.GetCustomAttribute(type, typeof(PushExpressionAttribute));

        typeToAttributeTable.Add(type, attribute);
        dictionary.Add(type, creator);

        // do not index hidden expressions like push expression in tables
        if (attribute.IsHidden) continue;

        indexToNameTable.Add(indexToNameTable.Keys.Count, attribute.Name);
        typeToNameTable.Add(type, attribute.Name);
        nameToTypeTable.Add(attribute.Name, type);

        if (!stackTypeToNamesTable.ContainsKey(attribute.StackType)) {
          stackTypeToNamesTable.Add(attribute.StackType, new List<string>());
        }

        stackTypeToNamesTable[attribute.StackType].Add(attribute.Name);

        var dependencies = attribute.StackType | attribute.AdditionalStackDependencies;
        if (!stackDependencyToNamesTable.ContainsKey(dependencies)) {
          stackDependencyToNamesTable.Add(dependencies, new List<string>());
        }

        stackDependencyToNamesTable[dependencies].Add(attribute.Name);
      }

      return dictionary;
    }



    private static IEnumerable<Type> GetExpressionTypes(Type baseType) {
      return from domainAssembly in AppDomain.CurrentDomain.GetAssemblies()
             from assemblyType in domainAssembly.GetTypes()
             where !assemblyType.IsAbstract &&
                   assemblyType.IsSubclass(baseType) &&
                   assemblyType.GetConstructor(Type.EmptyTypes) != null
             select assemblyType;
    }

    public static IReadOnlyList<string> GetExpressionsByStackTypes(StackTypes allowedTypes) {
      return stackDependencyToNamesTable
          .Where(entry => (entry.Key & ~allowedTypes) == 0x0)
          .SelectMany(entry => entry.Value)
          .ToList();
    }

    public static PushProgram GetProgram(IManagedPool<PushProgram> pool, int[] index) {
      var expressions = new Expression[index.Length];

      for (var i = 0; i < index.Length; i++) {
        expressions[i] = GetExpression(index[i]);
      }

      return PushProgram.Create(pool, expressions);
    }

    public static Expression GetExpression(int index) {
      return GetExpression(indexToNameTable[index]);
    }

    public static Expression GetExpression(Type type) {
      var name = TypeToNameTable[type];
      return GetExpression(name);
    }

    public static Expression GetExpression(string name) {
      Expression expression;

      if (!TryGetStatelessExpression(name, out expression) &&
          !TryGetStatefulExpression(name, out expression))
        throw new InvalidOperationException(string.Format("Expression with name {0} not found", name));

      return expression;
    }

    public static Expression GetStatelessExpression<T>() where T : StatelessExpression {
      Expression expression;
      var type = typeof(T);

      if (StatelessExpressionTable.TryGetValue(type, out expression))
        return expression;

      throw new NotSupportedException("Expression not supported: " + type.Name);
    }

    public static Expression GetStatelessExpression(string name) {
      Type type;
      Expression expression;

      if (NameToTypeTable.TryGetValue(name, out type) && StatelessExpressionTable.TryGetValue(type, out expression))
        return expression;

      throw new NotSupportedException("Expression not supported: " + name);
    }

    public static bool TryGetStatelessExpression(string name, out Expression expression) {
      Type type;
      if (!NameToTypeTable.TryGetValue(name, out type) || !StatelessExpressionTable.TryGetValue(type, out expression)) {
        expression = null;
        return false;
      }

      return true;
    }

    public static Expression GetStatefulExpression<T>() {
      return GetStatefulExpression(typeToNameTable[typeof(T)]);
    }

    public static Expression GetStatefulExpression(string name) {
      Type type;
      Func<Expression> creator;

      if (NameToTypeTable.TryGetValue(name, out type) && StatefulExpressionFactory.TryGetValue(type, out creator)) {
        return creator();
      }

      throw new NotSupportedException("Expression not supported: " + name);
    }

    public static bool TryGetStatefulExpression(string name, out Expression expression) {
      if (NameToTypeTable.ContainsKey(name)) {
        expression = StatefulExpressionFactory[NameToTypeTable[name]]();
        return true;
      }

      expression = default(Expression);
      return false;
    }
  }
}