source: branches/HiveProjectManagement/HeuristicLab.Clients.Hive.JobManager/3.3/Views/HiveResourceSelector.cs @ 15412

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2017 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Windows.Forms;
using HeuristicLab.Collections;
using HeuristicLab.Common.Resources;
using HeuristicLab.Core;
using HeuristicLab.Core.Views;
using HeuristicLab.MainForm;
using HeuristicLab.MainForm.WindowsForms;

namespace HeuristicLab.Clients.Hive.JobManager.Views {
  [View("Hive Project Selector View")]
  [Content(typeof(IItemList<Project>), true)]
  public partial class HiveProjectSelector : ItemView, IDisposable {
    private const int greenFlagImageIndex = 0;
    private const int redFlagImageIndex = 1;
    private const int slaveImageIndex = 0;
    private const int slaveGroupImageIndex = 1;

    private readonly ISet<TreeNode> mainTreeNodes = new HashSet<TreeNode>();
    private readonly ISet<TreeNode> filteredTreeNodes = new HashSet<TreeNode>();
    private readonly ISet<TreeNode> nodeStore = new HashSet<TreeNode>();
    private readonly ISet<Resource> resources = new HashSet<Resource>();

    private string currentSearchString;

    private Project selectedProject;
    public Project SelectedProject {
      get { return selectedProject; }
      set {
        if (selectedProject == value) return;
        selectedProject = value;
        UpdateResources();
        OnSelectedProjectChanged();
      }
    }

    private readonly IObservableSet<Resource> selectedResources = new ObservableSet<Resource>();
    public IEnumerable<Resource> SelectedResources { get { return selectedResources; } }

    public new IItemList<Project> Content {
      get { return (IItemList<Project>)base.Content; }
      set { base.Content = value; }
    }

    public HiveProjectSelector() {
      InitializeComponent();

      projectsImageList.Images.Add(VSImageLibrary.FlagGreen);
      projectsImageList.Images.Add(VSImageLibrary.FlagRed);
      resourcesImageList.Images.Add(VSImageLibrary.MonitorLarge);
      resourcesImageList.Images.Add(VSImageLibrary.NetworkCenterLarge);
    }

    #region Overrides
    protected override void OnContentChanged() {
      base.OnContentChanged();

      if (Content != null) {
        UpdateMainTree();
        ExtractStatistics();
      } else {
        mainTreeNodes.Clear();
        UpdateFilteredTree();
      }

      SelectedProject = null;
    }
    #endregion

    #region Event Handlers
    private void HiveProjectSelector_Load(object sender, EventArgs e) {
      projectsTreeView.Nodes.Clear();
      resourcesTreeView.Nodes.Clear();
      SelectedProject = null;
    }

    private void searchTextBox_TextChanged(object sender, EventArgs e) {
      currentSearchString = searchTextBox.Text.ToLower();
      UpdateFilteredTree();
    }

    private void projectsTreeView_MouseDoubleClick(object sender, MouseEventArgs e) {
      OnProjectsTreeViewDoubleClicked();
    }

    private void projectsTreeView_MouseDown(object sender, MouseEventArgs e) {
      var node = projectsTreeView.GetNodeAt(new Point(e.X, e.Y));

      SelectedProject = (Project)node?.Tag;

      if (node == null) {
        projectsTreeView.SelectedNode = null;
      }

      ExtractStatistics();
    }

    private void resourcesTreeView_MouseDown(object sender, MouseEventArgs e) {
      var node = resourcesTreeView.GetNodeAt(new Point(e.X, e.Y));

      if (node == null) {
        resourcesTreeView.SelectedNode = null;
      }

      ExtractStatistics((Resource)node?.Tag);
    }

    private void resourcesTreeView_AfterCheck(object sender, TreeViewEventArgs e) {
      var resource = (Resource)e.Node.Tag;

      if (e.Node.Checked)
        selectedResources.Add(resource);
      else
        selectedResources.Remove(resource);

      ExtractStatistics((Resource)resourcesTreeView.SelectedNode?.Tag);
      OnSelectedResourcesChanged();
    }
    #endregion

    #region Helpers
    private void UpdateMainTree() {
      mainTreeNodes.Clear();

      foreach (Project g in Content.OrderBy(x => x.Name)) {
        if (g.ParentProjectId == null) {
          TreeNode tn = new TreeNode();
          tn.ImageIndex = greenFlagImageIndex;
          tn.SelectedImageIndex = tn.ImageIndex;

          tn.Tag = g;
          tn.Text = g.Name;
          tn.Checked = selectedResources.Any(x => x.Id == g.Id);

          BuildMainTree(tn);
          mainTreeNodes.Add(tn);
        }
      }
      UpdateFilteredTree();
    }

    private void BuildMainTree(TreeNode tn) {
      foreach (Project r in Content.Where(s => s.ParentProjectId != null && s.ParentProjectId == ((Project)tn.Tag).Id).OrderBy(x => x.Name)) {
        TreeNode stn = new TreeNode(r.Name);
        stn.ImageIndex = redFlagImageIndex;
        stn.SelectedImageIndex = stn.ImageIndex;
        stn.Tag = r;
        stn.Checked = selectedResources.Any(x => x.Id == r.Id);
        tn.Nodes.Add(stn);
        mainTreeNodes.Add(stn);

        BuildMainTree(stn);
      }
    }

    private void UpdateFilteredTree() {
      filteredTreeNodes.Clear();
      foreach (TreeNode n in mainTreeNodes) {
        n.BackColor = SystemColors.Window;
        if (currentSearchString == null || ((Project)n.Tag).Name.ToLower().Contains(currentSearchString)) {
          n.BackColor = string.IsNullOrEmpty(currentSearchString) ? SystemColors.Window : Color.LightBlue;
          filteredTreeNodes.Add(n);
          TraverseParentNodes(n);
        }
      }
      UpdateProjectsTree();
    }

    private void UpdateProjectsTree() {
      projectsTreeView.Nodes.Clear();
      nodeStore.Clear();

      foreach (TreeNode node in filteredTreeNodes) {
        var clone = nodeStore.SingleOrDefault(x => ((Project)x.Tag).Id == ((Project)node.Tag).Id);
        if (clone == null) {
          clone = (TreeNode)node.Clone();
          nodeStore.Add(clone);
          clone.Nodes.Clear();
        }
        foreach (TreeNode child in node.Nodes)
          if (filteredTreeNodes.Any(x => ((Project)x.Tag).Id == ((Project)child.Tag).Id)) {
            var childClone = nodeStore.SingleOrDefault(x => ((Project)x.Tag).Id == ((Project)child.Tag).Id);
            if (childClone == null) {
              childClone = (TreeNode)child.Clone();
              nodeStore.Add(childClone);
              childClone.Nodes.Clear();
            }
            clone.Nodes.Add(childClone);
          }
      }
      projectsTreeView.Nodes.AddRange(nodeStore.Where(x => ((Project)x.Tag).ParentProjectId == null).ToArray());
      if (string.IsNullOrEmpty(currentSearchString)) ExpandSlaveGroupNodes();
      else projectsTreeView.ExpandAll();
    }

    private void TraverseParentNodes(TreeNode node) {
      if (node != null) {
        for (TreeNode parent = node.Parent; parent != null; parent = parent.Parent)
          filteredTreeNodes.Add(parent);
      }
    }

    private void UpdateResources() {
      selectedResources.Clear();

      if (selectedProject != null) {
        var assignedResources = HiveServiceLocator.Instance.CallHiveService(s => s.GetAssignedResourcesForProject(selectedProject.Id));
        var assignedResourceIds = new HashSet<Guid>(assignedResources.Select(x => x.ResourceId));

        foreach (var resource in HiveAdminClient.Instance.Resources) {
          if (assignedResourceIds.Contains(resource.Id)) {
            resources.Add(resource);
            selectedResources.Add(resource);
          }
        }
      }

      BuildResourceTree(selectedResources);
      ExtractStatistics();
      OnSelectedResourcesChanged();
    }

    private Resource BuildResourceTree(IEnumerable<Resource> resources) {
      resourcesTreeView.Nodes.Clear();
      if (!resources.Any()) return null;

      var mainResources = new HashSet<Resource>(resources.Where(x => x.ParentResourceId == null));
      var subResources = new HashSet<Resource>(resources.Except(mainResources));

      var stack = new Stack<Resource>(mainResources.OrderByDescending(x => x.Name));
      var top = stack.Peek();

      TreeNode currentNode = null;
      Resource currentResource = null;

      while (stack.Any()) {
        var newResource = stack.Pop();
        var newNode = new TreeNode(newResource.Name) {
          Checked = true,
          ImageIndex = newResource is Slave ? slaveImageIndex : slaveGroupImageIndex,
          Tag = newResource
        };

        while (currentNode != null && newResource.ParentResourceId != currentResource.Id) {
          currentNode = currentNode.Parent;
          currentResource = currentNode == null ? null : (Resource)currentNode.Tag;
        }

        if (currentNode == null) {
          resourcesTreeView.Nodes.Add(newNode);
        } else {
          currentNode.Nodes.Add(newNode);
        }

        newNode.SelectedImageIndex = newNode.ImageIndex;

        var childResources = subResources.Where(x => x.ParentResourceId == newResource.Id);
        if (childResources.Any()) {
          foreach (var resource in childResources.OrderByDescending(x => x.Name)) {
            subResources.Remove(resource);
            stack.Push(resource);
          }
          currentNode = newNode;
          currentResource = newResource;
        }
      }

      resourcesTreeView.ExpandAll();

      return top;
    }

    private void ExpandSlaveGroupNodes() {
      foreach (TreeNode n in nodeStore.Where(x => x.Tag is SlaveGroup)) {
        TreeNode[] children = new TreeNode[n.Nodes.Count];
        n.Nodes.CopyTo(children, 0);
        if (children.Any(x => x.Tag is SlaveGroup)) n.Expand();
      }
    }

    private void ExtractStatistics(Resource resource = null) {
      ISet<Slave> selectedSlaves = null;

      if (resource != null) {
        var slaveGroup = resource as SlaveGroup;
        if (slaveGroup != null) {
          var children = new HashSet<Resource>(resources.Where(x => x.ParentResourceId == slaveGroup.Id));
          int nrOfChildren = children.Count;
          do {
            var newChildren = resources.Where(x => children.Any(y => y.Id == x.ParentResourceId));
            foreach (var newChild in newChildren)
              children.Add(newChild);
          } while (children.Count > nrOfChildren);
          selectedSlaves = new HashSet<Slave>(children.OfType<Slave>());
          selectedSlaves.IntersectWith(selectedResources.OfType<Slave>());
        } else {
          selectedSlaves = new HashSet<Slave>(new[] { resource as Slave });
        }
      } else {
        selectedSlaves = new HashSet<Slave>(selectedResources.OfType<Slave>());
      }

      int sumCores = selectedSlaves.OfType<Slave>().Sum(x => x.Cores.GetValueOrDefault());
      int sumFreeCores = selectedSlaves.OfType<Slave>().Sum(x => x.FreeCores.GetValueOrDefault());
      double sumMemory = selectedSlaves.OfType<Slave>().Sum(x => x.Memory.GetValueOrDefault()) / 1024.0;
      double sumFreeMemory = selectedSlaves.OfType<Slave>().Sum(x => x.FreeMemory.GetValueOrDefault()) / 1024.0;

      coresSummaryLabel.Text = $"{sumCores} Total ({sumFreeCores} Free / {sumCores - sumFreeCores} Used)";
      memorySummaryLabel.Text = $"{sumMemory:0.00} GB Total ({sumFreeMemory:0.00} GB Free / {(sumMemory - sumFreeMemory):0.00} GB Used)";
    }
    #endregion

    #region Events
    public event EventHandler SelectedProjectChanged;
    private void OnSelectedProjectChanged() {
      SelectedProjectChanged?.Invoke(this, EventArgs.Empty);
    }

    public event EventHandler SelectedResourcesChanged;
    private void OnSelectedResourcesChanged() {
      SelectedResourcesChanged?.Invoke(this, EventArgs.Empty);
    }

    public event EventHandler ProjectsTreeViewDoubleClicked;
    private void OnProjectsTreeViewDoubleClicked() {
      ProjectsTreeViewDoubleClicked?.Invoke(this, EventArgs.Empty);
    }
    #endregion
  }
}