#include "ns3/core-module.

h"
#include "ns3/network-module.h"
#include "ns3/internet-module.h"
#include "ns3/mobility-module.h"
#include "ns3/applications-module.h"
#include "ns3/point-to-point-module.h"
#include "ns3/lte-module.h"

using namespace ns3;

NS_LOG_COMPONENT_DEFINE("WifiOffloadSimulator");

const int NUM_USERS = 50;

const double PRB_CAPACITY = 1000.0; // Total number of available PRBs
const double PRB_USAGE_RATE = 0.02; // Rate at which PRBs are used per user (adjust
based on your scenario)
const double SIMULATION_TIME = 10.0; // in seconds

struct User {
double dataDemand; // User's data demand in PRBs
Ptr<Node> node; // User's node in ns-3
};

double usedPRBs = 0.0;

void SimulateUserActivity(std::vector<User>& users) {

for (size_t i = 0; i < users.size(); ++i) {
// Simulate user data demand
users[i].dataDemand = (rand() % 10) + 1; // Example: random data demand
between 1 and 10 PRBs

// Check if there are enough available PRBs

if (usedPRBs + users[i].dataDemand <= PRB_CAPACITY) {
// Allocate PRBs to the user
usedPRBs += users[i].dataDemand;
} else {
// Handle congestion or queuing mechanisms
NS_LOG_INFO("Congestion: User " << i << " cannot get required PRBs.");
}
}
}

void ReleaseUnusedPRBs(std::vector<User>& users) {

// Simulate release of PRBs for users who have finished using resources
for (size_t i = 0; i < users.size(); ++i) {
if (usedPRBs >= users[i].dataDemand) {
usedPRBs -= users[i].dataDemand;
} else {
// Handle potential error or queuing mechanisms
NS_LOG_INFO("Error: User " << i << " trying to release more PRBs than
allocated.");
}
}
}

int main(int argc, char* argv[]) {

LogComponentEnable("WifiOffloadSimulator", LOG_LEVEL_INFO);

// Seed for random number generation

 srand(time(0));

// Create nodes
NodeContainer enbNode;
enbNode.Create(1);

NodeContainer ueNodes;
ueNodes.Create(NUM_USERS);

// Mobility model for UEs (random walk)

MobilityHelper mobility;
mobility.SetMobilityModel("ns3::RandomWalk2dMobilityModel",
"Bounds", RectangleValue(Rectangle(-500, 500, -500,
500)));
mobility.Install(ueNodes);

// Install LTE
NetDeviceContainer enbLteDevice, ueLteDevice;
enbLteDevice = lte.Install(enbNode);
ueLteDevice = lte.Install(ueNodes);

// Internet stack
InternetStackHelper stack;
stack.Install(enbNode);
stack.Install(ueNodes);

// Install IP/EPC stack on eNodeB

lteHelper->Attach(enbLteDevice, ueLteDevice);

// Internet simulation
InternetHelper internet;
NodeContainer internetNode;
internetNode.Create(1);
NetDeviceContainer internetDevices = p2p.Install(internetNode.Get(0),
enbNode.Get(0));
internet.Install(internetNode);

// Configure the remote node as the Internet

Ipv4AddressHelper ipv4h;
ipv4h.SetBase("10.1.2.0", "255.255.255.0");
Ipv4InterfaceContainer internetInterfaces = ipv4h.Assign(internetDevices);

// Simulation loop
std::vector<User> users(NUM_USERS);
for (size_t i = 0; i < NUM_USERS; ++i) {
users[i].node = ueNodes.Get(i);
}

for (double currentTime = 0.0; currentTime < SIMULATION_TIME; currentTime +=

1.0) {
SimulateUserActivity(users);
ReleaseUnusedPRBs(users);

Simulator::Stop(Seconds(currentTime + 1.0));
Simulator::Run();
Simulator::Destroy();
}

return 0;
}