using System;

namespace HeuristicLab.Problems.ProgramSynthesis.Push.SolutionCreator {
  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.Problems.ProgramSynthesis.Base.Erc;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Encoding;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Extensions;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Generators.CodeGenerator;

  [Item("PlushCreator", "An operator which creates a new random plush vector with each element uniformly distributed")]
  [StorableClass]
  public class PlushCreator : InstrumentedOperator, IPlushCreator, IStochasticOperator {

    public PlushCreator() {
      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
      Parameters.Add(new LookupParameter<PlushVector>("PlushVector", "The vector which should be manipulated."));
      Parameters.Add(new ValueLookupParameter<IntValue>("MinLength", "The min length of the vector."));
      Parameters.Add(new ValueLookupParameter<IntValue>("MaxLength", "The max length of the vector."));
      Parameters.Add(new ValueLookupParameter<IntValue>("MaxClose", "The max close variable for a plush genome entry."));
      Parameters.Add(new ValueLookupParameter<DoubleValue>("CloseBiasLevel", "Determines how strongly the random close variable is biased towards 0."));
      Parameters.Add(new ValueLookupParameter<IReadOnlyExpressionsConfiguration>("Instructions", "The enabled instructions"));
      Parameters.Add(new ValueLookupParameter<IReadOnlyErcOptions>("ErcOptions", "ERC options"));
      Parameters.Add(new ValueLookupParameter<PercentValue>("InInstructionProbability", "The probability of IN Instructions"));
    }

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

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

    public override bool CanChangeName
    {
      get { return false; }
    }
    public ILookupParameter<IRandom> RandomParameter
    {
      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
    }
    public ILookupParameter<PlushVector> PlushVectorParameter
    {
      get { return (ILookupParameter<PlushVector>)Parameters["PlushVector"]; }
    }
    public IValueLookupParameter<IntValue> MinLengthParameter
    {
      get { return (IValueLookupParameter<IntValue>)Parameters["MinLength"]; }
    }
    public IValueLookupParameter<IntValue> MaxLengthParameter
    {
      get { return (IValueLookupParameter<IntValue>)Parameters["MaxLength"]; }
    }
    public IValueLookupParameter<IReadOnlyExpressionsConfiguration> InstructionsParameter
    {
      get { return (IValueLookupParameter<IReadOnlyExpressionsConfiguration>)Parameters["Instructions"]; }
    }
    public IValueLookupParameter<IReadOnlyErcOptions> ErcOptionsParameter
    {
      get { return (IValueLookupParameter<IReadOnlyErcOptions>)Parameters["ErcOptions"]; }
    }
    public IValueLookupParameter<PercentValue> InInstructionProbabilityParameter
    {
      get { return (IValueLookupParameter<PercentValue>)Parameters["InInstructionProbability"]; }
    }
    public IValueLookupParameter<IntValue> MaxCloseParameter
    {
      get { return (IValueLookupParameter<IntValue>)Parameters["MaxClose"]; }
    }
    public IValueLookupParameter<DoubleValue> CloseBiasLevelParameter
    {
      get { return (IValueLookupParameter<DoubleValue>)Parameters["CloseBiasLevel"]; }
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new PlushCreator(this, cloner);
    }

    public sealed override IOperation InstrumentedApply() {
      PlushVectorParameter.ActualValue = Create();
      return base.InstrumentedApply();
    }

    private PlushVector Create() {
      var random = RandomParameter.ActualValue;
      var minLength = MinLengthParameter.ActualValue.Value;
      var maxLength = MaxLengthParameter.ActualValue.Value;
      var ercOptions = ErcOptionsParameter.ActualValue;
      var instructions = InstructionsParameter.ActualValue;
      var inInstructionProbability = InInstructionProbabilityParameter.ActualValue.Value;
      var maxClose = MaxCloseParameter.ActualValue.Value;
      var biasLevel = CloseBiasLevelParameter.ActualValue.Value;

      if (minLength > maxLength)
        throw new InvalidOperationException("MinLength > MaxLength");

      var length = random.Next(minLength, maxLength);
      var result = new PlushVector(length);

      for (var i = 0; i < length; i++) {
        var expression = CodeGeneratorUtils.GetRandomExpression(
          random,
          ercOptions,
          instructions,
          inInstructionProbability);

        var close = maxClose == 0 ? 1 : random.NextBiased(0, maxClose, biasLevel);

        result.Add(new PlushEntry {
          Close = close,
          Instruction = expression,
        });
      }

      return result;
    }
  }
}