#include <rvm_std_lib.vrh>
#ifndef ENV_CLASS
#define ENV_CLASS

class env extends rvm_env {
  integer        time_out = 100000;
  integer        seed;

  packet_channel           chan_gen_tx;
  packet_channel           chan_hst2sb_tx;
  packet_channel           chan_phy2sb_tx;
  rx_packet_channel        chan_gen_rx;
  packet_channel        chan_hst2sb_rx;
  packet_channel        chan_phy2sb_rx;

  host_driver    h_drvr;
  phy_driver     p_drvr;
  cfg_driver     c_drvr;

  host_xtor_tx   h_xtor_tx;
  phy_xtor_tx    p_xtor_tx;
  host_xtor_rx   h_xtor_rx;
  phy_xtor_rx    p_xtor_rx;
  cfg_xtor       c_xtor;

  packet         tx_pkt;
  rx_packet      rx_pkt;

  sb             sb_tx;
  sb             sb_rx;

  packet_atomic_gen gen_tx;
  rx_packet_atomic_gen gen_rx;

  dbg_data_callback dbg_callback;

  cov rx_cov;
  cov tx_cov;

  integer rx_num_pkts = 20;
  integer tx_num_pkts = 20;

  task new();

  virtual task gen_cfg();
  virtual task build();
  virtual task reset_dut_t();
  virtual task cfg_dut_t();
  virtual task start_t();
  virtual task wait_for_end_t();
  virtual task stop_t();
  virtual task cleanup_t();
  virtual task report();

  virtual task Global_timeout();
  virtual task Set_timeout(integer time_out);
  virtual task Heart_beat();
  virtual task set_rx_num_pkts (integer num);
  virtual task set_tx_num_pkts (integer num);

}

task env::new(){
   super.new("Environment");
   this.log = new("ENV_LOG","0");
   rvm_note(this.log," ENV CREATED \n");
}

task env::gen_cfg(){
   super.gen_cfg();
   rvm_note(this.log," Starting... Gen_cfg \n");
   if (value_plusargs("use_seed=0", seed))
     rvm_note(this.log,psprintf("Using User specified seed 0 ",seed));
   else
     { seed = get_systime();
       rvm_note(this.log,psprintf("Using systime specified seed 0 ",seed));
     }
   srandom(seed);

}


task env::build(){
  super.build();
  rvm_note(this.log," Starting... build \n");

  c_drvr = new("CFG_driver");
  c_xtor = new("Cfg_xtor",c_drvr);
  gen_tx = new("GEN","TX_GEN");
  gen_rx = new("GEN","RX_GEN");
  chan_gen_tx      = new("CHAN_gen_tx","CHAN",1);
  chan_hst2sb_tx   = new("CHAN_hst2sb_tx","CHAN",100);
  chan_phy2sb_tx   = new("CHAN_phy2sb_tx","CHAN",100);
  chan_gen_rx      = new("CHAN_gen_rx","CHAN",1);
  chan_hst2sb_rx   = new("CHAN_hst2sb_rx","CHAN",100);
  chan_phy2sb_rx   = new("CHAN_phy2sb_rx","CHAN",100);
  tx_pkt = new();
  rx_pkt = new();
  h_drvr = new("Host_driver");
  p_drvr = new("PHY_driver");
  h_xtor_tx = new("HOST_XTOR_TX",h_drvr,chan_gen_tx,chan_hst2sb_tx);
  h_xtor_rx = new("HOST_XTOR_RX",h_drvr,chan_hst2sb_rx);
  p_xtor_tx = new("PHY_XTOR_TX",p_drvr,chan_phy2sb_tx);
  p_xtor_rx = new("PHY_XTOR_RX",p_drvr,chan_gen_rx,chan_phy2sb_rx);
  gen_tx.out_chan = chan_gen_tx;
  gen_rx.out_chan = chan_gen_rx;
  rx_cov = new();
  tx_cov = new();
  sb_tx = new("SB_TX",chan_hst2sb_tx,chan_phy2sb_tx,tx_cov);
  sb_rx = new("SB_RX",chan_phy2sb_rx,chan_hst2sb_rx,rx_cov);
  dbg_callback = new();
  h_xtor_tx.append_callback(dbg_callback);
  p_xtor_rx.append_callback(dbg_callback);
}

task env::reset_dut_t(){
  super.reset_dut_t();
  rvm_note(this.log," Starting... reset_dut \n");
  h_drvr.posedge_clk() ;
  h_drvr.drive_Tx_mac_sop(0);
  h_drvr.drive_Tx_mac_eop(0);
  h_drvr.drive_Tx_mac_wr(0);
  h_drvr.drive_Tx_mac_BE(0);
  h_drvr.drive_Tx_mac_data(0);
  h_drvr.drive_Reset(1);
  p_drvr.drive_Rx_dv(0);
  p_drvr.drive_Rxd(0);
  p_drvr.drive_Rx_er(0);
  p_drvr.drive_Crs(0);
  p_drvr.drive_Col(0);



  repeat(20) h_drvr.posedge_clk();
  h_drvr.drive_Reset(0);
  rvm_note(this.log," Ending...  reset_dut \n");

}

task env::cfg_dut_t(){
integer i;
   super.cfg_dut_t();
   rvm_note(this.log," Starting... cfg_dut \n");
   rvm_note(this.log," Ending...  cfg_dut \n");
   gen_tx.stop_after_n_insts = rx_num_pkts;
   gen_rx.stop_after_n_insts = tx_num_pkts;
   rvm_note(this.log," rx_num_pkts  \n");

}


task env::start_t(){
 super.start_t();
   rvm_note(this.log," Starting... start \n");
   this.Heart_beat();
   gen_tx.start_xactor();
   gen_rx.start_xactor();
   sb_tx.start_xactor();
   sb_rx.start_xactor();
   h_xtor_tx.start_xactor();
   h_xtor_rx.start_xactor();
   p_xtor_tx.start_xactor();
   p_xtor_rx.start_xactor();

}

task env::wait_for_end_t() {
   super.wait_for_end_t();
   rvm_note(this.log," Starting... wait_for_end \n");
   repeat(30)@(posedge host_intf.clk);

  fork//watchdog
  {
    Global_timeout();
   rvm_error(this.log," Watchdog timeout occured \n");
  }
  {
  while((sb_tx.exp_num_pkts() != sb_tx.rcv_num_pkts())||(sb_rx.exp_num_pkts() != sb_rx.rcv_num_pkts())) @(posedge host_intf.clk);
   rvm_note(this.log," DONE:: total number of sent pkts are receved \n");

  }
  join any
   rvm_note(this.log," Ending ... wait_for_end \n");


}

task env::stop_t() {
   super.stop_t();
   rvm_note(this.log," Starting... stop \n");
   gen_tx.stop_xactor();
   gen_rx.stop_xactor();
   sb_tx.stop_xactor();
   sb_rx.stop_xactor();
   h_xtor_tx.stop_xactor();
   h_xtor_rx.stop_xactor();
   p_xtor_tx.stop_xactor();
   p_xtor_rx.stop_xactor();

   rvm_note(this.log," Ending ... stop \n");

}



task env::cleanup_t() {
   super.cleanup_t();
   rvm_note(this.log," Starting... cleanup \n");
}

task env::report() {
   rvm_note(this.log," Starting... report \n");
   super.report();
   sb_tx.final();
   sb_rx.final();
   if(sb_tx.test_pass && sb_rx.test_pass)
    printf("\t                 TEST PASSED                   \n");
   else
    printf("\t                 TEST FAILED                   \n");
    printf("\t***********************************************\n\n");

   rvm_note(this.log," Ending...  report \n");
}




task env::Global_timeout(){
  repeat(time_out) @(posedge host_intf.clk);
}

task env::Set_timeout(integer time_out){
  this.time_out = time_out;
}

task env::Heart_beat(){
 fork
  while(1){
  repeat(1000) @(posedge host_intf.clk);
  rvm_note(this.log,psprintf(" HeartBeat 0",get_time(LO)));
  }
 join none
}

task env::set_rx_num_pkts (integer num){
  this.rx_num_pkts = num;
}

task env::set_tx_num_pkts (integer num){
  this.tx_num_pkts = num;
}

#endif