using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using HeuristicLab.Services.Hive.DataAccess;
using HeuristicLab.Services.Hive;
using HeuristicLab.Services.Hive.Common.DataTransfer;
using System.Text;
using System.Web.UI.DataVisualization.Charting;

public partial class Status : System.Web.UI.Page {
  protected void Page_Load(object sender, EventArgs e) {
    var dao = ServiceLocator.Instance.HiveDao;
    var resourceName = Request.QueryString["resource"];
    IEnumerable<Guid> resourceIds;
    if (!string.IsNullOrEmpty(resourceName)) {
      var resId = dao.GetResources(x => x.Name == resourceName).Single().Id;
      resourceIds = dao.GetChildResources(resId).Select(x => x.Id).Union(new List<Guid> { resId });
      speedupChartHours.Visible = false;
      speedupChartMinutes.Visible = false;
    } else {
      resourceIds = dao.GetResources(x => true).Select(y => y.Id);
      speedupChartHours.Visible = true;
      speedupChartMinutes.Visible = true;
    }

    var onlineSlaves = dao.GetSlaves(x => (x.SlaveState == SlaveState.Calculating || x.SlaveState == SlaveState.Idle) && resourceIds.Contains(x.ResourceId));

    int currentlyAvailableCores = onlineSlaves.Sum(s => s.Cores.Value);
    int currentlyUsedCores = currentlyAvailableCores - onlineSlaves.Sum(s => s.FreeCores.Value);
    int currentlyJobsWaiting = ServiceLocator.Instance.HiveDao.GetJobs(x => x.State == JobState.Waiting).Count();

    this.availableCoresLabel.Text = currentlyAvailableCores.ToString();
    this.usedCoresLabel.Text = currentlyUsedCores.ToString();
    this.waitingJobsLabel.Text = currentlyJobsWaiting.ToString();

    slavesLabel.Text = string.Join(", ", onlineSlaves.Select(x => string.Format("<a href=\"?resource={0}\">{0}</a> ({1} %)", x.Name, Math.Round(x.CpuUtilization, 2))));

    cpuUtilizationLabel.Text = (onlineSlaves.Count() > 0 ? Math.Round(onlineSlaves.Average(s => s.CpuUtilization), 2).ToString() : "0.0") + " %";

    HeuristicLab.Services.Hive.Common.DataTransfer.Statistics[] stats;
    if (daysDropDownList.SelectedValue == "All")
      stats = dao.GetStatistics(x => true).OrderBy(x => x.TimeStamp).ToArray();
    else
      stats = dao.GetStatistics(x => x.Timestamp >= DateTime.Now.Subtract(TimeSpan.FromDays(int.Parse(daysDropDownList.SelectedValue)))).OrderBy(x => x.TimeStamp).ToArray();

    var firstStatisticsDate = DateTime.Parse("2011-05-24 17:16:40");
    var statisticsSince = DateTime.Now - firstStatisticsDate;
    if (stats.Length != 0) {
      totalExecutionTimeLabel.Text = new TimeSpan(stats.Last().UserStatistics.Sum(x => x.ExecutionTime.Ticks)).ToString() + " (since " + Math.Round(statisticsSince.TotalDays, 2) + " days)";
    } else {
      totalExecutionTimeLabel.Text = "00:00:00.00";
    }
    
    for (int i = 0; i < stats.Length; i++) {
      var s = stats[i];
      var slaveStats = s.SlaveStatistics.Where(x => resourceIds.Contains(x.SlaveId));

      var averageCpuUtilization = slaveStats.Count() > 0 ? slaveStats.Average(x => x.CpuUtilization) : 0.0;
      cpuUtilizationChart.Series[0].Points.Add(new DataPoint(s.TimeStamp.ToOADate(), averageCpuUtilization));

      var cores = slaveStats.Sum(x => x.Cores);

      var usedCores = cores - slaveStats.Sum(x => x.FreeCores);
      coresChart.Series[0].Points.AddXY(s.TimeStamp.ToOADate(), cores);
      coresChart.Series[1].Points.AddXY(s.TimeStamp.ToOADate(), usedCores);

      var memory = slaveStats.Sum(x => x.Memory);
      var usedMemory = memory - slaveStats.Sum(x => x.FreeMemory);
      memoryChart.Series[0].Points.AddXY(s.TimeStamp.ToOADate(), memory / 1024.0);
      memoryChart.Series[1].Points.AddXY(s.TimeStamp.ToOADate(), usedMemory / 1024.0);

      if (i > 0) {
        var execTime = new TimeSpan(s.UserStatistics.Sum(x => x.ExecutionTime.Ticks));
        var execTimePrev = new TimeSpan(stats[i - 1].UserStatistics.Sum(x => x.ExecutionTime.Ticks));
        var execTimeDifference = execTimePrev - execTime;

        var timeDifference = stats[i - 1].TimeStamp - s.TimeStamp; // the difference between statistic entries is not alway exactly 1 minute
        var speedup = execTimeDifference.TotalMinutes / timeDifference.TotalMinutes;
        speedupChartMinutes.Series[0].Points.AddXY(s.TimeStamp.ToOADate(), speedup);
        speedupChartMinutes.Series[1].Points.AddXY(s.TimeStamp.ToOADate(), cores);
      }
      if (i - 60 >= 0) {
        var execTime = new TimeSpan(s.UserStatistics.Sum(x => x.ExecutionTime.Ticks));
        var execTimePrev = new TimeSpan(stats[i - 60].UserStatistics.Sum(x => x.ExecutionTime.Ticks));
        var execTimeDifference = execTimePrev - execTime;

        var timeDifference = stats[i - 60].TimeStamp - s.TimeStamp; // the difference between statistic entries is not alway exactly 1 minute
        var speedup = execTimeDifference.TotalMinutes / timeDifference.TotalMinutes;
        speedupChartHours.Series[0].Points.AddXY(s.TimeStamp.ToOADate(), speedup);
        speedupChartHours.Series[1].Points.AddXY(s.TimeStamp.ToOADate(), cores);
      }
    }
  }

  protected void daysDropDownList_SelectedIndexChanged(object sender, EventArgs e) {

  }
}