source: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Views/PushProgramDebuggerView.cs @ 14778

using System.Windows.Forms;

using HeuristicLab.Core.Views;
using HeuristicLab.MainForm;

namespace HeuristicLab.Problems.ProgramSynthesis.Push.Views {
  using System;
  using System.Linq;

  using HeuristicLab.BenchmarkSuite;
  using HeuristicLab.BenchmarkSuite.Problems;
  using HeuristicLab.BenchmarkSuite.Views;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Interpreter;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Problem;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Stack;
  using HeuristicLab.Random;

  [View("Push Program Debugger")]
  [Content(typeof(PushSolution), true)]
  public partial class PushProgramDebuggerView : NamedItemView {
    private const string Separator = ", ";
    private const string EmptySign = "-";
    private PushProgram program;

    private ListViewItem[] execListCache; //array to cache items for the virtual list
    private int firstExecListItemIndex; //stores the index of the first item in the cache

    private const string exampleSplitter = " => ";
    private PushInterpreter interpreter;

    public PushProgramDebuggerView() {
      InitializeComponent();

      Name = "Push Program Debugger";

      InitEvents();
      InitExecList();
    }

    private void InitEvents() {
      exampleComboBox.SelectedIndexChanged += SelectedExampleIndexChanged;
      runButton.Click += RunButtonClick;
      resetButton.Click += ResetButtonClick;
      stepButton.Click += StepButtonClick;
      simplifyButton.Click += SimplifyButtonClick;
    }

    private void SimplifyButtonClick(object sender, EventArgs e) {

    }

    private void InitExecList() {
      execList.RetrieveVirtualItem += ExecListRetrieveVirtualItem;
      execList.CacheVirtualItems += ExecListCacheVirtualItems;

      execList.View = View.Details;
      execList.HeaderStyle = ColumnHeaderStyle.None;
      execList.AutoResizeColumns(ColumnHeaderAutoResizeStyle.None);
      execList.Columns.Add(new ColumnHeader { Width = execList.Width - 40 });
      execList.VirtualMode = true;
      execList.VirtualListSize = 100;
    }

    private void ExecListCacheVirtualItems(object sender, CacheVirtualItemsEventArgs e) {
      //We've gotten a request to refresh the cache.
      //First check if it's really neccesary.
      if (execListCache != null &&
        e.StartIndex >= firstExecListItemIndex &&
        e.EndIndex <= firstExecListItemIndex + execListCache.Length) {
        //If the newly requested cache is a subset of the old cache,
        //no need to rebuild everything, so do nothing.
        return;
      }

      //Now we need to rebuild the cache.
      UpdateListCache(e.StartIndex, e.EndIndex);
    }

    private void ExecListRetrieveVirtualItem(object sender, RetrieveVirtualItemEventArgs e) {
      //check to see if the requested item is currently in the cache
      if (execListCache == null ||
        e.ItemIndex < firstExecListItemIndex ||
        e.ItemIndex >= firstExecListItemIndex + execListCache.Length) {
        UpdateListCache(e.ItemIndex, execList.VirtualListSize);
      }

      e.Item = e.ItemIndex >= firstExecListItemIndex && e.ItemIndex < firstExecListItemIndex + execListCache.Length
          ? execListCache[e.ItemIndex - firstExecListItemIndex]
          : e.Item = new ListViewItem();
    }

    private void UpdateListCache(int startIndex, int endIndex) {
      if (interpreter == null) {
        execListCache = new ListViewItem[0];
        return;
      }

      this.firstExecListItemIndex = startIndex;
      var length = Math.Min(endIndex - startIndex + 1, interpreter.ExecStack.Count); //indexes are inclusive
      this.execListCache = new ListViewItem[length];

      var expressions = this.interpreter.ExecStack.Peek(length);

      //Fill the cache with the appropriate ListViewItems.
      for (var i = 0; i < length; i++)
        this.execListCache[i] = new ListViewItem(expressions[length - 1 - i].ToString());

      execList.AutoResizeColumns(ColumnHeaderAutoResizeStyle.None);
      execList.AutoResizeColumns(ColumnHeaderAutoResizeStyle.ColumnContent);
    }

    //protected override void OnEnabledChanged(EventArgs e) {
    //  SetReadonlyFields();
    //}

    //protected override void OnReadOnlyChanged() {
    //  base.OnReadOnlyChanged();

    //  SetReadonlyFields();
    //}

    //protected override void SetEnabledStateOfControls()
    //{
    //  SetReadonlyFields();
    //}

    private void SetReadonlyFields() {
      var enabled = !ReadOnly;

      exampleComboBox.Enabled = enabled;
      execList.Enabled = enabled;
      codeList.Enabled = enabled;
      nameList.Enabled = enabled;
      integerList.Enabled = enabled;
      floatList.Enabled = enabled;
      booleanList.Enabled = enabled;
      stringList.Enabled = enabled;
      charList.Enabled = enabled;
      stepButton.Enabled = enabled;
      runButton.Enabled = enabled;
      resetButton.Enabled = enabled;
      skipNoopsCheckBox.Enabled = enabled;
      stepWidthBox.Enabled = enabled;
    }

    private void RunButtonClick(object sender, EventArgs e) {
      if (interpreter == null)
        return;

      interpreter.Resume();

      UpdateExecList();
      UpdateValueLists();
      CheckIfButtonsCanBeEnabled();
    }

    private void SyncExecList() {
      UpdateExecList();

      this.execGroupBox.Text = string.Format("Exec [{0}]", this.interpreter.ExecStack.Count);
    }

    private void StepButtonClick(object sender, EventArgs e) {
      if (interpreter == null || stepWidthBox.Value <= 0)
        return;

      var count = Math.Min(stepWidthBox.Value, interpreter.ExecStack.Count);

      for (var i = 0; i < count; i++) {
        if (skipNoopsCheckBox.Checked) {
          bool noop;

          do {
            noop = !interpreter.Step();
          }
          while (interpreter.CanStep && noop);
        } else interpreter.Step();
      }

      stepWidthBox.Maximum = interpreter.ExecStack.Count;

      SyncExecList();
      UpdateValueLists();
      CheckIfButtonsCanBeEnabled();
    }

    private void CheckIfButtonsCanBeEnabled() {
      if (interpreter == null)
        return;

      runButton.Enabled = interpreter.CanStep;
      stepButton.Enabled = interpreter.CanStep;
      stepWidthBox.Enabled = interpreter.CanStep;
    }

    private void ResetButtonClick(object sender, System.EventArgs e) {
      Reset();
    }

    private void SelectedExampleIndexChanged(object sender, System.EventArgs e) {
      Reset();
    }

    public new PushSolution Content
    {
      get { return (PushSolution)base.Content; }
      set
      {
        base.Content = value;
      }
    }

    private void Reset() {
      if (Content == null ||
        interpreter == null ||
        this.exampleComboBox.SelectedIndex < 0)
        return;

      interpreter.Clear();

      var example = Content.Data.Examples[this.exampleComboBox.SelectedIndex];

      interpreter.BooleanStack.Push(example.InputBoolean);
      interpreter.IntegerStack.Push(example.InputInt);
      interpreter.FloatStack.Push(example.InputFloat);

      interpreter.Run(program, true);
      stepWidthBox.Maximum = interpreter.ExecStack.Count;

      UpdateValueLists();
      UpdateExecList();
      CheckIfButtonsCanBeEnabled();
    }

    protected override void OnContentChanged() {
      if (Content == null) return;

      this.nameTextBox.Text = "Push Solution";

      var random = Content.Random ?? new FastRandom();
      interpreter = new PushInterpreter(Content.Config, random);
      program = Content.IntegerVector.MapToPushProgram(Content.Config.EnabledExpressions);

      UpdateExamples(Content.Data);
      InitResultGrid();

      if (this.exampleComboBox.SelectedIndex < 0) {
        this.exampleComboBox.SelectedIndex = 0; // Triggers Reset via event
      } else {
        Reset();
      }
    }

    private void InitResultGrid() {
      var cellTemplate = new DataGridViewTextBoxCell();

      for (var i = 0; i < Content.Data.InputArgumentTypes.Length; i++) {
        var headerTypeName = ViewHelper.GetHeaderTypeName(Content.Data.InputArgumentTypes[i]);
        var column = new DataGridViewColumn {
          HeaderText = string.Format("Input {0} : {1}", i + 1, headerTypeName),
          AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill,
          CellTemplate = cellTemplate
        };

        resultsDataGrid.Columns.Add(column);
      }

      for (var i = 0; i < Content.Data.OutputArgumentTypes.Length; i++) {
        var headerTypeName = ViewHelper.GetHeaderTypeName(Content.Data.OutputArgumentTypes[i]);

        var estimatedOutputColumn = new DataGridViewColumn {
          HeaderText = string.Format("Estimated Output {0} : {1}", i + 1, headerTypeName),
          AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill,
          CellTemplate = cellTemplate
        };

        var outputColumn = new DataGridViewColumn {
          HeaderText = string.Format("Output {0} : {1}", i + 1, headerTypeName),
          AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill,
          CellTemplate = cellTemplate
        };

        resultsDataGrid.Columns.Add(estimatedOutputColumn);
        resultsDataGrid.Columns.Add(outputColumn);
      }

      resultsDataGrid.Columns.Add(
        new DataGridViewColumn {
          HeaderText = "Absolute Diff.",
          AutoSizeMode = DataGridViewAutoSizeColumnMode.ColumnHeader,
          CellTemplate = cellTemplate
        });

      resultsDataGrid.Columns.Add(
        new DataGridViewColumn {
          HeaderText = "Relative Diff.",
          AutoSizeMode = DataGridViewAutoSizeColumnMode.ColumnHeader,
          CellTemplate = cellTemplate,
        });

      var pool = new PushInterpreterPool(Content.Config);
      var program = Content.IntegerVector.MapToPushProgram(Content.Config.EnabledExpressions);

      using (var pushInterpreter = pool.Create(Content.Random)) {
        foreach (var example in Content.Data.Examples) {
          var row = new DataGridViewRow();
          var absoluteDiff = PushEvaluator.Evaluate(pushInterpreter, program, example, Content.Data.WorstResult);
          var relativeDiff = absoluteDiff / Math.Abs(Content.Data.BestResult - Content.Data.WorstResult) * 100d;

          row.HeaderCell.Value = row.Index + 1;
          row.CreateCells(resultsDataGrid);

          for (var i = 0; i < Content.Data.InputArgumentTypes.Length; i++) {
            row.Cells[i].Value = ViewHelper.StringifyInput(Content.Data.InputArgumentTypes[i], example, Separator);
          }

          for (var i = 0; i < Content.Data.OutputArgumentTypes.Length; i++) {
            row.Cells[Content.Data.InputArgumentTypes.Length + i * 2].Value = ViewHelper.StringifyOutput(Content.Data.OutputArgumentTypes[i], example, Separator);
            row.Cells[Content.Data.InputArgumentTypes.Length + i * 2 + 1].Value = StringifyResult(Content.Data.OutputArgumentTypes[i], pushInterpreter, example, Separator);
          }

          row.Cells[Content.Data.TotalArgumentCount + 1].Value = absoluteDiff;
          row.Cells[Content.Data.TotalArgumentCount + 2].Value = relativeDiff + "%";

          this.resultsDataGrid.Rows.Add(row);
          pushInterpreter.Clear();
        }
      }
    }

    private string StringifyResult(ExampleArgumentType type, IPushInterpreter interpreter, Example example, string valueSeparator) {
      switch (type) {
        case ExampleArgumentType.Integer:
        case ExampleArgumentType.IntegerCollection: return interpreter.IntegerStack.IsEmpty ? EmptySign : string.Join(valueSeparator, interpreter.IntegerStack.Peek(GetCount(interpreter.IntegerStack, example.OutputInt)));

        case ExampleArgumentType.Float:
        case ExampleArgumentType.FloatCollection: return interpreter.FloatStack.IsEmpty ? EmptySign : string.Join(valueSeparator, interpreter.FloatStack.Peek(GetCount(interpreter.FloatStack, example.OutputFloat)));

        case ExampleArgumentType.Bool: return interpreter.BooleanStack.IsEmpty ? EmptySign : interpreter.BooleanStack.Top.ToString();
        case ExampleArgumentType.Char: return interpreter.CharStack.IsEmpty ? EmptySign : interpreter.CharStack.Top.ToString();

        case ExampleArgumentType.String:
        case ExampleArgumentType.StringCollection: return interpreter.StringStack.IsEmpty ? EmptySign : string.Join(valueSeparator, interpreter.StringStack.Peek(GetCount(interpreter.StringStack, example.OutputString)));
        default: return string.Empty;
      }
    }

    private int GetCount<T>(IStack<T> stack, T[] data) {
      return Math.Max(0, Math.Min(data.Length, stack.Count));
    }

    private void ClearLists() {
      codeList.Items.Clear();
      nameList.Items.Clear();
      booleanList.Items.Clear();
      integerList.Items.Clear();
      floatList.Items.Clear();
    }

    private void UpdateExecList() {
      UpdateListCache(0, execList.VirtualListSize);
      execList.Update();

      this.execGroupBox.Text = string.Format("Exec [{0}]", this.execList.Items.Count);
    }

    private void UpdateValueLists() {
      ClearLists();

      if (Content == null || interpreter == null)
        return;

      ManageStackType(interpreter.Configuration.IsCodeStackEnabled, codeList, codeGroupBox, interpreter.CodeStack, "Code");
      ManageStackType(interpreter.Configuration.IsIntegerStackEnabled, integerList, integerGroupBox, interpreter.IntegerStack, "Integer");
      ManageStackType(interpreter.Configuration.IsFloatStackEnabled, floatList, floatGroupBox, interpreter.FloatStack, "Float");
      ManageStackType(interpreter.Configuration.IsBooleanStackEnabled, booleanList, booleanGroupBox, interpreter.BooleanStack, "Boolean");
      ManageStackType(interpreter.Configuration.IsNameStackEnabled, nameList, nameGroupBox, interpreter.NameStack, "Name");
      ManageStackType(interpreter.Configuration.IsStringStackEnabled, stringList, stringGroupBox, interpreter.StringStack, "String");
      ManageStackType(interpreter.Configuration.IsCharStackEnabled, charList, charGroupBox, interpreter.CharStack, "Char");
    }

    private void ManageStackType<T>(bool enabled, ListBox listbox, GroupBox groupBox, IStack<T> stack, string name) {
      if (enabled) {
        listbox.Enabled = true;

        foreach (var item in stack.Reverse())
          listbox.Items.Add(item);

        groupBox.Text = string.Format("{0} [{1}]", name, listbox.Items.Count);
      } else {
        listbox.Enabled = false;
        groupBox.Text = string.Format("{0} - DISABLED", name);
      }
    }

    private void UpdateExamples(Data data) {
      if (data == null) return;

      var stringRepresentations = data.Examples.Select(e =>
        string.Join(Separator, e.InputArgs) +
        exampleSplitter +
        string.Join(Separator, e.OutputArgs));

      exampleComboBox.Items.Clear();
      foreach (var str in stringRepresentations) {
        exampleComboBox.Items.Add(str);
      }
    }
  }
}