/*
 * blocks.cpp
 *
 *  Created on: 04.05.2020
 *      Author: eyck
 */

#include "pkt_sender.h"
#include "types.h"
#include <scc/report.h>
#include <tlm/tlm_mm.h>

using namespace sc_core;

pkt_sender::pkt_sender(const sc_core::sc_module_name &nm, unsigned dim, unsigned pos_x, unsigned pos_y, unsigned count)
: sc_module(nm)
, bw_peq("bw_peq")
, fw_peq("fw_peq")
, my_pos{pos_x,pos_y}
, dim{dim}
, count{count}
{
    SCCDEBUG(SCMOD)<<"instantiating sender "<<pos_x<<"/"<<pos_y;
    SC_HAS_PROCESS(pkt_sender);
    isck.register_nb_transport_bw([this](tlm::tlm_generic_payload &gp, tlm::tlm_phase &phase, sc_core::sc_time &delay)->tlm::tlm_sync_enum{
        return this->nb_bw(gp, phase, delay);
    });
    tsck.register_nb_transport_fw([this](tlm::tlm_generic_payload &gp, tlm::tlm_phase &phase, sc_core::sc_time &delay)->tlm::tlm_sync_enum{
        return this->nb_fw(gp, phase, delay);
    });
    SC_METHOD(received);
    sensitive<<fw_peq.get_event();
    dont_initialize();
    SC_THREAD(run);
}

void pkt_sender::gen_routing(std::vector<uint8_t> &route_vec) {
    if(std::get<0>(my_pos)==0){
        for(auto i=0; i<dim; ++i)
            route_vec.push_back(RIGHT);
    } else if(std::get<0>(my_pos)==dim+1){
        for(auto i=0; i<dim; ++i)
            route_vec.push_back(LEFT);
    } else if(std::get<1>(my_pos)==0){
        for(auto i=0; i<dim; ++i)
            route_vec.push_back(BOTTOM);
    } else if(std::get<1>(my_pos)==dim+1){
        for(auto i=0; i<dim; ++i)
            route_vec.push_back(TOP);
    } else
        SCCERR(SCMOD)<<"WTF!?!";
}

void pkt_sender::run() {
    wait(clk_i.posedge_event());
    for(auto i=0U; i<count; i++){
        tlm::tlm_generic_payload* gp = tlm::tlm_mm<>::get().allocate<packet_ext>();
        gen_routing(gp->get_extension<packet_ext>()->routing);
        tlm::tlm_phase phase{tlm::BEGIN_REQ};
        sc_time delay;
        gp->acquire();
        auto sync = isck->nb_transport_fw(*gp, phase, delay);
        sc_assert(sync==tlm::TLM_UPDATED && phase==tlm::END_REQ);
        tlm::tlm_generic_payload* ret{nullptr};
        while(!(ret=bw_peq.get_next_transaction())){
            wait(bw_peq.get_event());
        }
        sc_assert(gp==ret);
        ret->release();
    }
    finish_evt.notify(SC_ZERO_TIME);
}

tlm::tlm_sync_enum pkt_sender::nb_bw(tlm::tlm_generic_payload &gp, tlm::tlm_phase &phase, sc_core::sc_time &delay) {
    sc_assert(phase==tlm::BEGIN_RESP);
    bw_peq.notify(gp, delay);
    phase=tlm::END_RESP;
    return tlm::TLM_COMPLETED;
}

tlm::tlm_sync_enum pkt_sender::nb_fw(tlm::tlm_generic_payload &gp, tlm::tlm_phase &phase, sc_core::sc_time &delay) {
    sc_assert(phase==tlm::BEGIN_REQ);
    auto ext = gp.get_extension<packet_ext>();
    sc_assert(ext->routing.size()==0);
    gp.acquire();
    fw_peq.notify(gp, delay);
    phase=tlm::END_REQ;
    return tlm::TLM_UPDATED;
}

void pkt_sender::received() {
    if(auto gp = fw_peq.get_next_transaction()){
        tlm::tlm_phase phase{tlm::BEGIN_RESP};
        sc_time delay;
        auto sync = tsck->nb_transport_bw(*gp, phase, delay);
        sc_assert(sync==tlm::TLM_COMPLETED && phase==tlm::END_RESP);
        gp->release();
    }
}