#include <stdio.h>

#define COUNT 10

int access_capacity[COUNT];
int backbone_capacity[COUNT][COUNT];
int node_iw[COUNT];
int node_noloss[COUNT];

void fill_initial(int iw, int lac, int hac, int lbc, int hbc) {
  int i, j;
  for(i=0; i<COUNT; i++) {
    node_iw[i] = iw;
    node_noloss[i] = 0;
    access_capacity[i] = rand() % (hac-lac) + lac;
    for(j=0;j<COUNT;j++) {
      backbone_capacity[i][j] = rand() % (hbc-lbc) + lbc;
    }
  }
}

void iterate(int adjust, int loss_thresh, int *rloss, int *rheadroom, int *riw) {
  // return the loss on the connection
  int i,j;
  int iw;
  int mincap;
  int loss;
  int headroom;

  i = rand() % COUNT;
  j = rand() % COUNT;

  iw = node_iw[j] < node_iw[i] ? node_iw[j] : node_iw[i];

  *riw = iw;
  printf("Connection from between %d[iw %d, cap %d] and %d[iw %d, cap %d], resulting iw = %d, backbone cap: %d\n",
       i, node_iw[i], access_capacity[i],
       j, node_iw[j], access_capacity[j],
       iw, backbone_capacity[i][j] );

  // calculate the min capacity = min of two access and backbone

  mincap = backbone_capacity[i][j];
  if (mincap > access_capacity[i]) { mincap = access_capacity[i]; }
  if (mincap > access_capacity[j]) { mincap = access_capacity[j]; }

  // loss occurs if iw is bigger than a minimum capacity.
  loss = iw > mincap ? iw - mincap : 0;
  // headroom is a measure of inefficiency - how much did we undershoot the capacity of the path
  headroom = iw < mincap ? mincap - iw : 0;

  if (adjust) {
    if (loss) {
      node_noloss[i] = node_noloss[j] = 0; 
   
      if (node_iw[i] < node_iw[j]) {
	// node_iw[i] /= 2;
	// if(node_iw[j] > 2) { node_iw[j] -= 1; }
	if(node_iw[i] > 2) { node_iw[i] -= 1; }
      } else {
	// node_iw[j] /= 2;
	// if(node_iw[i] > 2) { node_iw[i] -= 1; }
	if(node_iw[j] > 2) { node_iw[j] -= 1; }
      }
    } else {
      node_noloss[i]++;
      node_noloss[j]++;

      // no loss, can try incrementing the smaller side
      if (node_iw[i] < node_iw[j]) {
	if(node_noloss[i] > loss_thresh) { node_iw[i] += 1; }
      } else {
	if(node_noloss[j] > loss_thresh) { node_iw[j] += 1; }
      }
    }
  }

  printf("   result headroom: %d, loss: %d, new iw %d = %d, new iw %d = %d\n", 
	headroom, loss, 
	i, node_iw[i],
	j, node_iw[j]);

  *rloss = loss;
  *rheadroom = headroom;
}


int main(int argc, char **argv) {
  int i = 0;
  int loss, headroom;
  int iws;
  int closs, cheadroom;
  int ciw;
  int count = 100;
  if(argc < 8) {
    printf("usage: %d <initial window> <adjust: 1/0> <IW increment success threshold> <lower access cap> <higher access cap> <lower bb cap> <higher bb cap>\n");
    exit(0);
  }
  fill_initial(atoi(argv[1]), atoi(argv[4]), atoi(argv[5]), atoi(argv[6]), atoi(argv[7]));
  while(1) {
    iws = loss = headroom = 0;
    for(i=0;i<count;i++) {
      iterate(atoi(argv[2]), atoi(argv[3]), &closs, &cheadroom, &ciw);
      loss += closs;
      headroom += cheadroom;
      iws += ciw;
    }
    printf("Results from the round: loss: %d, headroom: %d, avg IW size: %f\n", loss, headroom, ((float)iws)/((float)count));
    
  }

}