source: branches/3.3-HiveMigration/sources/HeuristicLab.Hive/HeuristicLab.Hive.Experiment/3.3/JobItem.cs @ 4264

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using HeuristicLab.Core;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.Hive.Contracts.BusinessObjects;
using HeuristicLab.Hive.Contracts;
using System.Drawing;
using HeuristicLab.Common;
using System.Diagnostics;
using HeuristicLab.Optimization;
using HeuristicLab.Hive.Contracts.ResponseObjects;

namespace HeuristicLab.Hive.Experiment {
  public enum SnapshotRequestedState { Idle, Requested }

  [StorableClass]
  public class JobItem : Item {
    private static object locker = new object();

    public override Image ItemImage {
      get {
        if (State == JobState.Offline) return HeuristicLab.Common.Resources.VS2008ImageLibrary.ExecutablePrepared;
        else if (State == JobState.Calculating) return HeuristicLab.Common.Resources.VS2008ImageLibrary.ExecutableStarted;
        else if (State == JobState.Aborted) return HeuristicLab.Common.Resources.VS2008ImageLibrary.ExecutableStopped;
        else if (State == JobState.Failed) return HeuristicLab.Common.Resources.VS2008ImageLibrary.Error;
        else if (State == JobState.Finished) return HeuristicLab.Common.Resources.VS2008ImageLibrary.ExecutableStopped;
        else return HeuristicLab.Common.Resources.VS2008ImageLibrary.Event;
      }
    }

    [Storable]
    private JobDto jobDto;
    /// <summary>
    /// Some static information about the job. Don't use State-Information out of there
    /// </summary>
    public JobDto JobDto {
      get { return jobDto; }
      set {
        if (jobDto != value) {
          jobDto = value;
          OnJobDtoChanged();
          OnToStringChanged();
          OnItemImageChanged();
        }
      }
    }

    [Storable]
    private JobResult jobResult;
    public JobResult JobResult {
      private get { return jobResult; }
      set {
        if (jobResult != value) {
          jobResult = value;
          OnJobStateChanged();
          OnToStringChanged();
          OnItemImageChanged();
        }
      }
    }

    public JobState State {
      get { return jobResult != null ? JobResult.State : JobDto.State; }
    }

    public double? Percentage {
      get { return jobResult != null ? JobResult.Percentage : JobDto.Percentage; }
    }

    public string Exception {
      get { return jobResult != null ? JobResult.Exception : JobDto.Exception; }
    }

    public DateTime? DateCalculated {
      get { return jobResult != null ? JobResult.DateCalculated : JobDto.DateCalculated; }
    }

    public DateTime? DateFinished {
      get { return jobResult != null ? JobResult.DateFinished : JobDto.DateFinished; }
    }
    
    [Storable]
    private ResponseObject<SerializedJob> latestSnapshot;
    public ResponseObject<SerializedJob> LatestSnapshot {
      get { return latestSnapshot; }
      set {
        if (latestSnapshot != value) {
          latestSnapshot = value;
          if (value != null) {
            latestSnapshotTime = DateTime.Now;
          }
          SnapshotRequestedState = Experiment.SnapshotRequestedState.Idle;
          OnLatestSnapshotChanged();
        }
      }
    }

    [Storable]
    private DateTime latestSnapshotTime;
    public DateTime LatestSnapshotTime {
      get { return latestSnapshotTime; }
    }

    [Storable]
    private ILog log;
    public ILog Log {
      get { return log; }
    }

    [Storable]
    private IOptimizer optimizer;
    public IOptimizer Optimizer {
      get { return optimizer; }
      set { this.optimizer = value; }
    }

    [Storable]
    private SnapshotRequestedState snapshotRequestedState;
    public SnapshotRequestedState SnapshotRequestedState {
      get { return snapshotRequestedState; }
      private set {
        this.snapshotRequestedState = value;
        OnSnapshotRequestedStateChanged();
      }
    }

    public JobItem() {
      log = new Log();
    }

    public override string ToString() {
      if (jobDto != null) {
        return optimizer.Name;
      } else {
        return base.ToString();
      }
    }

    public event EventHandler LatestSnapshotChanged;
    private void OnLatestSnapshotChanged() {
      LogMessage("LatestSnapshotChanged");
      EventHandler handler = LatestSnapshotChanged;
      if (handler != null) handler(this, EventArgs.Empty);
    }

    public event EventHandler JobDtoChanged;
    private void OnJobDtoChanged() {
      LogMessage("JobDtoChanged");
      EventHandler handler = JobDtoChanged;
      if (handler != null) handler(this, EventArgs.Empty);
    }

    public event EventHandler JobStateChanged;
    private void OnJobStateChanged() {
      LogMessage("JobStateChanged (State: " + this.State + ", Percentage: " + this.Percentage + ")");
      EventHandler handler = JobStateChanged;
      if (handler != null) handler(this, EventArgs.Empty);
    }

    public void LogMessage(string message) {
      lock (locker) {
        log.LogMessage(message);
      }
    }

    public override IDeepCloneable Clone(Cloner cloner) {
      LogMessage("I am beeing cloned");
      JobItem clone = (JobItem)base.Clone(cloner);
      clone.latestSnapshotTime = this.latestSnapshotTime;
      clone.jobDto = (JobDto)cloner.Clone(this.jobDto);
      clone.latestSnapshot = (ResponseObject<SerializedJob>)cloner.Clone(this.latestSnapshot);
      clone.log = (ILog)cloner.Clone(this.log);
      clone.optimizer = (IOptimizer)cloner.Clone(this.optimizer);
      clone.jobResult = (JobResult)cloner.Clone(this.jobResult);
      return clone;
    }


    public event EventHandler SnapshotRequestedStateChanged;
    private void OnSnapshotRequestedStateChanged() {
      EventHandler handler = SnapshotRequestedStateChanged;
      if (handler != null) handler(this, EventArgs.Empty);
    }

    public void RequestSnapshot() {
      this.SnapshotRequestedState = Experiment.SnapshotRequestedState.Requested;
    }


  }
}