#include <iostream>
#include <vector>
#include <math.h>

class env_Env {

  public:  
           enum TRAFFIC_TYPE { TT_UNIFORM, TT_DET_BURSTY, TT_RAND_BURSTY };
           enum BW_TYPE {  BW_UNIFORM, BW_DET_FADING, BW_RAND_FADING };

           env_Env( int users, int channels, double load, double rate, TRAFFIC_TYPE traffic_type, BW_TYPE bw_type);

           double rate( int i, int j ) { return currentRateMatrix[i][j]; };
           double occupancy( int i ) { return currentOccupancyVector[i]; };

           void tick( vector<int> schedule );
           void print();

           int numUsers;
           int numChannels;

  private: 

     double avgLoad;
     double avgRate;
   
     int cycle;

     TRAFFIC_TYPE tt;
     BW_TYPE bw;

     vector< vector<double> > currentRateMatrix;
     vector<double> currentOccupancyVector;
     int bernoulli( double avgLoad );
     void transmit( vector<int> schedule );
};


env_Env::env_Env( 
  int users,
  int channels,
  double load,
  double rate,
  TRAFFIC_TYPE traffic_type,
  BW_TYPE bw_type )
{
  cycle = 0;

  numUsers = users;
  numChannels = channels;

  avgLoad = load / (float) users;
  avgRate = rate;

  tt = traffic_type; 
  bw = bw_type; 

  for ( int i = 0 ; i < numUsers; i++ ) {

    currentOccupancyVector.push_back( 0.0 );

    currentRateMatrix.push_back( *( new vector<double> ) );
    for ( int j = 0 ; j < numChannels ; j++ ) {
      currentRateMatrix[i].push_back( 0.0 );
    }
  }

}


void env_Env::tick( vector<int> schedule )
{            

  transmit( schedule );

  for (int i = 0 ; i < numUsers; i++ ) {

    for ( int j = 0 ; j < numChannels ; j++ ) {

      if ( bw == BW_UNIFORM ) {
        currentRateMatrix[i][j] = bernoulli( avgRate );
      }
      else if ( bw ==  BW_DET_FADING ) {
        currentRateMatrix[i][j] = ( (double) ( ( cycle + 37 * i * i + 41 * j *j ) % 100 ) ) / 100.0  < avgRate ? 1 : 0;
      }
      else {
        currentRateMatrix[i][j] = avgRate * exp( ( ( (double) ( rand() % 100 ) ) / 100  ) * 5.0 ) / ( exp(5.0) - 1.0 );
      }
    }

    if ( tt == TT_UNIFORM ) {
      currentOccupancyVector[i] += (double) bernoulli( avgLoad );
    }
    else if ( tt ==  TT_DET_BURSTY ) {
      currentOccupancyVector[i] += ( (double) ( ( cycle + 41 * i * i  ) % 100 ) ) / 100.0  < avgLoad ? 1 : 0;
    }
    else {
      currentOccupancyVector[i] += avgLoad * exp( ( ( (double) ( rand() % 100 ) ) / 100.0  ) * 5.0 ) / ( exp(5.0) - 1.0 );
    }
  }

  cycle++;

}


int env_Env::bernoulli( double prob )
{
  double foo = (double) rand();
  double bar =  foo /(double) RAND_MAX ; 

  return ( bar  < prob ) ? 1 : 0;
}

           
void env_Env::transmit( vector<int> schedule )
{
  for (int j = 0; j < numChannels ; j++ ) {
    currentOccupancyVector[schedule[j]] -= currentRateMatrix[schedule[j]][j];
    if ( currentOccupancyVector[schedule[j]] < 0 ) { 
      currentOccupancyVector[schedule[j]] = 0; 
    }
  }
}


void 
env_Env::print()
{
  cout << "Current state:" << endl;
  for (int i = 0; i < numUsers ; i++ ) {
    cout << "User " << i << " Q length " <<  currentOccupancyVector[i] << endl;
  }
}


int main()
{
  int numCycles = 100;

  env_Env cells[3] = {  env_Env(4, 1, 0.49, 0.50, env_Env::TT_UNIFORM, env_Env::BW_UNIFORM ),
			env_Env(4, 1, 0.49, 0.50, env_Env::TT_DET_BURSTY, env_Env::BW_DET_FADING ),
			env_Env(4, 1, 0.49, 0.50, env_Env::TT_RAND_BURSTY, env_Env::BW_RAND_FADING ) } ;

  vector<int> schedule;
  schedule.push_back(0);

  for ( int h = 0 ; h < 3 ; h++ ) {
    cout << "\n\nIteration " << h << endl;
    for ( int i = 0; i < numCycles ; i++ ) {
      schedule[0] = 0;
      for ( int j = 0 ; j < cells[h].numUsers; j++ ) {
        // greedy scheduling
        if (  cells[h].occupancy( j ) > 0 &&
              ( cells[h].rate( j, 0) > cells[h].rate( schedule[0], 0 ) ) ) {
          schedule[0] = j;
        }
      }
      if ( !(i % 10) ) cells[h].print(); 
      cells[h].tick( schedule );
    }
  }
}