namespace HeuristicLab.Problems.ProgramSynthesis.Base.Erc {
  using System;
  using System.Collections.Generic;
  using System.Linq;

  using HeuristicLab.Common;
  using HeuristicLab.Core;
  using HeuristicLab.Data;
  using HeuristicLab.Parameters;
  using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
  using HeuristicLab.Problems.ProgramSynthesis.Base.Erc.Interfaces;

  [StorableClass]
  public class FloatErcOptions : ErcOption, IReadOnlyFloatErcOptions {
    private const string ConstantsParameterName = "Constants";
    private const string RangeParameterName = "Range";

    public FloatErcOptions() : this(default(double), default(double)) {
      IsEnabled = false;
    }

    public FloatErcOptions(double start, double end) : this(start, end, new double[0]) {
    }

    public FloatErcOptions(double[] constants) : this(default(double), default(double), constants) {
    }

    public FloatErcOptions(double start, double end, double[] constants) {
      if (start > end) {
        throw new InvalidOperationException("start >= end");
      }

      IsEnabled = true;
      Parameters.Add(new ValueParameter<DoubleArray>(ConstantsParameterName, new DoubleArray(constants) { Resizable = true }));
      Parameters.Add(new FixedValueParameter<DoubleRange>(RangeParameterName, new DoubleRange(start, end)));
    }

    [StorableConstructor]
    private FloatErcOptions(bool deserializing) : base(deserializing) { }

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

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

    public IValueParameter<DoubleArray> ConstantsParameter
    {
      get { return (IValueParameter<DoubleArray>)Parameters[ConstantsParameterName]; }
    }

    public IReadOnlyList<double> Constants
    {
      get { return ConstantsParameter.Value.Data; }
      set { ConstantsParameter.Value = new DoubleArray(value.ToArray()); }
    }

    public IValueParameter<DoubleRange> RangeParameter
    {
      get { return (IValueParameter<DoubleRange>)Parameters[RangeParameterName]; }
    }

    /// <summary>
    /// The minimum FLOAT that will be produced as an ephemeral random FLOAT constant or from a call to FLOAT.RAND.
    /// </summary>
    public double Start
    {
      get { return RangeParameter.Value.Start; }
      set { RangeParameter.Value.Start = value; }
    }

    /// <summary>
    /// The maximum FLOAT that will be produced as an ephemeral random FLOAT constant or from a call to FLOAT.RAND.
    /// </summary>
    public double End
    {
      get { return RangeParameter.Value.End; }
      set { RangeParameter.Value.End = value; }
    }
  }
}