///////////////////////////////////////////////////////////////////////////////
//
///////////////////////////////////////////////////////////////////////////////
#include "TFile.h"
#include "TTree.h"
#include "TBranch.h"

#include "CompModel/TDiskStorageModel.hh"

ClassImp(TDiskStorageModel)

namespace {
//
//                          stage  stage
//                            I     II
  int   kYearAcquired [] = { 2002, 2002, 2003, 2004,  2005,  2006,  2007, 2008, 2009, 2010, -1} ;
  int   kNAcquired    [] = {   16,   76,   26,   10,    26,    17,    16,   10,    0,    0, -1} ;
  float kSizeAcquired [] = { 1.92,  2.1,  5.1,  7.0,   14.,    10,    35,   56,    0,    0, -1} ;

  int   kYearAcquired2 [] = { 2002, 2002, 2003, 2004,  2005,  2006,  2007, 2008, 2009, 2010, -1} ;
  int   kNAcquired2    [] = {   16,   76,   26,   10,    26,    17,    19,   11,    0,    0, -1} ;
  float kSizeAcquired2 [] = { 1.92,  2.1,  5.1,  7.0,   14.,    10,    35,   56,   -1,    0, -1} ;

  int   kYearRetired [] = {   2006,  2006,  2007,  2008,  2009,  -1} ;
  int   kNRetired    [] = {     16,    76,    26,    10,   26,   -1} ;
  float kSizeRetired [] = {   1.92,   2.1,   5.1,   7.0,   14.,  -1} ;

  int   kYearRetired2 [] = {   2006,  2006,  2007, 2007, 2008,  2009,  -1} ;
  int   kNRetired2    [] = {     16,    10,    66,   26,    0,     0,  -1} ;
  float kSizeRetired2 [] = {   1.92,   2.1,   2.1,  5.1,    0,     0,  -1} ;

  int   kYear          [] = { 2002, 2003,  2004,  2005,  2006,  2007, 2008, 2009, 2010,  -1} ;
  float kUnitSize      [] = { 2.10, 5.10,  7.00,  14.0,  10.0,  35.0, 56.0,  56,    56,  -1} ;
  float kUnitCost      [] = {  20.,  20.,    20,  20.0,  15.0,  20.0, 20.0,  20.,   20., -1} ;
  float kEstimatedSize [] = {       180.,  320.,  490.,  710.,   -1.,  -1.,  -1.,   -1., -1} ;
};

//_____________________________________________________________________________
TDiskStorageModel::TDiskStorageModel() {
  fRetirementPolicy = 1;
}

//_____________________________________________________________________________
TDiskStorageModel::~TDiskStorageModel() {
}

//_____________________________________________________________________________
float TDiskStorageModel::UnitCost(int Year) {
  // in $10^3

  int   loc;
  float cost;

  loc  = Year-kYear[0];
  cost = kUnitCost[loc];

  return cost;
}

//_____________________________________________________________________________
float TDiskStorageModel::UnitSize(int Year) {
  // in $10^3

  int   loc;
  float sz;

  loc = Year-kYear[0];
  sz  = kUnitSize[loc];

  return sz;
}

//_____________________________________________________________________________
int TDiskStorageModel::AcquiredUnits(int Year) {
  // in $10^3

  int   loc, n(0);
  float sz;

  for (int i=0; kYearAcquired[i] >= 0; i++) {
    if (kYearAcquired[i] == Year) {
      n += kNAcquired[i];
    }
  }

  return n;
}

//_____________________________________________________________________________
float TDiskStorageModel::NServers(int Year) {
  // assume aquisition in the end of FY, in TBytes

  float n_drives(0);

  for (int i=0; (kNAcquired[i] >= 0) && (kYearAcquired[i] < Year); i++) {
   n_drives += kNAcquired[i] ;
  }
  
  for (int i=0; (kNRetired[i] >= 0) && (kYearRetired[i] <= Year); i++) {

    if (fRetirementPolicy == 1) {
      n_drives -= kNRetired[i];
    }
    else {
      n_drives -= kNRetired2[i];
    }
  }
  
  return n_drives;
}

//_____________________________________________________________________________
float TDiskStorageModel::AcquisitionCost(int Year) {
  float x(0), dx;

  for (int i=0; kYearAcquired[i] >= 0; i++) {
    if (kYearAcquired[i] == Year) {
      dx = kNAcquired[i]*kUnitCost[i];
      x += dx;
    }
  }

  return x;
}


//_____________________________________________________________________________
float TDiskStorageModel::VolumeToBuy(int Year) {
  float vol;

  vol = TotalVolume(Year+1)-TotalVolume(Year)+RetiredVolume(Year);

  return vol;
}


//_____________________________________________________________________________
float TDiskStorageModel::AcquiredVolume(int Year) {
  float x(0), dx;

  if (fRetirementPolicy == 1) {
    for (int i=0; kYearAcquired[i] >= 0; i++) {
      if (kYearAcquired[i] == Year) {
	dx = kNAcquired[i]*kSizeAcquired[i];
	if ( kYearAcquired[i] < 2005) dx *= 7/8.;
	x += dx;
      }
    }
  }
  else if (fRetirementPolicy == 2) {
    for (int i=0; kYearAcquired2[i] >= 0; i++) {
      if (kYearAcquired2[i] == Year) {
	dx = kNAcquired2[i]*kSizeAcquired2[i];
	if ( kYearAcquired2[i] < 2005) dx *= 7/8.;
	x += dx;
      }
    }
  }

  return x;
}


//_____________________________________________________________________________
float TDiskStorageModel::RetiredVolume(int Year) {
  float x(0), dx;

  if (fRetirementPolicy == 1) {
    for (int i=0; kYearRetired[i] >= 0; i++) {
      if (kYearRetired[i] == Year) {
	dx = kNRetired[i]*kSizeRetired[i];
	x += dx*7/8.;
      }
    }
  }
  else if (fRetirementPolicy == 2) {
    for (int i=0; kYearRetired2[i] >= 0; i++) {
      if (kYearRetired2[i] == Year) {
	dx = kNRetired2[i]*kSizeRetired2[i];
	x += dx*7/8.;
      }
    }
  }

  return x;
}


//_____________________________________________________________________________
float TDiskStorageModel::TotalVolume(int Year) {
  // assume aquisition in the end of FY , in TBytes
  // account for RAID'ing (7./8.) is incorrect....
  // fudge to agree with the previous years

  float vol(0);

  for (int year=2002; year < Year; year++) {
    vol += AcquiredVolume(year);
  }

  for (int year=2002; year < Year; year++) {
    vol -= RetiredVolume(year);
  }
  
  return vol;
}

//_____________________________________________________________________________
int TDiskStorageModel::PlotHist(const char* Name) {
  
  float x;

  TString name = Name;

  name.ToUpper();

//   if (name == "EVENT_SIZE") {

//     fHist = new TH1F("event_size","event size, KBytes",8,2001.5,2009.5);
//     fHist->SetMinimum(0);
//     fHist->GetXaxis()->SetTitle("Year");

//     for (int year=2002; year<2010; year++) {

//       x = L3EventSize(year);
//       fHist->Fill(year,x);
//     }


//     fHist->SetMarkerSize(1);
//     fHist->SetMarkerStyle(20);
//     fHist->Draw("p");
//   }

  return 0;
}