program 1

/* 
 * 3G Network Performance Analysis: Throughput and Delay
 * NS-3 Simulation for 1-10 Nodes
 * Measures: Throughput, End-to-End Delay, Packet Loss, Jitter
 */

#include "ns3/core-module.h"
#include "ns3/network-module.h"
#include "ns3/internet-module.h"
#include "ns3/point-to-point-module.h"
#include "ns3/applications-module.h"
#include "ns3/mobility-module.h"
#include "ns3/lte-module.h"
#include "ns3/config-store-module.h"
#include "ns3/flow-monitor-module.h"
#include "ns3/netanim-module.h"
#include <fstream>
#include <iostream>
#include <iomanip>
#include <vector>
#include <cmath>

using namespace ns3;

NS_LOG_COMPONENT_DEFINE("3GNetworkPerformance");

// Global variables for statistics
uint32_t totalPacketsSent = 0;
uint32_t totalPacketsReceived = 0;
uint64_t totalBytesReceived = 0;
double totalDelay = 0.0;
uint32_t delayCount = 0;
std::vector<double> delays;

// Performance metrics structure
struct PerformanceMetrics {
    uint32_t numNodes;
    double throughput;
    double avgDelay;
    double packetLoss;
    double jitter;
    double rxPackets;
    double txPackets;
};

std::vector<PerformanceMetrics> allMetrics;

// Packet receive callback
void ReceivePacket(Ptr<Socket> socket) {
    Ptr<Packet> packet;
    Address from;
    while ((packet = socket->RecvFrom(from))) {
        totalPacketsReceived++;
        totalBytesReceived += packet->GetSize();
        
        // Extract timing information if available
        SeqTsHeader seqTs;
        packet->RemoveHeader(seqTs);
        Time tx = seqTs.GetTs();
        Time rx = Simulator::Now();
        Time delay = rx - tx;
        
        totalDelay += delay.GetSeconds();
        delays.push_back(delay.GetSeconds());
        delayCount++;
        
        NS_LOG_INFO("Received packet of size " << packet->GetSize() 
                    << " bytes at " << rx.GetSeconds() 
                    << "s, delay: " << delay.GetMilliSeconds() << " ms");
    }
}

// Packet send callback
void SendPacket(Ptr<Socket> socket, uint32_t pktSize, uint32_t pktCount, Time pktInterval) {
    if (pktCount > 0) {
        Ptr<Packet> packet = Create<Packet>(pktSize);
        SeqTsHeader seqTs;
        seqTs.SetSeq(totalPacketsSent++);
        packet->AddHeader(seqTs);
        
        socket->Send(packet);
        
        Simulator::Schedule(pktInterval, &SendPacket, socket, pktSize, pktCount - 1, pktInterval);
    }
}

// Calculate jitter
double CalculateJitter() {
    if (delays.size() < 2) return 0.0;
    
    double jitter = 0.0;
    for (size_t i = 1; i < delays.size(); i++) {
        jitter += std::abs(delays[i] - delays[i-1]);
    }
    return (jitter / (delays.size() - 1)) * 1000; // Convert to ms
}

// Run simulation for specific number of nodes
void RunSimulation(uint32_t numNodes, double bandwidth, double frequency, double simTime) {
    
    // Reset statistics
    totalPacketsSent = 0;
    totalPacketsReceived = 0;
    totalBytesReceived = 0;
    totalDelay = 0.0;
    delayCount = 0;
    delays.clear();
    
    NS_LOG_INFO("Running simulation with " << numNodes << " nodes");
    
    // Create LTE Helper
    Ptr<LteHelper> lteHelper = CreateObject<LteHelper>();
    Ptr<PointToPointEpcHelper> epcHelper = CreateObject<PointToPointEpcHelper>();
    lteHelper->SetEpcHelper(epcHelper);
    
    // Configure 3G/LTE parameters
    lteHelper->SetAttribute("PathlossModel", StringValue("ns3::FriisSpectrumPropagationLossModel"));
    lteHelper->SetEnbDeviceAttribute("DlBandwidth", UintegerValue(bandwidth)); // Resource blocks
    lteHelper->SetEnbDeviceAttribute("UlBandwidth", UintegerValue(bandwidth));
    
    // Set frequency (carrier frequency in Hz)
    lteHelper->SetEnbDeviceAttribute("DlEarfcn", UintegerValue(frequency));
    lteHelper->SetEnbDeviceAttribute("UlEarfcn", UintegerValue(frequency + 18000));
    
    // Get PGW node
    Ptr<Node> pgw = epcHelper->GetPgwNode();
    
    // Create remote host
    NodeContainer remoteHostContainer;
    remoteHostContainer.Create(1);
    Ptr<Node> remoteHost = remoteHostContainer.Get(0);
    
    InternetStackHelper internet;
    internet.Install(remoteHostContainer);
    
    // Connect remote host to PGW
    PointToPointHelper p2ph;
    p2ph.SetDeviceAttribute("DataRate", DataRateValue(DataRate("100Gb/s")));
    p2ph.SetDeviceAttribute("Mtu", UintegerValue(1500));
    p2ph.SetChannelAttribute("Delay", TimeValue(Seconds(0.001)));
    NetDeviceContainer internetDevices = p2ph.Install(pgw, remoteHost);
    
    // Assign IP addresses
    Ipv4AddressHelper ipv4h;
    ipv4h.SetBase("1.0.0.0", "255.0.0.0");
    Ipv4InterfaceContainer internetIpIfaces = ipv4h.Assign(internetDevices);
    
    // Set up routing
    Ipv4StaticRoutingHelper ipv4RoutingHelper;
    Ptr<Ipv4StaticRouting> remoteHostStaticRouting = ipv4RoutingHelper.GetStaticRouting(remoteHost->GetObject<Ipv4>());
    remoteHostStaticRouting->AddNetworkRouteTo(Ipv4Address("7.0.0.0"), Ipv4Mask("255.0.0.0"), 1);
    
    // Create eNodeB
    NodeContainer enbNodes;
    enbNodes.Create(1);
    
    // Create UE nodes
    NodeContainer ueNodes;
    ueNodes.Create(numNodes);
    
    // Install mobility model for eNodeB
    MobilityHelper enbMobility;
    Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator>();
    positionAlloc->Add(Vector(0.0, 0.0, 0.0));
    enbMobility.SetPositionAllocator(positionAlloc);
    enbMobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
    enbMobility.Install(enbNodes);
    
    // Install mobility model for UEs
    MobilityHelper ueMobility;
    ueMobility.SetPositionAllocator("ns3::UniformDiscPositionAllocator",
                                    "X", DoubleValue(0.0),
                                    "Y", DoubleValue(0.0),
                                    "rho", DoubleValue(50.0));
    ueMobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
    ueMobility.Install(ueNodes);
    
    // Install LTE devices
    NetDeviceContainer enbLteDevs = lteHelper->InstallEnbDevice(enbNodes);
    NetDeviceContainer ueLteDevs = lteHelper->InstallUeDevice(ueNodes);
    
    // Install Internet stack on UEs
    internet.Install(ueNodes);
    
    // Assign IP addresses to UEs
    Ipv4InterfaceContainer ueIpIface;
    ueIpIface = epcHelper->AssignUeIpv4Address(NetDeviceContainer(ueLteDevs));
    
    // Set default gateway for UEs
    for (uint32_t u = 0; u < ueNodes.GetN(); ++u) {
        Ptr<Node> ueNode = ueNodes.Get(u);
        Ptr<Ipv4StaticRouting> ueStaticRouting = ipv4RoutingHelper.GetStaticRouting(ueNode->GetObject<Ipv4>());
        ueStaticRouting->SetDefaultRoute(epcHelper->GetUeDefaultGatewayAddress(), 1);
    }
    
    // Attach UEs to eNodeB
    lteHelper->Attach(ueLteDevs);
    
    // Install applications
    uint16_t dlPort = 1234;
    uint16_t ulPort = 2000;
    
    ApplicationContainer clientApps;
    ApplicationContainer serverApps;
    
    // Downlink: Remote host to UEs
    for (uint32_t u = 0; u < ueNodes.GetN(); ++u) {
        PacketSinkHelper dlPacketSinkHelper("ns3::UdpSocketFactory", 
                                           InetSocketAddress(Ipv4Address::GetAny(), dlPort));
        serverApps.Add(dlPacketSinkHelper.Install(ueNodes.Get(u)));
        
        UdpClientHelper dlClient(ueIpIface.GetAddress(u), dlPort);
        dlClient.SetAttribute("Interval", TimeValue(MilliSeconds(10)));
        dlClient.SetAttribute("MaxPackets", UintegerValue(1000000));
        dlClient.SetAttribute("PacketSize", UintegerValue(1024));
        clientApps.Add(dlClient.Install(remoteHost));
    }
    
    // Uplink: UEs to Remote host
    PacketSinkHelper ulPacketSinkHelper("ns3::UdpSocketFactory", 
                                       InetSocketAddress(Ipv4Address::GetAny(), ulPort));
    serverApps.Add(ulPacketSinkHelper.Install(remoteHost));
    
    for (uint32_t u = 0; u < ueNodes.GetN(); ++u) {
        UdpClientHelper ulClient(internetIpIfaces.GetAddress(1), ulPort);
        ulClient.SetAttribute("Interval", TimeValue(MilliSeconds(10)));
        ulClient.SetAttribute("MaxPackets", UintegerValue(1000000));
        ulClient.SetAttribute("PacketSize", UintegerValue(1024));
        clientApps.Add(ulClient.Install(ueNodes.Get(u)));
    }
    
    serverApps.Start(Seconds(0.1));
    clientApps.Start(Seconds(0.5));
    serverApps.Stop(Seconds(simTime));
    clientApps.Stop(Seconds(simTime - 0.1));
    
    // --- NETANIM CONFIGURATION ---
    // 2. Create the AnimationInterface object
    AnimationInterface anim("3g-simulation.xml"); 

    // 3. Optional: Color the Base Station (Red)
    anim.UpdateNodeDescription(enbNodes.Get(0), "eNodeB (3G BS)");
    anim.UpdateNodeColor(enbNodes.Get(0), 255, 0, 0); 

    // 4. Optional: Color the Remote Host (Green)
    anim.UpdateNodeDescription(remoteHost, "Remote Server");
    anim.UpdateNodeColor(remoteHost, 0, 255, 0);

    // 5. Optional: Color and Label UEs (Blue)
    for (uint32_t i = 0; i < ueNodes.GetN(); ++i) {
        anim.UpdateNodeDescription(ueNodes.Get(i), "User_" + std::to_string(i));
        anim.UpdateNodeColor(ueNodes.Get(i), 0, 0, 255);
    }
    
    // 6. Enable Packet Metadata (allows you to see IP/UDP details in NetAnim)
    anim.EnablePacketMetadata(true);
    
    // Install FlowMonitor
    FlowMonitorHelper flowmon;
    Ptr<FlowMonitor> monitor = flowmon.InstallAll();
    
    // Run simulation
    Simulator::Stop(Seconds(simTime));
    Simulator::Run();
    
    // Calculate metrics using FlowMonitor
    monitor->CheckForLostPackets();
    Ptr<Ipv4FlowClassifier> classifier = DynamicCast<Ipv4FlowClassifier>(flowmon.GetClassifier());
    std::map<FlowId, FlowMonitor::FlowStats> stats = monitor->GetFlowStats();
    
    double totalThroughput = 0.0;
    double totalAvgDelay = 0.0;
    double totalPacketLoss = 0.0;
    uint32_t flowCount = 0;
    
    for (std::map<FlowId, FlowMonitor::FlowStats>::const_iterator i = stats.begin(); i != stats.end(); ++i) {
        Ipv4FlowClassifier::FiveTuple t = classifier->FindFlow(i->first);
        
        double throughput = i->second.rxBytes * 8.0 / (i->second.timeLastRxPacket.GetSeconds() - 
                                                        i->second.timeFirstTxPacket.GetSeconds()) / 1024 / 1024;
        double avgDelay = i->second.delaySum.GetMilliSeconds() / i->second.rxPackets;
        double packetLoss = (i->second.txPackets - i->second.rxPackets) * 100.0 / i->second.txPackets;
        
        totalThroughput += throughput;
        totalAvgDelay += avgDelay;
        totalPacketLoss += packetLoss;
        flowCount++;
        
        NS_LOG_INFO("Flow " << i->first << " (" << t.sourceAddress << " -> " << t.destinationAddress << ")");
        NS_LOG_INFO("  Throughput: " << throughput << " Mbps");
        NS_LOG_INFO("  Avg Delay: " << avgDelay << " ms");
        NS_LOG_INFO("  Packet Loss: " << packetLoss << " %");
    }
    
    // Store metrics
    PerformanceMetrics metrics;
    metrics.numNodes = numNodes;
    metrics.throughput = totalThroughput;
    metrics.avgDelay = totalAvgDelay / flowCount;
    metrics.packetLoss = totalPacketLoss / flowCount;
    metrics.jitter = 0.0; // Can be calculated from FlowMonitor if needed
    metrics.rxPackets = 0;
    metrics.txPackets = 0;
    
    for (std::map<FlowId, FlowMonitor::FlowStats>::const_iterator i = stats.begin(); i != stats.end(); ++i) {
        metrics.rxPackets += i->second.rxPackets;
        metrics.txPackets += i->second.txPackets;
    }
    
    allMetrics.push_back(metrics);
    
    Simulator::Destroy();
}

int main(int argc, char *argv[]) {
    
    // Simulation parameters
    double bandwidth = 50;  // Resource blocks (equivalent to ~10 MHz for LTE)
    double frequency = 2100; // Carrier frequency index (EARFCN)
    double simTime = 10.0;   // Simulation time in seconds
    uint32_t minNodes = 1;
    uint32_t maxNodes = 10;
    std::string outputFile = "3g_performance_results.csv";
    
    // Parse command line arguments
    CommandLine cmd;
    cmd.AddValue("bandwidth", "Bandwidth in resource blocks", bandwidth);
    cmd.AddValue("frequency", "Carrier frequency (EARFCN)", frequency);
    cmd.AddValue("simTime", "Simulation time in seconds", simTime);
    cmd.AddValue("minNodes", "Minimum number of nodes", minNodes);
    cmd.AddValue("maxNodes", "Maximum number of nodes", maxNodes);
    cmd.AddValue("outputFile", "Output CSV file name", outputFile);
    cmd.Parse(argc, argv);
    
    // Enable logging
    LogComponentEnable("3GNetworkPerformance", LOG_LEVEL_INFO);
    
    std::cout << "\n========================================" << std::endl;
    std::cout << "3G Network Performance Simulation" << std::endl;
    std::cout << "========================================" << std::endl;
    std::cout << "Bandwidth: " << bandwidth << " RBs" << std::endl;
    std::cout << "Frequency: " << frequency << " EARFCN" << std::endl;
    std::cout << "Simulation Time: " << simTime << " seconds" << std::endl;
    std::cout << "Node Range: " << minNodes << " to " << maxNodes << std::endl;
    std::cout << "========================================\n" << std::endl;
    
    // Run simulations for different node counts
    for (uint32_t numNodes = minNodes; numNodes <= maxNodes; numNodes++) {
        std::cout << "\n--- Simulating with " << numNodes << " node(s) ---" << std::endl;
        RunSimulation(numNodes, bandwidth, frequency, simTime);
    }
    
    // Write results to CSV file
    std::ofstream outFile(outputFile);
    outFile << "Nodes,Throughput(Mbps),AvgDelay(ms),PacketLoss(%),RxPackets,TxPackets" << std::endl;
    
    std::cout << "\n========================================" << std::endl;
    std::cout << "Simulation Results Summary" << std::endl;
    std::cout << "========================================" << std::endl;
    std::cout << "Nodes\tThroughput\tAvg Delay\tPacket Loss\tRx Pkts\tTx Pkts" << std::endl;
    std::cout << "\t(Mbps)\t\t(ms)\t\t(%)" << std::endl;
    std::cout << "------------------------------------------------------------------------" << std::endl;
    
    for (const auto& metrics : allMetrics) {
        std::cout << metrics.numNodes << "\t"
                  << std::fixed << std::setprecision(2) << metrics.throughput << "\t\t"
                  << metrics.avgDelay << "\t\t"
                  << metrics.packetLoss << "\t\t"
                  << metrics.rxPackets << "\t"
                  << metrics.txPackets << std::endl;
        
        outFile << metrics.numNodes << ","
                << metrics.throughput << ","
                << metrics.avgDelay << ","
                << metrics.packetLoss << ","
                << metrics.rxPackets << ","
                << metrics.txPackets << std::endl;
    }
    
    outFile.close();
    
    std::cout << "========================================" << std::endl;
    std::cout << "Results written to: " << outputFile << std::endl;
    std::cout << "========================================\n" << std::endl;
    
    return 0;
}