using System.Linq;

using HEAL.Attic;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
using HeuristicLab.Operators;
using HeuristicLab.Optimization;
using HeuristicLab.Parameters;

namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
  [Item("SymbolFrequencyReinitializationStrategyController", "")]
  [StorableType("8F0B7020-A02F-491D-881A-5CE550426E5B")]
  public class SymbolFrequencyReinitializationStrategyController : InstrumentedOperator, IReinitializationStrategyController {

    private const string SymbolicExpressionTreeParameterName = "SymbolicExpressionTree";
    private const string SymbolicExpressionTreeGrammarParameterName = "ClonedSymbolicExpressionTreeGrammar";

    #region Parameter Properties
    public IScopeTreeLookupParameter<ISymbolicExpressionTree> SymbolicExpressionTreeParameter {
      get { return (IScopeTreeLookupParameter<ISymbolicExpressionTree>)Parameters[SymbolicExpressionTreeParameterName]; }
    }

    public IValueLookupParameter<ISymbolicExpressionGrammar> SymbolicExpressionTreeGrammarParameter {
      get { return (IValueLookupParameter<ISymbolicExpressionGrammar>)Parameters[SymbolicExpressionTreeGrammarParameterName]; }
    }
    #endregion

    #region Constructors
    public SymbolFrequencyReinitializationStrategyController() {
      Parameters.Add(new ScopeTreeLookupParameter<ISymbolicExpressionTree>(SymbolicExpressionTreeParameterName, "The symbolic expression tree whose length should be calculated."));
      Parameters.Add(new ValueLookupParameter<ISymbolicExpressionGrammar>(SymbolicExpressionTreeGrammarParameterName, "The tree grammar that defines the correct syntax of symbolic expression trees that should be created."));
    }

    private SymbolFrequencyReinitializationStrategyController(SymbolFrequencyReinitializationStrategyController original, Cloner cloner)
      : base(original, cloner) { }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new SymbolFrequencyReinitializationStrategyController(this, cloner);
    }

    [StorableConstructor]
    private SymbolFrequencyReinitializationStrategyController(StorableConstructorFlag _) : base(_) { }
    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }
    #endregion


    public override IOperation InstrumentedApply() {
      var trees = SymbolicExpressionTreeParameter.ActualValue;
      var grammar = SymbolicExpressionTreeGrammarParameter.ActualValue;

      var symbolFrequencies = SymbolicExpressionSymbolFrequencyAnalyzer.CalculateSymbolFrequencies(trees).ToDictionary(x => x.Key, x => x.Value);

      foreach (var s in grammar.AllowedSymbols) {
        if (s is ProgramRootSymbol || s is StartSymbol) {
          continue;
        }

        if (symbolFrequencies.TryGetValue(s.Name, out double f)) {
          s.InitialFrequency = f;
        }
      }

      return base.InstrumentedApply();
    }
  }
}