using System;
using System.Linq;
using HeuristicLab.Analysis.FitnessLandscape.DataTables;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Operators;
using HeuristicLab.Optimization;
using HeuristicLab.Parameters;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;

namespace HeuristicLab.Analysis.FitnessLandscape.Algorithms {
  public interface IRepeatsAnalyzer : IOperator { }

  [Item("RepeatedRuggednessAnalyzer", "Analyzes and consolidates repeated ruggedness analyses.")]
  [StorableClass]
  public class RepeatedRuggednessAnalyzer : SingleSuccessorOperator, IRepeatsAnalyzer {

    #region Parameters
    public ScopeTreeLookupParameter<DoubleValue> AutoCorrelationValuesParameter {
      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["AutoCorrelationValues"]; }
    }
    public LookupParameter<DoubleValue> AutoCorrelation1Parameter {
      get { return (LookupParameter<DoubleValue>)Parameters["AutoCorrelation1"]; }
    }
    public LookupParameter<DoubleValue> AutoCorrelation1VarianceParameter {
      get { return (LookupParameter<DoubleValue>)Parameters["AutoCorrelation1Variance"]; }
    }

    public ScopeTreeLookupParameter<IntValue> CorrelationLengthsParameter {
      get { return (ScopeTreeLookupParameter<IntValue>)Parameters["CorrelationLengths"]; }
    }
    public LookupParameter<DoubleValue> CorrelationLengthParameter {
      get { return (LookupParameter<DoubleValue>)Parameters["CorrelationLength"]; }
    }
    public LookupParameter<DoubleValue> CorrelationLengthVarianceParameter {
      get { return (LookupParameter<DoubleValue>)Parameters["CorrelationLengthVariance"]; }
    }

    public ScopeTreeLookupParameter<DataTable> AutoCorrelationTablesParameter {
      get { return (ScopeTreeLookupParameter<DataTable>)Parameters["AutoCorrelationTables"]; }
    }
    public LookupParameter<DataTable> AutoCorrelationParameter {
      get { return (LookupParameter<DataTable>)Parameters["AutoCorrelation"]; }
    }
    public LookupParameter<DataTable> AllAutoCorrelationsParameter {
      get { return (LookupParameter<DataTable>)Parameters["AllAutoCorrelations"]; }
    }
    public LookupParameter<DataTable> AutoCorrelationVarianceParameter {
      get { return (LookupParameter<DataTable>)Parameters["AutoCorrelationVariance"]; }
    }
    public LookupParameter<ResultCollection> ResultsParameter {
      get { return (LookupParameter<ResultCollection>)Parameters["Results"]; }
    }
    public ValueParameter<BoolValue> SaveAllAutocorrelationsParameter {
      get { return (ValueParameter<BoolValue>)Parameters["SaveAllAutocorrelations"]; }
    }
    
    #endregion

    #region Construction & Cloning
    [StorableConstructor]
    protected RepeatedRuggednessAnalyzer(bool deserializing) : base(deserializing) { }
    protected RepeatedRuggednessAnalyzer(RepeatedRuggednessAnalyzer original, Cloner cloner) : base(original, cloner) { }
    public RepeatedRuggednessAnalyzer() {
      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("AutoCorrelationValues", "Auto correlation values of repeats."));
      Parameters.Add(new LookupParameter<DoubleValue>("AutoCorrelation1", "Consolidated auto correlation 1."));
      Parameters.Add(new LookupParameter<DoubleValue>("AutoCorrelation1Variance", "Variance between auto correlations in repeats."));

      Parameters.Add(new ScopeTreeLookupParameter<IntValue>("CorrelationLengths", "Correlation lengths of the individual repeats."));
      Parameters.Add(new LookupParameter<DoubleValue>("CorrelationLength", "Consolidated (average) correlation length."));
      Parameters.Add(new LookupParameter<DoubleValue>("CorrelationLengthVariance", "Variance of correlation lengths."));

      Parameters.Add(new ScopeTreeLookupParameter<DataTable>("AutoCorrelationTables", "List of autocorrelation tables for each repeat."));
      Parameters.Add(new LookupParameter<DataTable>("AutoCorrelation", "Consolidated auto correlation table."));
      Parameters.Add(new LookupParameter<DataTable>("AllAutoCorrelations", "All auto correlations merged into a single table."));
      Parameters.Add(new LookupParameter<DataTable>("AutoCorrelationVariance", "Variance of autocorrelations."));
      Parameters.Add(new ValueParameter<BoolValue>("SaveAllAutocorrelations", "Wether to include all repeated autocorrelation curves. Turn of to save memory instead.", new BoolValue(false)));

      Parameters.Add(new LookupParameter<ResultCollection>("Results", "The collection of all results."));

      AutoCorrelationValuesParameter.ActualName = "AutoCorrelation1";
      AutoCorrelationValuesParameter.Depth = 2;
      AutoCorrelationTablesParameter.ActualName = "Autocorrelation";
      AutoCorrelationTablesParameter.Depth = 2;
      CorrelationLengthsParameter.ActualName = "CorrelationLength";
      CorrelationLengthsParameter.Depth = 2;
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new RepeatedRuggednessAnalyzer(this, cloner);
    }
    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
      if (!Parameters.ContainsKey("SaveAllAutocorrelations"))
        Parameters.Add(new ValueParameter<BoolValue>("SaveAllAutocorrelations", "Whether to include all repeated autocorrelation curves. Turn of to save memory instead.", new BoolValue(false)));
    }
    #endregion

    public override IOperation Apply() {
      AggregateAutoCorrelationValues();
      AggregateCorrelationLengths();
      AggregateAutoCorrelationFunctions();
      return base.Apply();
    }

    private void AggregateAutoCorrelationValues() {
      ResultCollection results = ResultsParameter.ActualValue;
      var autocorrelations = AutoCorrelationValuesParameter.ActualValue.Select(v => v.Value).ToList();
      if (autocorrelations.Count > 0) {
        var avgAutoCorrelation1 = new DoubleValue(autocorrelations.Average());
        var varAutoCorrelation1 = new DoubleValue(autocorrelations.Variance());
        AutoCorrelation1Parameter.ActualValue = avgAutoCorrelation1;
        AutoCorrelation1VarianceParameter.ActualValue = varAutoCorrelation1;
        results.Remove("AutoCorrelation1");
        results.Add(new Result("AutoCorrelation1", avgAutoCorrelation1));
        results.Add(new Result("AutoCorrelation1 Variance", varAutoCorrelation1));
      }
    }

    private void AggregateCorrelationLengths() {
      ResultCollection results = ResultsParameter.ActualValue;
      var correlationLengths = CorrelationLengthsParameter.ActualValue.Select(v => (double)v.Value).ToList();
      if (correlationLengths.Count > 0) {
        var avgCorrelationLength = new DoubleValue(correlationLengths.Average());
        var varCorrelationLength = new DoubleValue(correlationLengths.Variance());
        CorrelationLengthParameter.ActualValue = avgCorrelationLength;
        CorrelationLengthVarianceParameter.ActualValue = varCorrelationLength;
        results.Remove("CorrelationLength");
        results.Add(new Result("CorrelationLength", avgCorrelationLength));
        results.Add(new Result("CorrelationLength Variance", varCorrelationLength));
      }
    }

    private void AggregateAutoCorrelationFunctions() {
      ResultCollection results = ResultsParameter.ActualValue;
      bool saveAllAutocorrelations = SaveAllAutocorrelationsParameter.Value.Value;
      var tables = AutoCorrelationTablesParameter.ActualValue.ToList();
      if (tables.Count > 0) {
        DataTable allValues = saveAllAutocorrelations ? new DataTable("All AutoCorrelations") : null;
        DataRow avgRow = new DataRow("Average Auto Correlation");
        DataRow stdRow = new DataRow("Std.Dev. of Auto Correlations");
        DataRow countRow = new DataRow("n");
        avgRow.VisualProperties.StartIndexZero = true;
        stdRow.VisualProperties.StartIndexZero = true;
        countRow.VisualProperties.StartIndexZero = true;
        countRow.VisualProperties.SecondYAxis = true;
        for (int i = 0; i<tables.Count; i++) {
          DataRow row = tables[i].Rows.First();
          var newRow = new DataRow(i.ToString(), "", row.Values);
          newRow.VisualProperties.StartIndexZero = true;
          if (allValues != null)
            allValues.Rows.Add(newRow);
          while (avgRow.Values.Count < row.Values.Count) {
            stdRow.Values.Add(0);
            avgRow.Values.Add(0);
            countRow.Values.Add(0);
          }
          for (int j = 0; j<row.Values.Count; j++) {
            avgRow.Values[j] += row.Values[j];
            countRow.Values[j]++;
          }
        }
        for (int i = 0; i<avgRow.Values.Count; i++) {
          avgRow.Values[i] = avgRow.Values[i] / tables.Count;
        }
        foreach (var table in tables) {
          DataRow row = table.Rows.First();
          for (int j = 0; j<row.Values.Count; j++) {
            stdRow.Values[j] += square(avgRow.Values[j] - row.Values[j]);
          }
        }
        for (int i = 0; i<avgRow.Values.Count; i++) {
          stdRow.Values[i] = Math.Sqrt(stdRow.Values[i] / tables.Count);
        }
        AutoCorrelationTable avgTable = new AutoCorrelationTable("Average repeated auto correlation");
        AutoCorrelationTable stdTable = new AutoCorrelationTable("Std.Dev. of repeated auto correlation");
        avgTable.Rows.Add(avgRow);
        avgTable.Rows.Add(countRow);
        stdTable.Rows.Add(stdRow);
        AutoCorrelationParameter.ActualValue = avgTable;
        AutoCorrelationVarianceParameter.ActualValue = stdTable;
        results.Remove("Autocorrelation");
        results.Add(new Result("Auto Correlation", avgTable));
        results.Add(new Result("auto correlation deviations", stdTable));
        if (allValues != null) {
          AllAutoCorrelationsParameter.ActualValue = allValues;
          results.Add(new Result("All auto correlations", allValues));
        }
      }
    }

    public static double square(double x) { return x * x; }
  }
}