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

namespace HeuristicLab.Analysis.FitnessLandscape.Analysis {

  [Item("RepeatAggregator", "Aggregates analysis results from repeated runs on the same starting point.")]
  [StorableClass]
  public class RepeatAggregator : SingleSuccessorOperator {

    #region Parameter Properties
    public LookupParameter<ResultCollection> ResultsParameter {
      get { return (LookupParameter<ResultCollection>)Parameters["Results"]; }
    }
    #endregion

    #region Construction & Cloning
    [StorableConstructor]
    protected RepeatAggregator(bool deserializing) : base(deserializing) { }
    protected RepeatAggregator(RepeatAggregator original, Cloner cloner) : base(original, cloner) { }
    public RepeatAggregator() {
      Parameters.Add(new LookupParameter<ResultCollection>("Results", ""));
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new RepeatAggregator(this, cloner);
    }
    #endregion

    public override IOperation Apply() {
      ResultCollection results = ResultsParameter.ActualValue;
      var tables = ExtractTablesFromResults(results).ToList();
      DataTable allValues = new DataTable("All AutoCorrelations");
      DataRow avgRow = new DataRow("Average Auto Correlation");
      DataRow stdRow = new DataRow("Std.Dev. of Auto Correlations");
      DataRow countRow = new DataRow("n");
      countRow.VisualProperties.SecondYAxis = true;
      for (int i = 0; i<tables.Count; i++) {
        DataRow row = tables[i].Rows.First();
        allValues.Rows.Add(new DataRow(i.ToString(), "", row.Values));
        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);
      }
      results.RemoveAll(r => r.Value is IScope || r.Value is AutoCorrelationTable);
      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);
      results.Add(new Result("Average Auto Correlation", avgTable));
      results.Add(new Result("All Auto Correlations", allValues));
      results.Add(new Result("Std.Dev. Auto Correlations", stdTable));
      return base.Apply();
    }

    public static IEnumerable<AutoCorrelationTable> ExtractTablesFromResults(ResultCollection results) {
      foreach (IResult result in results) {
        IScope scope = result.Value as IScope;
        if (scope != null) {
          foreach (Variable v in scope.Variables) {
            AutoCorrelationTable table = v.Value as AutoCorrelationTable;
            if (table != null) {
              yield return table;
            }
          }
        }
      }
    }

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