#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2019 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

using System;
using System.Collections.Generic;
using System.Linq;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
using HeuristicLab.Optimization;
using HeuristicLab.Parameters;
using HEAL.Attic;
using System.Runtime.InteropServices;
using System.Diagnostics;

namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
  [Item("NLOpt Evaluator (with constraints)", "")]
  [StorableType("5FADAE55-3516-4539-8A36-BC9B0D00880D")]
  public class NLOptEvaluator : SymbolicRegressionSingleObjectiveEvaluator {
    private const string ConstantOptimizationIterationsParameterName = "ConstantOptimizationIterations";
    private const string ConstantOptimizationImprovementParameterName = "ConstantOptimizationImprovement";
    private const string ConstantOptimizationProbabilityParameterName = "ConstantOptimizationProbability";
    private const string ConstantOptimizationRowsPercentageParameterName = "ConstantOptimizationRowsPercentage";
    private const string UpdateConstantsInTreeParameterName = "UpdateConstantsInSymbolicExpressionTree";
    private const string UpdateVariableWeightsParameterName = "Update Variable Weights";

    private const string FunctionEvaluationsResultParameterName = "Constants Optimization Function Evaluations";
    private const string GradientEvaluationsResultParameterName = "Constants Optimization Gradient Evaluations";
    private const string CountEvaluationsParameterName = "Count Function and Gradient Evaluations";


    private const string AchievedQualityImprovementParameterName = "AchievedQualityImprovment";
    private const string NumberOfConstraintViolationsBeforeOptimizationParameterName = "NumberOfConstraintViolationsBeforeOptimization";
    private const string NumberOfConstraintViolationsAfterOptimizationParameterName = "NumberOfConstraintViolationsAfterOptimization";
    private const string ConstraintsBeforeOptimizationParameterName = "ConstraintsBeforeOptimization";
    private const string ViolationsAfterOptimizationParameterName = "ConstraintsAfterOptimization";
    private const string OptimizationDurationParameterName = "OptimizationDuration";

    public IFixedValueParameter<IntValue> ConstantOptimizationIterationsParameter {
      get { return (IFixedValueParameter<IntValue>)Parameters[ConstantOptimizationIterationsParameterName]; }
    }
    public IFixedValueParameter<DoubleValue> ConstantOptimizationImprovementParameter {
      get { return (IFixedValueParameter<DoubleValue>)Parameters[ConstantOptimizationImprovementParameterName]; }
    }
    public IFixedValueParameter<PercentValue> ConstantOptimizationProbabilityParameter {
      get { return (IFixedValueParameter<PercentValue>)Parameters[ConstantOptimizationProbabilityParameterName]; }
    }
    public IFixedValueParameter<PercentValue> ConstantOptimizationRowsPercentageParameter {
      get { return (IFixedValueParameter<PercentValue>)Parameters[ConstantOptimizationRowsPercentageParameterName]; }
    }
    public IFixedValueParameter<BoolValue> UpdateConstantsInTreeParameter {
      get { return (IFixedValueParameter<BoolValue>)Parameters[UpdateConstantsInTreeParameterName]; }
    }
    public IFixedValueParameter<BoolValue> UpdateVariableWeightsParameter {
      get { return (IFixedValueParameter<BoolValue>)Parameters[UpdateVariableWeightsParameterName]; }
    }

    public IResultParameter<IntValue> FunctionEvaluationsResultParameter {
      get { return (IResultParameter<IntValue>)Parameters[FunctionEvaluationsResultParameterName]; }
    }
    public IResultParameter<IntValue> GradientEvaluationsResultParameter {
      get { return (IResultParameter<IntValue>)Parameters[GradientEvaluationsResultParameterName]; }
    }
    public IFixedValueParameter<BoolValue> CountEvaluationsParameter {
      get { return (IFixedValueParameter<BoolValue>)Parameters[CountEvaluationsParameterName]; }
    }
    public IConstrainedValueParameter<StringValue> SolverParameter {
      get { return (IConstrainedValueParameter<StringValue>)Parameters["Solver"]; }
    }


    public ILookupParameter<DoubleValue> AchievedQualityImprovementParameter {
      get { return (ILookupParameter<DoubleValue>)Parameters[AchievedQualityImprovementParameterName]; }
    }
    public ILookupParameter<DoubleValue> NumberOfConstraintViolationsBeforeOptimizationParameter {
      get { return (ILookupParameter<DoubleValue>)Parameters[NumberOfConstraintViolationsBeforeOptimizationParameterName]; }
    }
    public ILookupParameter<DoubleValue> NumberOfConstraintViolationsAfterOptimizationParameter {
      get { return (ILookupParameter<DoubleValue>)Parameters[NumberOfConstraintViolationsAfterOptimizationParameterName]; }
    }
    public ILookupParameter<DoubleArray> ViolationsAfterOptimizationParameter {
      get { return (ILookupParameter<DoubleArray>)Parameters[ViolationsAfterOptimizationParameterName]; }
    }
    public ILookupParameter<DoubleArray> ViolationsBeforeOptimizationParameter {
      get { return (ILookupParameter<DoubleArray>)Parameters[ConstraintsBeforeOptimizationParameterName]; }
    }
    public ILookupParameter<DoubleValue> OptimizationDurationParameter {
      get { return (ILookupParameter<DoubleValue>)Parameters[OptimizationDurationParameterName]; }
    }


    public IntValue ConstantOptimizationIterations {
      get { return ConstantOptimizationIterationsParameter.Value; }
    }
    public DoubleValue ConstantOptimizationImprovement {
      get { return ConstantOptimizationImprovementParameter.Value; }
    }
    public PercentValue ConstantOptimizationProbability {
      get { return ConstantOptimizationProbabilityParameter.Value; }
    }
    public PercentValue ConstantOptimizationRowsPercentage {
      get { return ConstantOptimizationRowsPercentageParameter.Value; }
    }
    public bool UpdateConstantsInTree {
      get { return UpdateConstantsInTreeParameter.Value.Value; }
      set { UpdateConstantsInTreeParameter.Value.Value = value; }
    }

    public bool UpdateVariableWeights {
      get { return UpdateVariableWeightsParameter.Value.Value; }
      set { UpdateVariableWeightsParameter.Value.Value = value; }
    }

    public bool CountEvaluations {
      get { return CountEvaluationsParameter.Value.Value; }
      set { CountEvaluationsParameter.Value.Value = value; }
    }

    public string Solver {
      get { return SolverParameter.Value.Value; }
    }
    public override bool Maximization {
      get { return false; }
    }

    [StorableConstructor]
    protected NLOptEvaluator(StorableConstructorFlag _) : base(_) { }
    protected NLOptEvaluator(NLOptEvaluator original, Cloner cloner)
      : base(original, cloner) {
    }
    public NLOptEvaluator()
      : base() {
      Parameters.Add(new FixedValueParameter<IntValue>(ConstantOptimizationIterationsParameterName, "Determines how many iterations should be calculated while optimizing the constant of a symbolic expression tree (0 indicates other or default stopping criterion).", new IntValue(10)));
      Parameters.Add(new FixedValueParameter<DoubleValue>(ConstantOptimizationImprovementParameterName, "Determines the relative improvement which must be achieved in the constant optimization to continue with it (0 indicates other or default stopping criterion).", new DoubleValue(0)) { Hidden = true });
      Parameters.Add(new FixedValueParameter<PercentValue>(ConstantOptimizationProbabilityParameterName, "Determines the probability that the constants are optimized", new PercentValue(1)));
      Parameters.Add(new FixedValueParameter<PercentValue>(ConstantOptimizationRowsPercentageParameterName, "Determines the percentage of the rows which should be used for constant optimization", new PercentValue(1)));
      Parameters.Add(new FixedValueParameter<BoolValue>(UpdateConstantsInTreeParameterName, "Determines if the constants in the tree should be overwritten by the optimized constants.", new BoolValue(true)) { Hidden = true });
      Parameters.Add(new FixedValueParameter<BoolValue>(UpdateVariableWeightsParameterName, "Determines if the variable weights in the tree should be  optimized.", new BoolValue(true)) { Hidden = true });

      Parameters.Add(new FixedValueParameter<BoolValue>(CountEvaluationsParameterName, "Determines if function and gradient evaluation should be counted.", new BoolValue(false)));

      var validSolvers = new ItemSet<StringValue>(new[] { "MMA", "COBYLA", "CCSAQ", "ISRES" }.Select(s => new StringValue(s).AsReadOnly()));
      Parameters.Add(new ConstrainedValueParameter<StringValue>("Solver", "The solver algorithm", validSolvers, validSolvers.First()));
      Parameters.Add(new ResultParameter<IntValue>(FunctionEvaluationsResultParameterName, "The number of function evaluations performed by the constants optimization evaluator", "Results", new IntValue()));
      Parameters.Add(new ResultParameter<IntValue>(GradientEvaluationsResultParameterName, "The number of gradient evaluations performed by the constants optimization evaluator", "Results", new IntValue()));



      Parameters.Add(new LookupParameter<DoubleValue>(AchievedQualityImprovementParameterName));
      Parameters.Add(new LookupParameter<DoubleValue>(NumberOfConstraintViolationsBeforeOptimizationParameterName));
      Parameters.Add(new LookupParameter<DoubleValue>(NumberOfConstraintViolationsAfterOptimizationParameterName));
      Parameters.Add(new LookupParameter<DoubleArray>(ConstraintsBeforeOptimizationParameterName));
      Parameters.Add(new LookupParameter<DoubleArray>(ViolationsAfterOptimizationParameterName));
      Parameters.Add(new LookupParameter<DoubleValue>(OptimizationDurationParameterName));
    }

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

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
      if (!Parameters.ContainsKey(AchievedQualityImprovementParameterName)) {
        Parameters.Add(new LookupParameter<DoubleValue>(AchievedQualityImprovementParameterName));
        Parameters.Add(new LookupParameter<DoubleValue>(NumberOfConstraintViolationsBeforeOptimizationParameterName));
        Parameters.Add(new LookupParameter<DoubleValue>(NumberOfConstraintViolationsAfterOptimizationParameterName));
      }
      if(!Parameters.ContainsKey(ConstraintsBeforeOptimizationParameterName)) {
        Parameters.Add(new LookupParameter<DoubleArray>(ConstraintsBeforeOptimizationParameterName));
        Parameters.Add(new LookupParameter<DoubleArray>(ViolationsAfterOptimizationParameterName));
        Parameters.Add(new LookupParameter<DoubleValue>(OptimizationDurationParameterName));

      }
    }

    private static readonly object locker = new object();

    public override IOperation InstrumentedApply() {
      var solution = SymbolicExpressionTreeParameter.ActualValue;
      double quality;
      if (RandomParameter.ActualValue.NextDouble() < ConstantOptimizationProbability.Value) {
        IEnumerable<int> constantOptimizationRows = GenerateRowsToEvaluate(ConstantOptimizationRowsPercentage.Value);
        var counter = new EvaluationsCounter();
        if (ConstantOptimizationRowsPercentage.Value != RelativeNumberOfEvaluatedSamplesParameter.ActualValue.Value) {
          throw new NotSupportedException();
        }

        var sw = new Stopwatch();
        sw.Start();
        quality = OptimizeConstants(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, solution, ProblemDataParameter.ActualValue,
           constantOptimizationRows, ApplyLinearScalingParameter.ActualValue.Value, Solver, 
           out double qDiff, out double[] constraintsBefore, out double[] constraintsAfter,
           ConstantOptimizationIterations.Value, updateVariableWeights: UpdateVariableWeights, 
           lowerEstimationLimit: EstimationLimitsParameter.ActualValue.Lower, upperEstimationLimit: EstimationLimitsParameter.ActualValue.Upper,
           updateConstantsInTree: UpdateConstantsInTree, counter: counter);

        AchievedQualityImprovementParameter.ActualValue = new DoubleValue(qDiff);
        NumberOfConstraintViolationsBeforeOptimizationParameter.ActualValue = new DoubleValue(constraintsBefore.Count(cv => cv > 0));
        NumberOfConstraintViolationsAfterOptimizationParameter.ActualValue = new DoubleValue(constraintsAfter.Count(cv => cv > 0));
        ViolationsBeforeOptimizationParameter.ActualValue = new DoubleArray(constraintsBefore);
        ViolationsAfterOptimizationParameter.ActualValue = new DoubleArray(constraintsAfter);
        OptimizationDurationParameter.ActualValue = new DoubleValue(sw.Elapsed.TotalSeconds);

        if (CountEvaluations) {
          lock (locker) {
            FunctionEvaluationsResultParameter.ActualValue.Value += counter.FunctionEvaluations;
            GradientEvaluationsResultParameter.ActualValue.Value += counter.GradientEvaluations;
          }
        }

      } else {
        throw new NotSupportedException();
      }
      QualityParameter.ActualValue = new DoubleValue(quality);

      return base.InstrumentedApply();
    }

    public override double Evaluate(IExecutionContext context, ISymbolicExpressionTree tree, IRegressionProblemData problemData, IEnumerable<int> rows) {
      SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = context;
      EstimationLimitsParameter.ExecutionContext = context;
      ApplyLinearScalingParameter.ExecutionContext = context;
      FunctionEvaluationsResultParameter.ExecutionContext = context;
      GradientEvaluationsResultParameter.ExecutionContext = context;

      // MSE evaluator is used on purpose instead of the const-opt evaluator, 
      // because Evaluate() is used to get the quality of evolved models on 
      // different partitions of the dataset (e.g., best validation model)
      double mse = SymbolicRegressionSingleObjectiveMeanSquaredErrorEvaluator.Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, tree, double.MinValue, double.MaxValue, problemData, rows, applyLinearScaling: false);

      SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = null;
      EstimationLimitsParameter.ExecutionContext = null;
      ApplyLinearScalingParameter.ExecutionContext = null;
      FunctionEvaluationsResultParameter.ExecutionContext = null;
      GradientEvaluationsResultParameter.ExecutionContext = null;

      return mse;
    }

    public class EvaluationsCounter {
      public int FunctionEvaluations = 0;
      public int GradientEvaluations = 0;
    }


    public static double OptimizeConstants(ISymbolicDataAnalysisExpressionTreeInterpreter interpreter,
      ISymbolicExpressionTree tree, IRegressionProblemData problemData, IEnumerable<int> rows, bool applyLinearScaling,
      string solver, out double qDiff, out double[] constraintsBefore, out double[] constraintsAfter,
      int maxIterations, bool updateVariableWeights = true,
      double lowerEstimationLimit = double.MinValue, double upperEstimationLimit = double.MaxValue,
      bool updateConstantsInTree = true, Action<double[], double, object> iterationCallback = null, EvaluationsCounter counter = null
      ) {

      if (!updateVariableWeights) throw new NotSupportedException("not updating variable weights is not supported");
      if (!updateConstantsInTree) throw new NotSupportedException("not updating tree parameters is not supported");
      if (!applyLinearScaling) throw new NotSupportedException("application without linear scaling is not supported");

      using (var state = new ConstrainedNLSInternal(solver, tree, maxIterations, problemData, 0, 0, 0)) {
        constraintsBefore = state.BestConstraintValues;
        double qBefore = state.BestError;
        state.Optimize(ConstrainedNLSInternal.OptimizationMode.UpdateParameters);
        constraintsAfter = state.BestConstraintValues;
        var qOpt = state.BestError;
        if (constraintsAfter.Any(cv => cv > 1e-8)) qOpt = qBefore;
        qDiff = qOpt - qBefore;

        if(counter != null) {
          counter.FunctionEvaluations += state.NumObjectiveFunctionEvaluations;
          counter.GradientEvaluations += state.NumObjectiveGradientEvaluations;
        }

        return qOpt;
      }
    }


  }
}