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<LoopState> loopStatePoolProvider;
    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);
      loopStatePoolProvider = new ManagedPoolProvider<LoopState>(partitionSize, () => new LoopState(), maxPartitionCount);
      expressionListPoolProvider = new ManagedPoolProvider<PooledList<Expression>>(partitionSize, () => new PooledList<Expression>(), maxPartitionCount);

      InitStatefulExpressionPools();
    }

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

      InitStatefulExpressionPools();
    }

    public IManagedPool<PushProgram> PushProgramPool { get; private set; }
    public IManagedPool<LoopState> LoopStatePool { get; private set; }
    public IManagedPool<PooledList<Expression>> ExpressionListPool { get; private set; }

    private void InitStatefulExpressionPools() {
      for (var i = 0; i < ExpressionTable.StatefulExpressionTypes.Length; i++) {
        var type = ExpressionTable.StatefulExpressionTypes[i];
        var name = ExpressionTable.TypeToNameTable[type];
        var factory = ExpressionTable.StatefulExpressionFactory[name];

        statefulExpressionPoolProviders.Add(type, new ManagedPoolProvider<Expression>(1024, factory));

        statefulExpressionPools.Add(type, null);
      }
    }

    public IManagedPool<Expression> GetStatefulExpressionPool<T, StateT>() where T : StatefulExpression<StateT> {
      return statefulExpressionPools[typeof(T)];
    }

    public T GetStatefulExpression<T>() where T : Expression {
      return (T)statefulExpressionPools[typeof(T)].Get();
    }

    public void CreatePools() {
      PushProgramPool = pushProgramPoolProvider.CreatePool();
      LoopStatePool = loopStatePoolProvider.CreatePool();
      ExpressionListPool = expressionListPoolProvider.CreatePool();

      for (var i = 0; i < ExpressionTable.StatefulExpressionTypes.Length; i++) {
        var type = ExpressionTable.StatefulExpressionTypes[i];
        statefulExpressionPools[type] = statefulExpressionPoolProviders[type].CreatePool();
      }
    }

    public void DisposePools() {
      if (PushProgramPool != null) PushProgramPool.Dispose();
      if (LoopStatePool != null) LoopStatePool.Dispose();
      if (ExpressionListPool != null) ExpressionListPool.Dispose();

      for (var i = 0; i < ExpressionTable.StatefulExpressionTypes.Length; i++) {
        var type = ExpressionTable.StatefulExpressionTypes[i];
        if (statefulExpressionPools[type] != null) statefulExpressionPools[type].Dispose();
      }
    }
  }
}