using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using HeuristicLab.PDPSimulation.DomainModel;
using HeuristicLab.Core;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.Common;

namespace HeuristicLab.PDPSimulation {
  [StorableClass]
  public class VehicleHistory: Item {
    [Storable]
    public string VehicleName { get; private set; }
    [Storable]
    public List<VehicleState> VehicleState { get; private set; }
    [Storable]
    public List<int> VehicleAvailability { get; private set; }
    [Storable]
    public List<string> AvailabilityInformation { get; private set; }
    [Storable]
    public List<Order> ActiveOrders { get; private set; }
    [Storable]
    public List<Order> AssignedOrders { get; private set; }

    public VehicleHistory(string vehicleName) {
      VehicleName = vehicleName;
      VehicleState = new List<VehicleState>();
      VehicleAvailability = new List<int>();
      AvailabilityInformation = new List<string>();
      ActiveOrders = new List<Order>();
      AssignedOrders = new List<Order>();
    }
     [StorableConstructor]
    private VehicleHistory(bool deserializing) : base(deserializing) {
    }
     private VehicleHistory(VehicleHistory original, Cloner cloner)
      : base(original, cloner) {
        VehicleName = original.VehicleName;
        VehicleState = new List<VehicleState>(original.VehicleState);
        AvailabilityInformation = new List<string>(original.AvailabilityInformation);
        ActiveOrders = new List<Order>();
        foreach (Order order in original.ActiveOrders)
          ActiveOrders.Add(cloner.Clone<Order>(order));
        AssignedOrders = new List<Order>();
        foreach (Order order in original.AssignedOrders)
          AssignedOrders.Add(cloner.Clone<Order>(order));
        VehicleAvailability = new List<int>();
        VehicleAvailability.AddRange(original.VehicleAvailability);
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new VehicleHistory(this, cloner);
    }
  }

  [StorableClass]
  public class VehicleHistoryVisualization: Item {
    [Storable]
    public double ResultCollectionInterval { get; set; }
    
    [Storable]
    public List<VehicleHistory> VehicleHistory { get; private set; }

    public VehicleHistoryVisualization() {
      VehicleHistory = new List<VehicleHistory>();
      ResultCollectionInterval = 1.0;
    }
    [StorableConstructor]
    protected VehicleHistoryVisualization(bool deserializing) : base(deserializing) {
    }
    protected VehicleHistoryVisualization(VehicleHistoryVisualization original, Cloner cloner)
      : base(original, cloner) {
        VehicleHistory = new List<VehicleHistory>();
        foreach (VehicleHistory history in original.VehicleHistory) {
          VehicleHistory.Add(cloner.Clone<VehicleHistory>(history));
        } 
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new VehicleHistoryVisualization(this, cloner);
    }
    public event EventHandler ContentChanged;
    private void OnContentChanged() {
      var changed = ContentChanged;
      if (changed != null)
        changed(this, EventArgs.Empty);
    }

    public void Refresh() {
      OnContentChanged();
    }
  }
}