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

  using HeuristicLab.Problems.ProgramSynthesis.Push.Data.Pool;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;

  public class InterpreterPoolContainer {
    private readonly ManagedPoolProvider<PushProgram> pushProgramPoolProvider;
    private readonly ManagedPoolProvider<PooledList<Expression>> expressionListPoolProvider;

    private readonly IDictionary<Type, ManagedPoolProvider<Expression>> statefulExpressionPoolProviders
      = new Dictionary<Type, ManagedPoolProvider<Expression>>();

    private readonly IDictionary<Type, IManagedPool<Expression>> statefulExpressionPools
      = new Dictionary<Type, IManagedPool<Expression>>();

    public InterpreterPoolContainer(int partitionSize = 512, int maxPartitionCount = 1024) {
      pushProgramPoolProvider = new ManagedPoolProvider<PushProgram>(partitionSize, () => new PushProgram(), maxPartitionCount);
      expressionListPoolProvider = new ManagedPoolProvider<PooledList<Expression>>(partitionSize, () => new PooledList<Expression>(), maxPartitionCount);

      InitStatefulExpressionPools(partitionSize, maxPartitionCount);
    }

    public InterpreterPoolContainer(
      ManagedPoolProvider<PushProgram> pushProgramPoolProvider,
      ManagedPoolProvider<PooledList<Expression>> expressionListPoolProvider) {
      this.pushProgramPoolProvider = pushProgramPoolProvider;
      this.expressionListPoolProvider = expressionListPoolProvider;

      InitStatefulExpressionPools(1024, 2048);
    }

    private IManagedPool<PushProgram> pushProgramPool;
    public IManagedPool<PushProgram> PushProgramPool
    {
      get
      {
        if (pushProgramPool == null) pushProgramPool = pushProgramPoolProvider.CreatePool();
        return pushProgramPool;
      }
    }

    private IManagedPool<PooledList<Expression>> expressionListPool;
    public IManagedPool<PooledList<Expression>> ExpressionListPool
    {
      get
      {
        if (expressionListPool == null) expressionListPool = expressionListPoolProvider.CreatePool();
        return expressionListPool;
      }
    }

    private void InitStatefulExpressionPools(int partitionSize, int maxPartitionCount) {
      foreach (var type in ExpressionTable.StatefulExpressionTypes) {
        statefulExpressionPoolProviders.Add(type, new ManagedPoolProvider<Expression>(
          partitionSize,
          ExpressionTable.StatefulExpressionFactory[type],
          maxPartitionCount));

        statefulExpressionPools.Add(type, null);
      }
    }

    public T GetStatefulExpression<T>() where T : Expression {
      var type = typeof(T);
      if (statefulExpressionPools[type] == null)
        statefulExpressionPools[type] = statefulExpressionPoolProviders[type].CreatePool();

      return (T)statefulExpressionPools[type].Get();
    }

    public IManagedPool<Expression> GetStatefulExpressionPool<T>() where T : Expression {
      var type = typeof(T);
      return statefulExpressionPools[type] ?? (statefulExpressionPools[type] = statefulExpressionPoolProviders[type].CreatePool());
    }

    public void DisposePools() {
      if (pushProgramPool != null) {
        pushProgramPool.Dispose();
        pushProgramPool = null;
      }

      if (expressionListPool != null) {
        expressionListPool.Dispose();
        expressionListPool = null;
      }

      for (var i = 0; i < ExpressionTable.StatefulExpressionTypes.Count; i++) {
        var type = ExpressionTable.StatefulExpressionTypes[i];
        var pool = statefulExpressionPools[type];

        if (pool != null) {
          pool.Dispose();
          statefulExpressionPools[type] = null;
        }
      }
    }
  }
}