using HeuristicLab.Algorithms.PushGP.Interpreter;
using HeuristicLab.Algorithms.PushGP.Stack;
using HeuristicLab.Common;

namespace HeuristicLab.Algorithms.PushGP.Expressions
{
    /// <summary>
    /// Duplicates the top item on the INTEGER stack. Does not pop its argument
    /// (which, if it did, would negate the effect of the duplication!).
    /// </summary>
    /// <typeparam name="T">Stacktype</typeparam>
    public abstract class DuplicateExpression<T> : Expression
    {
        public DuplicateExpression(string stringRepresentation) : base(stringRepresentation)
        { }

        public void Eval(IStack<T> stack)
        {
            if (stack.Count == 0)
                return;

            var clone = this.Clone(stack.Top);

            stack.Push(clone);
        }

        public abstract T Clone(T original);
    }

    public class IntegerDuplicateExpression : DuplicateExpression<long>
    {
        public IntegerDuplicateExpression() : base("INTEGER.DUP")
        { }

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

        public override long Clone(long value)
        {
            return value;
        }
    }

    public class FloatDuplicateExpression : DuplicateExpression<double>
    {
        public FloatDuplicateExpression() : base("FLOAT.DUP")
        { }

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

        public override double Clone(double value)
        {
            return value;
        }
    }

    public class BooleanDuplicateExpression : DuplicateExpression<bool>
    {
        public BooleanDuplicateExpression() : base("BOOLEAN.DUP")
        { }

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

        public override bool Clone(bool value)
        {
            return value;
        }
    }

    public class NameDuplicateExpression : DuplicateExpression<string>
    {
        public NameDuplicateExpression() : base("NAME.DUP")
        { }

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

        public override string Clone(string value)
        {
            return string.Copy(value);
        }
    }

    public class ExecDuplicateExpression : DuplicateExpression<Expression>
    {
        private readonly Cloner cloner = new Cloner();
        public ExecDuplicateExpression() : base("EXEC.DUP")
        { }

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

        public override Expression Clone(Expression original)
        {
            return cloner.Clone(original);
        }
    }

    public class CodeDuplicateExpression : DuplicateExpression<Expression>
    {
        private readonly Cloner cloner = new Cloner();

        public CodeDuplicateExpression() : base("CODE.DUP")
        { }

        public override void Eval(IInterpreter interpreter)
        {
            this.Eval(interpreter.CodeStack);
        }

        public override Expression Clone(Expression original)
        {
            return cloner.Clone(original);
        }
    }
}