source: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Views/PushDebuggerView.cs @ 14914

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Windows.Forms;

namespace HeuristicLab.Problems.ProgramSynthesis.Push.Views {
  using Configuration;
  using Core.Views;
  using Expressions;
  using Interpreter;
  using MainForm;
  using Problem;
  using Stack;

  public partial class PushDebuggerView : ItemView {
    private readonly IDictionary<StackTypes, ListBox> debugControlDict = new Dictionary<StackTypes, ListBox>();

    private PooledPushInterpreter interpreter;
    private PooledPushInterpreter interpreter2; // used to determine noops
    private PushInterpreterPool pool;

    private const string GroupBoxTextStringFormat = "{0}[{1}]";

    public event EventHandler<IPushInterpreter> OnReset;

    public PushDebuggerView() {
      InitializeComponent();
      InitEvents();
    }

    ~PushDebuggerView() {
      interpreter.Dispose();
      interpreter2.Dispose();
    }

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

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

      Name = "Push Debugger";
      pool = new PushInterpreterPool(Content.Config);

      if (interpreter != null) {
        interpreter.Dispose();
        interpreter2.Dispose();
      }

      interpreter = pool.Create(Content.Random);
      interpreter2 = pool.Create(Content.Random);


      InitDebugLists(Content.Config);
      ClearDebugLists();
      UpdateExecList();
      UpdateDebugLists();
      ResetDebugging();
    }

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

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

      interpreter.Resume();

      ResetDebugging();
      UpdateExecList();
      UpdateDebugLists();
      CheckIfButtonsCanBeEnabled();
    }

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

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

      if (!interpreter.CanStep)
        return;

      // skip leading noops
      if (interpreter2.ExecCounter == (Content.Program.IsProgram ? 1 : 0) &&
          skipNoopsCheckBox.Checked &&
          SkipNoops()) {
        count = 0; // no entries left, cause all were noops
      }

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

          if (SkipNoops())
            break;
        } else {
          interpreter.Step();
          interpreter2.Step();
        }
      }

      stepWidthBox.Maximum = Math.Max(1, interpreter.ExecStack.Count);

      UpdateExecList();
      UpdateDebugLists();
      CheckIfButtonsCanBeEnabled();
    }

    private bool SkipNoops() {
      var skipCount = 0;
      bool isNoop;

      do {
        skipCount++;
        isNoop = !interpreter2.Step();
      } while (interpreter2.CanStep && isNoop);

      if (isNoop) {
        interpreter.Step(skipCount);
      } else if (skipCount > 1) {
        interpreter.Step(skipCount - 1);
      }

      return isNoop;
    }

    private void CheckIfButtonsCanBeEnabled() {
      runButton.Enabled = interpreter != null && interpreter.CanStep;
      stepButton.Enabled = interpreter != null && interpreter.CanStep;
      stepWidthBox.Enabled = interpreter != null && interpreter.CanStep;
    }

    private void ResetButtonClick(object sender, EventArgs e) {
      ResetDebugging();
    }

    private void SimplifyButtonClick(object sender, EventArgs e) {
      var newContent = Content.Simplify();

      MainFormManager.MainForm.ShowContent(newContent, GetType());
    }

    public void ResetDebugging() {
      if (Content == null ||
          pool == null ||
          Content.Program == null)
        return;

      if (interpreter != null) {
        interpreter.Reset();
        interpreter2.Reset();
      }

      if (OnReset != null) {
        OnReset(this, interpreter);
        OnReset(this, interpreter2);
      }

      interpreter.Run(Content.Program, true);
      interpreter2.Run(Content.Program, true);

      stepWidthBox.Maximum = interpreter.ExecStack.Count;

      UpdateDebugLists();
      UpdateExecList();
      CheckIfButtonsCanBeEnabled();
    }

    private void ClearDebugLists() {
      foreach (var list in debugControlDict.Values) {
        list.Items.Clear();
      }
    }

    private void UpdateExecList() {
      execList.Items.Clear();
      var expressions = interpreter.ExecStack.AsEnumerable()
        .Reverse()
        .Select(e => e.StringRepresentation)
        .ToArray();

      execList.Items.AddRange(expressions);
      execGroupBox.Text = string.Format(GroupBoxTextStringFormat, Enum.GetName(typeof(StackTypes), StackTypes.Exec), interpreter.ExecStack.Count);
    }

    private void InitDebugLists(IReadOnlyPushConfiguration config) {
      debugControlDict.Clear();

      // 2 = ExecList + EmptyColumn which is required to fill empty space
      while (debugTableLayout.ColumnCount > 2) {
        debugTableLayout.Controls.RemoveAt(1);
        debugTableLayout.ColumnCount--;
      }

      foreach (StackTypes stackType in Enum.GetValues(typeof(StackTypes))) {
        if (stackType != StackTypes.Exec &&
            ExpressionTable.GetExpressionsByStackTypes(stackType).Intersect(config.EnabledExpressions).Any()) {
          var list = CreateDebugList(stackType);
          debugControlDict.Add(stackType, list);
        }
      }
    }

    private ListBox CreateDebugList(StackTypes type) {
      var groupBox = new GroupBox {
        Anchor = AnchorStyles.Bottom | AnchorStyles.Right | AnchorStyles.Left | AnchorStyles.Top,
        AutoSize = true,
        AutoSizeMode = AutoSizeMode.GrowAndShrink,
        Text = Enum.GetName(typeof(StackTypes), type)
      };

      var list = new ListBox {
        Dock = DockStyle.Fill,
        DrawMode = DrawMode.OwnerDrawFixed
      };

      // align numbers right
      var stackEntryType = type.GetStackEntryType();
      if (stackEntryType == typeof(double) ||
          stackEntryType == typeof(long)) {
        list.DrawItem += (sender, e) => {
          if (e.Index <= -1) return;
          var item = list.Items[e.Index];

          e.DrawBackground();
          e.DrawFocusRectangle();

          var brush = new SolidBrush(e.ForeColor);
          var size = e.Graphics.MeasureString(item.ToString(), e.Font);

          e.Graphics.DrawString(
            item.ToString(),
            e.Font,
            brush,
            e.Bounds.Right - size.Width,
            e.Bounds.Top + (e.Bounds.Height / 2 - size.Height / 2));
        };
      }

      groupBox.Controls.Add(list);

      var columnWidth = stackEntryType == typeof(Expression) ? 250 : 150;

      debugTableLayout.ColumnCount++;
      debugTableLayout.ColumnStyles.Insert(1, new ColumnStyle(SizeType.Absolute, columnWidth));
      debugTableLayout.Controls.Add(groupBox);
      debugTableLayout.Controls.SetChildIndex(groupBox, 1);

      return list;
    }


    private void UpdateDebugLists() {
      ClearDebugLists();

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

      foreach (var pair in debugControlDict) {
        var stack = interpreter.Stacks[pair.Key];
        var name = Enum.GetName(typeof(StackTypes), pair.Key);

        pair.Value.Items.AddRange(stack.AsObjects().Reverse().ToArray());
        ((GroupBox)pair.Value.Parent).Text = string.Format(GroupBoxTextStringFormat, name, pair.Value.Items.Count);
      }
    }

  }
}