namespace HeuristicLab.Problems.ProgramSynthesis {
  using System;
  using System.Linq;

  using HeuristicLab.Common;
  using HeuristicLab.Core;
  using HeuristicLab.Data;
  using HeuristicLab.Operators;
  using HeuristicLab.Optimization;
  using HeuristicLab.Parameters;
  using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
  using HeuristicLab.Random;

  /// <summary>
  /// Alternation crossover for plush vectors.
  /// </summary>
  [Item("AlternationCrossover", "Alternation crossover for plush vectors.")]
  [StorableClass]
  public class AlternationCrossover : InstrumentedOperator, IPlushCrossover, IStochasticOperator {
    private const double Mean = 0.0;

    public AlternationCrossover() {
      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic crossover operators."));

      Parameters.Add(new ScopeTreeLookupParameter<PlushVector>("Parents", "The parent vectors which should be crossed."));
      ParentsParameter.ActualName = "PlushVector";

      Parameters.Add(new LookupParameter<PlushVector>("Child", "The child vector resulting from the crossover."));
      ChildParameter.ActualName = "PlushVector";

      Parameters.Add(new LookupParameter<IntValue>("MaxProgramLength", "The max length of children"));

      Parameters.Add(new FixedValueParameter<PercentValue>("AlternationRate", "Specifies the probability of switching to another parent.", new PercentValue(0.5)));
      Parameters.Add(new FixedValueParameter<DoubleValue>("AlignmentDeviation", "When alternating between parents, the index at which to continue copying may be offset backward or forward some amount based on a random sample from a normal distribution with mean 0 and standard deviation set by the alignment deviation parameter", new DoubleValue(1.0)));

    }

    [StorableConstructor]
    public AlternationCrossover(bool deserializing) : base(deserializing) {
    }

    public AlternationCrossover(AlternationCrossover origin, Cloner cloner) : base(origin, cloner) {
    }

    public override IDeepCloneable Clone(Cloner cloner) {
      return new AlternationCrossover(this, cloner);
    }

    public ILookupParameter<IntValue> MaxProgramLengthParameter {
      get { return (ILookupParameter<IntValue>)Parameters["MaxProgramLength"]; }
    }

    public int MaxProgramLength {
      get { return MaxProgramLengthParameter.ActualValue.Value; }
      set { MaxProgramLengthParameter.ActualValue.Value = value; }
    }

    public IValueParameter<PercentValue> AlternationRateParameter {
      get { return (IValueParameter<PercentValue>)Parameters["AlternationRate"]; }
    }

    public double AlternationRate {
      get { return AlternationRateParameter.Value.Value; }
      set { AlternationRateParameter.Value.Value = value; }
    }

    public IValueParameter<DoubleValue> AlignmentDeviationParameter {
      get { return (IValueParameter<DoubleValue>)Parameters["AlignmentDeviation"]; }
    }

    public double AlignmentDeviation {
      get { return AlignmentDeviationParameter.Value.Value; }
      set { AlignmentDeviationParameter.Value.Value = value; }
    }

    public ILookupParameter<IRandom> RandomParameter {
      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
    }
    public ILookupParameter<ItemArray<PlushVector>> ParentsParameter {
      get { return (ScopeTreeLookupParameter<PlushVector>)Parameters["Parents"]; }
    }
    public ILookupParameter<PlushVector> ChildParameter {
      get { return (ILookupParameter<PlushVector>)Parameters["Child"]; }
    }

    public sealed override IOperation InstrumentedApply() {
      ChildParameter.ActualValue = Cross(
        RandomParameter.ActualValue,
        ParentsParameter.ActualValue,
        AlternationRate,
        MaxProgramLength,
        AlignmentDeviation);
      return base.InstrumentedApply();
    }

    private static PlushVector Cross(
      IRandom random,
      ItemArray<PlushVector> parents,
      double alternationRate,
      int maxChildLength,
      double alignmentDeviation) {
      var normalDistributedRandom = new NormalDistributedRandom(random, Mean, alignmentDeviation);
      var maxLength = parents.Max(p => p.Entries.Count);
      var parentIndex = random.Next(0, 2);
      var parent = parents[parentIndex];
      var child = new PlushVector(maxLength);

      for (var i = 0; i < maxLength && child.Entries.Count <= maxChildLength; i++) {

        // if parent is shorter than the other, then ignore those entries
        if (i < parent.Entries.Count)
          child.Add(parent[i]);

        // switch parent?
        if (random.NextDouble() < alternationRate) {
          parentIndex = parentIndex == 0 ? 1 : 0;
          parent = parents[parentIndex];
          i += normalDistributedRandom.NextRounded();
          i = Math.Max(i, 0);
        }
      }

      return child;
    }
  }
}