//.ned

//IIUC_DWIP_ELITE
// DATE: 11/02/2024

simple IIUC_DWIP_ELITE_node
{
    parameters:
     @signal[arrival](type="long");
  @statistic[hopCount](title="hop count"; source="arrival"; record=vector,stats; interpolationmode=none);
  @display("i=block/routing");
     
    gates:
        inout gate[];
}

network IIUC_DWIP_ELITE_net
{
    parameters:
        @figure[description](type=text; pos=5,20; font=,,bold; 
      text="Random routing example - displaying last hop count");
     @figure[lasthopcount](type=text; pos=5,35; text="last hopCount: N/A");
    types:
        channel Delay extends ned.DelayChannel {
            delay = 100ms;
    }
    submodules:
        meraj[10]: IIUC_DWIP_ELITE_node {
            @display("i=block/socket");
        }
    connections:
        meraj[0].gate++ <-->   Delay <--> meraj[1].gate++;
        meraj[1].gate++ <-->   Delay <--> meraj[2].gate++;
        meraj[1].gate++ <-->   Delay <--> meraj[4].gate++;
        meraj[3].gate++ <-->   Delay <--> meraj[4].gate++;
        meraj[4].gate++ <-->   Delay <--> meraj[5].gate++;
        meraj[5].gate++ <-->   Delay <--> meraj[6].gate++;
        meraj[5].gate++ <-->   Delay <--> meraj[7].gate++;
        meraj[6].gate++ <-->   Delay <--> meraj[7].gate++;
        meraj[6].gate++ <-->   Delay <--> meraj[8].gate++;
        meraj[7].gate++ <-->   Delay <--> meraj[9].gate++;
        meraj[8].gate++ <-->   Delay <--> meraj[9].gate++;      
}

//.cc

/* IIUC_DWIP_ELITE.cc
   Created on: Feb 11, 2024
   Author: DELL  */

#include <stdio.h>
#include <string.h>
#include <omnetpp.h>
#include "IIUC_DWIP_ELITE_m.h"
using namespace omnetpp;

    class IIUC_DWIP_ELITE_node : public cSimpleModule
    {
    private:
        simsignal_t arrivalSignal;

      protected:
        virtual IIUC_DWIP_ELITE *generateMessage();
        virtual void forwardMessage(IIUC_DWIP_ELITE *msg);
        virtual void initialize() override;
        virtual void handleMessage(cMessage *msg) override;
    };

    Define_Module(IIUC_DWIP_ELITE_node);

    void IIUC_DWIP_ELITE_node::initialize()
    {
        arrivalSignal = registerSignal("arrival");

        // Module 0 sends the first message

        if (getIndex() == 0) {

            // Boot the process scheduling the initial message as a self-message.
            IIUC_DWIP_ELITE *msg = generateMessage();
            scheduleAt(0.0, msg);
        }
    }

    void IIUC_DWIP_ELITE_node::handleMessage(cMessage *msg)
    {
        IIUC_DWIP_ELITE *ttmsg = check_and_cast<IIUC_DWIP_ELITE *>(msg);

        if (ttmsg->getDestination() == getIndex()) {
            int hopcount = ttmsg->getHopCount();
                       // send a signal
              emit(arrivalSignal, hopcount);




            if (hasGUI()) {
                    char label[50];
                    // Write last hop count to string
                    sprintf(label, "last hopCount = %d", hopcount);
                    // Get pointer to figure
                    cCanvas *canvas = getParentModule()->getCanvas();
                    cTextFigure *textFigure = check_and_cast<cTextFigure*>(canvas->getFigure("lasthopcount"));
                    // Update figure text
                    textFigure->setText(label);
                }

                EV << "Message " << ttmsg << " arrived after " << hopcount << " hops.n";
                bubble("ARRIVED, starting new one!");

                delete ttmsg;

                // Generate another one.
                EV << "Generating another message: ";
                IIUC_DWIP_ELITE *newmsg = generateMessage();
                EV << newmsg << endl;
                forwardMessage(newmsg);
        }

        else {
            // We need to forward the message.
            forwardMessage(ttmsg);
        }
    }

    IIUC_DWIP_ELITE *IIUC_DWIP_ELITE_node::generateMessage()
    {
        // Produce source and destination addresses.
        int src = getIndex();  // our module index
        int n = getVectorSize();  // module vector size
        int dest = intuniform(0, n-2);
        if (dest >= src)
            dest++;

        char msgname[20];
        sprintf(msgname, "tic-%d-to-%d", src, dest);

        // Create message object and set source and destination field.
        IIUC_DWIP_ELITE *msg = new IIUC_DWIP_ELITE(msgname);
        msg->setSource(src);
        msg->setDestination(dest);
        return msg;
    }

    void IIUC_DWIP_ELITE_node::forwardMessage(IIUC_DWIP_ELITE *msg)
    {
        // Increment hop count.
        msg->setHopCount(msg->getHopCount()+1);

        // Same routing as before: random gate.
        int n = gateSize("gate");
        int k = intuniform(0, n-1);

        EV << "Forwarding message " << msg << " on gate[" << k << "]n";
        send(msg, "gate$o", k);
    }

//.ini
[General]
network = IIUC_DWIP_ELITE_net
record-eventlog = true
#**.meraj[*].hopCount.result-recording-modes = +scala
**.meraj[*].hopCount.result-recording-modes = +histogram
**.meraj[*].hopCount.result-recording-modes = -vector
  
//.msg
message IIUC_DWIP_ELITE
{
    int source;
    int destination;
    int hopCount = 0;
}