#include <systemc.h>

#include "config.h"
#include "cross.h"
#include "print.h"
#include "source.h"

/***
 * NOTE : Les paramètres se trouvent dans le fichier "config.h"
 */

/*
 * Permet de cabler un étage d'un réseau butterfly
 *
 * stage : étage à cabler
 * gh : hauteur du groupe
 * dh : offset du groupe
 */
void cable_stage(cross *net[ETAGES][HEIGHT],
		 sc_buffer<sc_bv<BV_SIZE> > links[ETAGES][IO],
		 int stage,
		 int gh,
		 int dh)
{
  /* Pour chaque connexion, de manière symétrique */
  for(int i=dh;i<dh+gh;i++)
    {

      /* Cas pair : Connexion 0 */
      if ( i % 2 == 0 )
	{
	  printf("connecting... %d => %d\n", i, i);
	  net[stage][i/2]->out_0(links[stage][i]);
	  net[stage+1][i/2]->in_0(links[stage][i]);

	  printf("connecting... %d => %d\n", dh*2+(gh*2)-i-1, dh*2+(gh*2)-i-1);
	  net[stage][dh+gh-i/2-1]->out_1(links[stage][dh*2+(gh*2)-i-1]);
	  net[stage+1][dh+gh-i/2-1]->in_1(links[stage][dh*2+(gh*2)-i-1]);
	}
      /* Cas impair : Connexion 1 */
      else
	{
	  int dest_up = i + gh - 1;
	  int dest_down = ((gh*2)-i-1) - (gh - 1);

	  printf("connecting... %d => %d\n", i, dest_up);
	  net[stage][i/2]->out_1(links[stage][i]);

	  if ( dest_up % 2 == 0 )
	    net[stage+1][dest_up/2]->in_0(links[stage][i]);
	  else
	    net[stage+1][dest_up/2]->in_1(links[stage][i]);


	  printf("connecting... %d => %d\n", dh*2+(gh*2)-i-1, dh*2+dest_down);
	  net[stage][dh+gh-i/2-1]->out_0(links[stage][dh*2+(gh*2)-i-1]);

	  if ( dest_down % 2 == 0 )
	    net[stage+1][(dh*2+dest_down)/2]->in_0(links[stage][dh*2+(gh*2)-i-1]);
	  else
	    net[stage+1][(dh*2+dest_down)/2]->in_1(links[stage][dh*2+(gh*2)-i-1]);

	}
      
    }
}
		 
/*
 * Cable un réseau buttefly complètement
 */
void cable_butterfly(cross *net[ETAGES][HEIGHT],
		     sc_buffer<sc_bv<BV_SIZE> > links[ETAGES][IO])
{

  for(int i=1;i<ETAGES;i++)
    {
      int grp_size = IO / 2 / i;

      printf("Stage %d : Making %d groups of size %d\n", i-1, i, grp_size);

      /* Cabler chaque groupe */
      for(int j=0;j<i;j++)
	{
	  printf("Group %d (starts @%d)...\n", j, j*grp_size*2);
	  cable_stage(net, links,
		      i-1,
		      grp_size,
		      j*grp_size*2);
	}
    }
}

int sc_main(int argc, char *argv[])
{
  srand(time(NULL));

  // Clock
  sc_clock clk("clock", 20, 0.5);

  // Cables pour les sources
  sc_buffer<sc_bv<BV_SIZE> > e[IO];

  // Cables pour les afficheurs
  sc_buffer<sc_bv<BV_SIZE> > s[IO];

  // Cables d'interlaison
  sc_buffer<sc_bv<BV_SIZE> > links[ETAGES][IO];
  
  // Réseau
  cross *net[ETAGES][HEIGHT];
  for(int i=0;i<ETAGES;i++)
    for(int j=0;j<HEIGHT;j++)
      {
	char name[10];
	snprintf(name, 10, "%d-%d", i, j);
	net[i][j] = new cross(name);
      }

  // cable l'entrée
  source *sources[IO];
  for(int i=0;i<IO;i++)
    {
      char name[10];
      snprintf(name, 10, "source%d", i);
      sources[i] = new source(name);

      printf("connect in %d\n", i);
      if ( i % 2 == 0 )
	net[0][i/2]->in_0(e[i]);
      else
	net[0][i/2]->in_1(e[i]);

      sources[i]->out(e[i]);
      sources[i]->clk(clk);
      sources[i]->data = random();
    }

  // cable le réseau
  cable_butterfly(net, links);

  // cable sortie
  print *printers[IO];
  for(int i=0;i<IO;i++)
    {
      char name[10];
      snprintf(name, 10, "printer%d", i);
      printers[i] = new print(name);

      sc_buffer<sc_bv<BV_SIZE> > link;

      printf("connect out %d\n", i);
      if ( i % 2 == 0 )
	net[ETAGES-1][i/2]->out_0(s[i]);
      else
	net[ETAGES-1][i/2]->out_1(s[i]);

      printers[i]->in(s[i]);
    }
  
  // Lancer la simulation
  sc_start(1000);

  // Libération des ressources
  for(int i=0;i<ETAGES;i++)
    for(int j=0;j<HEIGHT;j++)
      delete net[i][j];

  for(int i=0;i<IO;i++)
    {
      delete printers[i];
      delete sources[i];
    }

  return 0;
}