namespace HeuristicLab.Problems.ProgramSynthesis.Push.Expressions {
  using System;
  using System.Collections.Generic;
  using System.Linq;
  using Attributes;
  using Constants;
  using Data.Pool;
  using Extensions;
  using Interpreter;
  using Persistence.Default.CompositeSerializers.Storable;
  using Stack;

  [Serializable]
  [StorableClass]
  public abstract class PushExpression<T> : StatefulExpression<T> {
    [StorableConstructor]
    protected PushExpression(bool deserializing) : base(deserializing) { }

    protected PushExpression(T state, object other) : base(state) { }

    public override bool IsNoop(IInternalPushInterpreter interpreter) {
      return false;
    }

    protected void Eval(IPushStack<T> stack) {
      stack.Push(State);
    }
  }

  [StorableClass]
  [Serializable]
  public abstract class VectorPushExpression<T> : PushExpression<IReadOnlyList<T>> {
    [StorableConstructor]
    protected VectorPushExpression(bool deserializing) : base(deserializing) { }

    protected VectorPushExpression(IReadOnlyList<T> state) : base(state, null) { }

    protected override string GetStringRepresentation() {
      return PushEnvironment.VectorStartSymbolStr +
             string.Join(PushEnvironment.VectorSeparatorSymbolStr, State) +
             PushEnvironment.VectorEndSymbolStr;
    }

    protected override int CalcHashCode() {
      return State.HashCode();
    }
  }

  [StorableClass]
  [Serializable]
  [PushExpression(StackTypes.Integer, "INTEGER.PUSH", "Pushes a specific integer onto the INTEGER stack", isHidden: true)]
  public class IntegerPushExpression : PushExpression<long> {
    [StorableConstructor]
    protected IntegerPushExpression(bool deserializing) : base(deserializing) { }

    public static IntegerPushExpression Create(IManagedPool<Expression> statefulExpressionPool, long state) {
      var expression = (IntegerPushExpression)statefulExpressionPool.Get();
      expression.State = state;

      return expression;
    }

    /// <summary>
    /// Pushes default(long)
    /// </summary>
    public IntegerPushExpression() : base(default(long), null) {
    }

    public IntegerPushExpression(long state)
      : base(state, null) {
    }

    public override void Eval(IInternalPushInterpreter interpreter) {
      Eval(interpreter.IntegerStack);
    }
  }

  [StorableClass]
  [Serializable]
  [PushExpression(StackTypes.Float, "FLOAT.PUSH", "Pushes a specific float onto the FLOAT stack", isHidden: true)]
  public class FloatPushExpression : PushExpression<double> {
    [StorableConstructor]
    protected FloatPushExpression(bool deserializing) : base(deserializing) { }

    public static FloatPushExpression Create(IManagedPool<Expression> statefulExpressionPool, double state) {
      var expression = (FloatPushExpression)statefulExpressionPool.Get();
      expression.State = state;

      return expression;
    }

    /// <summary>
    /// Pushes default(double)
    /// </summary>
    public FloatPushExpression() : base(default(double), null) {
    }

    public FloatPushExpression(double state)
      : base(state, null) {
    }

    public override void Eval(IInternalPushInterpreter interpreter) {
      Eval(interpreter.FloatStack);
    }
  }

  [StorableClass]
  [Serializable]
  [PushExpression(StackTypes.Boolean, "BOOLEAN.PUSH", "Pushes a specific boolean onto the BOOLEAN stack", isHidden: true)]
  public class BooleanPushExpression : PushExpression<bool> {
    [StorableConstructor]
    protected BooleanPushExpression(bool deserializing, object other) : base(deserializing) { }

    public static BooleanPushExpression Create(IManagedPool<Expression> statefulExpressionPool, bool state) {
      var expression = (BooleanPushExpression)statefulExpressionPool.Get();
      expression.State = state;

      return expression;
    }

    /// <summary>
    /// Pushes default(bool)
    /// </summary>
    public BooleanPushExpression() : base(default(bool), null) {
    }

    public BooleanPushExpression(bool state)
      : base(state, null) {
    }

    public override void Eval(IInternalPushInterpreter interpreter) {
      Eval(interpreter.BooleanStack);
    }
  }

  [StorableClass]
  [Serializable]
  [PushExpression(StackTypes.Name, "NAME.PUSH", "Pushes a specific name onto the NAME stack", isHidden: true)]
  public class NamePushExpression : PushExpression<string> {
    [StorableConstructor]
    protected NamePushExpression(bool deserializing) : base(deserializing) { }
    public static NamePushExpression Create(IManagedPool<Expression> statefulExpressionPool, string state) {
      var expression = (NamePushExpression)statefulExpressionPool.Get();
      expression.State = state;

      return expression;
    }

    public NamePushExpression() : base(string.Empty, null) {
    }

    public NamePushExpression(string state)
      : base(state, null) {
    }

    public override void Eval(IInternalPushInterpreter interpreter) {
      Eval(interpreter.NameStack);
    }
  }

  [StorableClass]
  [Serializable]
  [PushExpression(StackTypes.Exec, "EXEC.PUSH", "Pushes a specific expression onto the EXEC stack", isHidden: true)]
  public class ExecPushExpression : PushExpression<Expression> {
    [StorableConstructor]
    protected ExecPushExpression(bool deserializing) : base(deserializing) { }
    public static ExecPushExpression Create(IManagedPool<Expression> statefulExpressionPool, Expression state) {
      var expression = (ExecPushExpression)statefulExpressionPool.Get();
      expression.State = state;

      return expression;
    }

    private static readonly Expression Noop = ExpressionTable.GetStatelessExpression<ExecNoopExpression>();

    /// <summary>
    /// Pushes ExecNoop
    /// </summary>
    public ExecPushExpression() : base(Noop, null) {
    }

    public ExecPushExpression(Expression state)
      : base(state, null) {
    }

    public override void Eval(IInternalPushInterpreter interpreter) {
      Eval(interpreter.ExecStack);
    }
  }

  [StorableClass]
  [Serializable]
  [PushExpression(StackTypes.Char, "CHAR.PUSH", "Pushes a specific char onto the CHAR stack", isHidden: true)]
  public class CharPushExpression : PushExpression<char> {
    [StorableConstructor]
    protected CharPushExpression(bool deserializing) : base(deserializing) { }

    // not supported so far
    public static CharPushExpression Create(IManagedPool<Expression> statefulExpressionPool, char state) {
      var expression = (CharPushExpression)statefulExpressionPool.Get();
      expression.State = state;

      return expression;
    }

    /// <summary>
    /// Pushes default(char)
    /// </summary>
    public CharPushExpression() : base(default(char), null) {
    }

    public CharPushExpression(char state)
      : base(state, null) {
    }

    protected override string GetStringRepresentation() {
      return PushEnvironment.CharSymbol + State.Printify() + PushEnvironment.CharSymbol;
    }

    public override void Eval(IInternalPushInterpreter interpreter) {
      Eval(interpreter.CharStack);
    }
  }

  [StorableClass]
  [Serializable]
  [PushExpression(StackTypes.String, "STRING.PUSH", "Pushes a specific string onto the STRING stack", isHidden: true)]
  public class StringPushExpression : PushExpression<string> {
    [StorableConstructor]
    protected StringPushExpression(bool deserializing) : base(deserializing) { }

    public static StringPushExpression Create(IManagedPool<Expression> statefulExpressionPool, string state) {
      var expression = (StringPushExpression)statefulExpressionPool.Get();
      expression.State = state;

      return expression;
    }

    /// <summary>
    /// Pushes String.Empty
    /// </summary>
    public StringPushExpression() : base(string.Empty, null) {
    }

    protected override string GetStringRepresentation() {
      return PushEnvironment.StringSymbol + State + PushEnvironment.StringSymbol;
    }

    public StringPushExpression(string state)
      : base(state, null) {
    }

    public override void Eval(IInternalPushInterpreter interpreter) {
      Eval(interpreter.StringStack);
    }
  }

  [StorableClass]
  [Serializable]
  [PushExpression(StackTypes.IntegerVector, "INTEGER[].PUSH", "Pushes a specific integer vector onto the INTEGER[] stack", isHidden: true)]
  public class IntegerVectorPushExpression : VectorPushExpression<long> {
    [StorableConstructor]
    protected IntegerVectorPushExpression(bool deserializing) : base(deserializing) { }

    public static IntegerVectorPushExpression Create(IManagedPool<Expression> statefulExpressionPool, IReadOnlyList<long> state) {
      var expression = (IntegerVectorPushExpression)statefulExpressionPool.Get();
      expression.State = state;

      return expression;
    }

    [NonSerialized]
    private static readonly long[] EmptyState = new long[0];

    /// <summary>
    /// Pushes long[0]
    /// </summary>
    public IntegerVectorPushExpression() : base(EmptyState) {
    }

    public IntegerVectorPushExpression(IReadOnlyList<long> state) : base(state) {
    }

    public override void Eval(IInternalPushInterpreter interpreter) {
      Eval(interpreter.IntegerVectorStack);
    }
  }

  [StorableClass]
  [Serializable]
  [PushExpression(StackTypes.FloatVector, "FLOAT[].PUSH", "Pushes a specific float vector onto the FLOAT[] stack", isHidden: true)]
  public class FloatVectorPushExpression : VectorPushExpression<double> {
    [StorableConstructor]
    protected FloatVectorPushExpression(bool deserializing) : base(deserializing) { }

    public static FloatVectorPushExpression Create(IManagedPool<Expression> statefulExpressionPool, IReadOnlyList<double> state) {
      var expression = (FloatVectorPushExpression)statefulExpressionPool.Get();
      expression.State = state;

      return expression;
    }

    [NonSerialized]
    private static readonly double[] EmptyState = new double[0];

    /// <summary>
    /// Pushes double[0]
    /// </summary>
    public FloatVectorPushExpression() : base(EmptyState) {
    }

    public FloatVectorPushExpression(IReadOnlyList<double> state) : base(state) { }

    public override void Eval(IInternalPushInterpreter interpreter) {
      Eval(interpreter.FloatVectorStack);
    }
  }

  [StorableClass]
  [Serializable]
  [PushExpression(StackTypes.BooleanVector, "BOOLEAN[].PUSH", "Pushes a specific boolean vector onto the BOOLEAN[] stack", isHidden: true)]
  public class BooleanVectorPushExpression : VectorPushExpression<bool> {
    [StorableConstructor]
    protected BooleanVectorPushExpression(bool deserializing) : base(deserializing) { }

    public static BooleanVectorPushExpression Create(IManagedPool<Expression> statefulExpressionPool, IReadOnlyList<bool> state) {
      var expression = (BooleanVectorPushExpression)statefulExpressionPool.Get();
      expression.State = state;

      return expression;
    }

    [NonSerialized]
    private static readonly bool[] EmptyState = new bool[0];

    /// <summary>
    /// Pushes bool[0]
    /// </summary>
    public BooleanVectorPushExpression() : base(EmptyState) {
    }

    public BooleanVectorPushExpression(IReadOnlyList<bool> state) : base(state) { }

    public override void Eval(IInternalPushInterpreter interpreter) {
      Eval(interpreter.BooleanVectorStack);
    }
  }

  [StorableClass]
  [Serializable]
  [PushExpression(StackTypes.StringVector, "STRING[].PUSH", "Pushes a specific string vector onto the STRING[] stack", isHidden: true)]
  public class StringVectorPushExpression : VectorPushExpression<string> {
    [StorableConstructor]
    protected StringVectorPushExpression(bool deserializing) : base(deserializing) { }

    public static StringVectorPushExpression Create(IManagedPool<Expression> statefulExpressionPool, IReadOnlyList<string> state) {
      var expression = (StringVectorPushExpression)statefulExpressionPool.Get();
      expression.State = state;

      return expression;
    }

    [NonSerialized]
    private static readonly string[] EmptyState = new string[0];

    /// <summary>
    /// Pushes string[0]
    /// </summary>
    public StringVectorPushExpression() : base(EmptyState) {
    }

    protected override string GetStringRepresentation() {
      return PushEnvironment.VectorStartSymbolStr +
             string.Join(PushEnvironment.VectorSeparatorSymbolStr, State.Select(str => PushEnvironment.StringSymbol + str + PushEnvironment.StringSymbol)) +
             PushEnvironment.VectorEndSymbolStr;
    }

    public StringVectorPushExpression(IReadOnlyList<string> state) : base(state) { }

    public override void Eval(IInternalPushInterpreter interpreter) {
      Eval(interpreter.StringVectorStack);
    }
  }
}