using System.Collections.Generic;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;

namespace HeuristicLab.Problems.ProgramSynthesis {
  /// <summary>
  /// Pushes a copy of an indexed item "deep" in the stack onto the top of the stack, without removing the deep item.
  /// The index is taken from the INTEGER stack, and the indexing is done after the index is removed.
  /// </summary>
  /// <typeparam name="T">Stacktype</typeparam>
  [StorableClass]
  public abstract class YankDuplicateExpression<T> : StatelessExpression {
    protected YankDuplicateExpression() { }
    [StorableConstructor]
    protected YankDuplicateExpression(bool deserializing) : base(deserializing) { }

    protected bool IsNoop(IPushStack<T> stack, IPushStack<long> integerStack) {
      return (stack == integerStack && integerStack.Count < 3) ||
             (stack != integerStack && (integerStack.IsEmpty || stack.Count < 2));
    }

    protected void Eval(IPushStack<T> stack, IPushStack<long> integerStack) {
      var index = integerStack.Pop().AsInt(stack.Count);
      stack.Push(stack[index]);
    }
  }

  [StorableClass]
  [PushExpression(
    StackTypes.Integer,
    "INTEGER.YANKDUP",
    "Pushes a copy of an indexed item \"deep\" in the stack onto the top of the stack, without removing the deep item.")]
  public class IntegerYankDuplicateExpression : YankDuplicateExpression<long> {
    public IntegerYankDuplicateExpression() { }
    [StorableConstructor]
    protected IntegerYankDuplicateExpression(bool deserializing) : base(deserializing) { }

    public override bool IsNoop(IInternalPushInterpreter interpreter) {
      return IsNoop(interpreter.IntegerStack, interpreter.IntegerStack);
    }

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

  [StorableClass]
  [PushExpression(
    StackTypes.Float,
    "FLOAT.YANKDUP",
    "Pushes a copy of an indexed item \"deep\" in the stack onto the top of the stack, without removing the deep item.",
    StackTypes.Integer)]
  public class FloatYankDuplicateExpression : YankDuplicateExpression<double> {
    public FloatYankDuplicateExpression() { }
    [StorableConstructor]
    protected FloatYankDuplicateExpression(bool deserializing) : base(deserializing) { }

    public override bool IsNoop(IInternalPushInterpreter interpreter) {
      return IsNoop(interpreter.FloatStack, interpreter.IntegerStack);
    }

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

  [StorableClass]
  [PushExpression(
    StackTypes.Boolean,
    "BOOLEAN.YANKDUP",
    "Pushes a copy of an indexed item \"deep\" in the stack onto the top of the stack, without removing the deep item.",
    StackTypes.Integer)]
  public class BooleanYankDuplicateExpression : YankDuplicateExpression<bool> {
    public BooleanYankDuplicateExpression() { }
    [StorableConstructor]
    protected BooleanYankDuplicateExpression(bool deserializing) : base(deserializing) { }

    public override bool IsNoop(IInternalPushInterpreter interpreter) {
      return IsNoop(interpreter.BooleanStack, interpreter.IntegerStack);
    }

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

  [StorableClass]
  [PushExpression(
    StackTypes.Name,
    "NAME.YANKDUP",
    "Pushes a copy of an indexed item \"deep\" in the stack onto the top of the stack, without removing the deep item.",
    StackTypes.Integer)]
  public class NameYankDuplicateExpression : YankDuplicateExpression<string> {
    public NameYankDuplicateExpression() { }
    [StorableConstructor]
    protected NameYankDuplicateExpression(bool deserializing) : base(deserializing) { }

    public override bool IsNoop(IInternalPushInterpreter interpreter) {
      return IsNoop(interpreter.NameStack, interpreter.IntegerStack);
    }

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

  [StorableClass]
  [PushExpression(
    StackTypes.Exec,
    "EXEC.YANKDUP",
    "Pushes a copy of an indexed item \"deep\" in the stack onto the top of the stack, without removing the deep item.",
    StackTypes.Integer, requiredBlockCount: 0)]
  public class ExecYankDuplicateExpression : YankDuplicateExpression<Expression> {
    public ExecYankDuplicateExpression() { }
    [StorableConstructor]
    protected ExecYankDuplicateExpression(bool deserializing) : base(deserializing) { }

    public override bool IsNoop(IInternalPushInterpreter interpreter) {
      return IsNoop(interpreter.ExecStack, interpreter.IntegerStack);
    }

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

  [StorableClass]
  [PushExpression(
    StackTypes.Code,
    "CODE.YANKDUP",
    "Pushes a copy of an indexed item \"deep\" in the stack onto the top of the stack, without removing the deep item.",
    StackTypes.Integer)]
  public class CodeYankDuplicateExpression : YankDuplicateExpression<Expression> {
    public CodeYankDuplicateExpression() { }
    [StorableConstructor]
    protected CodeYankDuplicateExpression(bool deserializing) : base(deserializing) { }

    public override bool IsNoop(IInternalPushInterpreter interpreter) {
      return IsNoop(interpreter.CodeStack, interpreter.IntegerStack);
    }

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

  [StorableClass]
  [PushExpression(
    StackTypes.Char,
    "CHAR.YANKDUP",
    "Pushes a copy of an indexed item \"deep\" in the stack onto the top of the stack, without removing the deep item.",
    StackTypes.Integer)]
  public class CharYankDuplicateExpression : YankDuplicateExpression<char> {
    public CharYankDuplicateExpression() { }
    [StorableConstructor]
    protected CharYankDuplicateExpression(bool deserializing) : base(deserializing) { }

    public override bool IsNoop(IInternalPushInterpreter interpreter) {
      return IsNoop(interpreter.CharStack, interpreter.IntegerStack);
    }

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

  [StorableClass]
  [PushExpression(
    StackTypes.String,
    "STRING.YANKDUP",
    "Pushes a copy of an indexed item \"deep\" in the stack onto the top of the stack, without removing the deep item.",
    StackTypes.Integer)]
  public class StringYankDuplicateExpression : YankDuplicateExpression<string> {
    public StringYankDuplicateExpression() { }
    [StorableConstructor]
    protected StringYankDuplicateExpression(bool deserializing) : base(deserializing) { }

    public override bool IsNoop(IInternalPushInterpreter interpreter) {
      return IsNoop(interpreter.StringStack, interpreter.IntegerStack);
    }

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

  [StorableClass]
  [PushExpression(
    StackTypes.IntegerVector,
    "INTEGER[].YANKDUP",
    "Pushes a copy of an indexed item \"deep\" in the stack onto the top of the stack, without removing the deep item.",
    StackTypes.Integer)]
  public class IntegerVectorYankDuplicateExpression : YankDuplicateExpression<IReadOnlyList<long>> {
    public IntegerVectorYankDuplicateExpression() { }
    [StorableConstructor]
    protected IntegerVectorYankDuplicateExpression(bool deserializing) : base(deserializing) { }

    public override bool IsNoop(IInternalPushInterpreter interpreter) {
      return IsNoop(interpreter.IntegerVectorStack, interpreter.IntegerStack);
    }

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

  [StorableClass]
  [PushExpression(
    StackTypes.FloatVector,
    "FLOAT[].YANKDUP",
    "Pushes a copy of an indexed item \"deep\" in the stack onto the top of the stack, without removing the deep item.",
    StackTypes.Integer)]
  public class FloatVectorYankDuplicateExpression : YankDuplicateExpression<IReadOnlyList<double>> {
    public FloatVectorYankDuplicateExpression() { }
    [StorableConstructor]
    protected FloatVectorYankDuplicateExpression(bool deserializing) : base(deserializing) { }

    public override bool IsNoop(IInternalPushInterpreter interpreter) {
      return IsNoop(interpreter.FloatVectorStack, interpreter.IntegerStack);
    }

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

  [StorableClass]
  [PushExpression(
    StackTypes.BooleanVector,
    "BOOLEAN[].YANKDUP",
    "Pushes a copy of an indexed item \"deep\" in the stack onto the top of the stack, without removing the deep item.",
    StackTypes.Integer)]
  public class BooleanVectorYankDuplicateExpression : YankDuplicateExpression<IReadOnlyList<bool>> {
    public BooleanVectorYankDuplicateExpression() { }
    [StorableConstructor]
    protected BooleanVectorYankDuplicateExpression(bool deserializing) : base(deserializing) { }

    public override bool IsNoop(IInternalPushInterpreter interpreter) {
      return IsNoop(interpreter.BooleanVectorStack, interpreter.IntegerStack);
    }

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

  [StorableClass]
  [PushExpression(
    StackTypes.StringVector,
    "STRING[].YANKDUP",
    "Pushes a copy of an indexed item \"deep\" in the stack onto the top of the stack, without removing the deep item.",
    StackTypes.Integer)]
  public class StringVectorYankDuplicateExpression : YankDuplicateExpression<IReadOnlyList<string>> {
    public StringVectorYankDuplicateExpression() { }
    [StorableConstructor]
    protected StringVectorYankDuplicateExpression(bool deserializing) : base(deserializing) { }

    public override bool IsNoop(IInternalPushInterpreter interpreter) {
      return IsNoop(interpreter.StringVectorStack, interpreter.IntegerStack);
    }

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