rng('default'); % Reset the random number generator
simParameters = []; % Clear the simParameters variable

simParameters.NumFramesSim = 100; % Simulation time in terms of number of 10 ms frames
% Number of UEs in the simulation. UEs are assumed to have sequential radio
% network temporary identifiers (RNTIs) from 1 to NumUEs. If you change the
% number of UEs, ensure that the length of simParameters.UEDistance is equal to NumUEs
simParameters.NumUEs = 4;
simParameters.UEDistance = [100 250 700 750]; % Distance of UEs from gNB (in meters)

% Set the channel bandwidth to 30 MHz and subcarrier spacing (SCS) to 15
% kHz as defined in 3GPP TS 38.104 Section 5.3.2. The complete UL and
% DL bandwidth is assumed to be allotted for PUSCH and PDSCH. The
% UL and DL carriers are assumed to have symmetric channel
% bandwidth
simParameters.NumRBs = 160;
simParameters.SCS = 15;

% Configure parameters to update UL channel quality at gNB and DL
% channel quality at gNB and UE. Channel conditions are periodically
% improved or deteriorated by CQIDelta every channelUpdatePeriodicity
% seconds for all RBs of a UE. Whether channel conditions for a particular
% UE improve or deteriorate is randomly determined
% RBCQI = RBCQI +/- CQIDelta
simParameters.ChannelUpdatePeriodicity = 0.2; % In sec
simParameters.CQIDelta = 2;
% Mapping between distance from gNB (first column in meters) and maximum
% achievable UL CQI value (second column). For example, if a UE is 700
% meters away from the gNB, it can achieve a maximum CQI value of 10 as the
% distance falls within the [501, 800] meters range, as per the mapping.
% Set the distance in increasing order and the maximum achievable CQI value in
% decreasing order
simParameters.CQIvsDistance = [
    200  15;
    500  12;
    800  10;
    1000  8;
    1200  7];
% Expression to calculate reception success probability of a PUSCH and
% PDSCH TBs based on the channel quality. 'x' represents the average CQI of
% the RBs over which the PUSCH and PDSCH packets are received
simParameters.CQISuccessProb = '.5 + (x/20)';

simParameters.BSRPeriodicity = 5; % In ms
simParameters.EnableHARQ = true; % Flag to enable or disable HARQ. If disabled, there are no retransmissions
simParameters.NumHARQ = 16; % Number of HARQ processes in UEs

% Set the scheduler run periodicity in terms of number of slots. Value must
% be less than the number of slots in a 10 ms frame
simParameters.SchedulerPeriodicity = 4;
simParameters.SchedulerStrategy = 'PF'; % Supported scheduling strategies: 'PF', 'RR' and 'BestCQI'
% Moving average parameter within the range [0, 1] to calculate average
% data rate for a UE in either UL and DL. This value is used in
% the PF scheduling strategy. Parameter value closer to 1 implies more
% weight on the instantaneous data rate. Parameter value closer to 0
% implies more weight on the past data rate
% AverageDataRate = ((1 - MovingAvgDataRateWeight) * PastDataRate) + (MovingAvgDataRateWeight * InstantaneousDataRate)
simParameters.MovingAvgDataRateWeight = 0.5;
% gNB ensures that PUSCH assignment is received at UEs PUSCHPrepTime ahead
% of the transmission time
simParameters.PUSCHPrepTime = 200; % In microseconds
% Maximum RBs allotted to a UE in a slot for the UL and DL
% transmission (limit is applicable for new PUSCH and PDSCH assignments and
% not for the retransmissions)
simParameters.RBAllocationLimitUL = 100; % For PUSCH
simParameters.RBAllocationLimitDL = 100; % For PDSCH

load('NRFDDRLCChannelConfig.mat')
simParameters.RLCChannelConfig = RLCChannelConfig;

load('NRFDDAppConfig.mat');
simParameters.AppConfig = AppConfig;

% The parameters CQIVisualization and RBVisualization control the display
% of these visualizations: (i) CQI visualization of RBs (ii) RB assignment
% visualization. By default, these plots are disabled. You can enable them
% by setting to 'true'
simParameters.CQIVisualization = false;
simParameters.RBVisualization = false;
% The output metrics plots are updated periodically NumMetricsSteps times within the
% simulation duration
simParameters.NumMetricsSteps = 20;
% MAT-files to write the logs into. They are used for post simulation analysis and visualization
simParameters.ParametersLogFile = 'simParameters'; % For logging the simulation parameters
simParameters.SimulationLogFile = 'simulationLogs'; % For logging the simulation logs

% Validate the simulation configuration
hNRSchedulingFDDValidateConfig(simParameters);

simParameters.DuplexMode = 0; % FDD
% Slot duration for the selected SCS and number of slots in a 10 ms frame
slotDuration = 1/(simParameters.SCS/15); % In ms
numSlotsFrame = 10/slotDuration; % Number of slots in a 10 ms frame
numSlotsSim = simParameters.NumFramesSim * numSlotsFrame; % Number of slots in the simulation

% Periodicity of channel update in terms of number of slots
channelUpdatePeriodicitySlots = floor((simParameters.ChannelUpdatePeriodicity * 1000)/ ...
    slotDuration);

% Calculate maximum achievable CQI value for the UEs based on their distance from
% the gNB
maxUECQIs = zeros(simParameters.NumUEs, 1); % To store the maximum achievable CQI value for UEs
for ueIdx = 1:simParameters.NumUEs
    % Based on the distance of the UE from gNB, find matching row in
    % CQIvsDistance mapping
    matchingRowIdx = find(simParameters.CQIvsDistance(:, 1) > simParameters.UEDistance(ueIdx));
    if isempty(matchingRowIdx)
        maxUECQIs(ueIdx) = simParameters.CQIvsDistance(end, 2);
    else
        maxUECQIs(ueIdx) = simParameters.CQIvsDistance(matchingRowIdx(1), 2);
    end
end

% Interval at which metrics visualization updates in terms of number of
% slots. As one slot is the finest time-granularity of the simulation, make
% sure that MetricsStepSize is an integer
simParameters.MetricsStepSize = ceil(numSlotsSim / simParameters.NumMetricsSteps);
if mod(numSlotsSim, simParameters.NumMetricsSteps) ~= 0
    % Update the NumMetricsSteps parameter if NumSlotsSim is not
    % completely divisible by it
    simParameters.NumMetricsSteps = floor(numSlotsSim / simParameters.MetricsStepSize);
end

gNB = hNRGNB(simParameters); % Create gNB node
scheduler = hNRGNBMACScheduler(simParameters); % Create scheduler
addScheduler(gNB, scheduler); % Add scheduler to gNB

% Create the set of UE nodes
UEs = cell(simParameters.NumUEs, 1);
for ueIdx=1:simParameters.NumUEs
    UEs{ueIdx} = hNRUE(simParameters, ueIdx);
end

% Define initial UL and DL channel quality as an N-by-P matrix,
% where N is the number of UEs and P is the number of RBs in the carrier
% bandwidth. The initial value of CQI for each RB, for each UE, is given
% randomly and is limited by the maximum achievable CQI value corresponding
% to the distance of the UE from gNB
uplinkChannelQuality = zeros(simParameters.NumUEs, simParameters.NumRBs); % To store current UL CQI values on the RBs for different UEs
downlinkChannelQuality = zeros(simParameters.NumUEs, simParameters.NumRBs); % To store current DL CQI values on the RBs for different UEs
for ueIdx = 1:simParameters.NumUEs
    % Assign random CQI values for the RBs, limited by the maximum achievable CQI value
    uplinkChannelQuality(ueIdx, :) = randi([1 maxUECQIs(ueIdx)], 1, simParameters.NumRBs);
    % Update the UL CQI values at gNB
    updateChannelQualityStatus(gNB, uplinkChannelQuality(ueIdx, :), 1, ueIdx); % 1 for UL
    
    % Initially, DL and UL CQI values are assumed to be equal
    downlinkChannelQuality(ueIdx, :) = uplinkChannelQuality(ueIdx, :);
    % Update the DL CQI values at gNB and UE. The DL CQI values
    % help gNB in scheduling, and UE in packet error probability estimation
    updateChannelQualityStatus(gNB, downlinkChannelQuality(ueIdx, :), 0, ueIdx); % 0 for DL
    updateChannelQualityStatus(UEs{ueIdx}, downlinkChannelQuality(ueIdx, :));
end

% Setup logical channels
for lchInfoIdx = 1:size(simParameters.RLCChannelConfig, 1)
    rlcChannelConfigStruct = table2struct(simParameters.RLCChannelConfig(lchInfoIdx, :));
    ueIdx = simParameters.RLCChannelConfig.RNTI(lchInfoIdx);
    % Setup the logical channel at gNB and UE
    gNB.configureLogicalChannel(ueIdx, rlcChannelConfigStruct);
    UEs{ueIdx}.configureLogicalChannel(ueIdx, rlcChannelConfigStruct);
end

% Initialize buffers to exchange packets between UEs and gNB
hNRPacketExchangeBuffer(simParameters);

% To store these UE metrics for each slot: throughput bytes
% transmitted, goodput bytes transmitted, and pending buffer amount bytes.
% The number of goodput bytes is calculated by excluding the
% retransmissions from the total transmissions
UESlotMetricsUL = zeros(simParameters.NumUEs, 3);
UESlotMetricsDL = zeros(simParameters.NumUEs, 3);

% To store the RLC statistics for each slot
ueRLCStats = cell(simParameters.NumUEs, 1);
gNBRLCStats = cell(simParameters.NumUEs, 1);

% Create an object for MAC (UL & DL) scheduling information visualization and logging
simSchedulingLogger = hNRSchedulingLogger(simParameters);

% To store the logical channel information associated per UE
lchInfo = repmat(struct('LCID',[],'EntityDir',[]), [simParameters.NumUEs 1]);
for ueIdx = 1:simParameters.NumUEs
    lchInfo(ueIdx).LCID = simParameters.RLCChannelConfig.LCID(simParameters.AppConfig.RNTI == ueIdx);
    lchInfo(ueIdx).EntityDir = simParameters.RLCChannelConfig.EntityDir(simParameters.AppConfig.RNTI == ueIdx);
end
% Create an object for RLC visualization and logging
simRLCLogger = hNRRLCLogger(simParameters, lchInfo);

symbolNum = 0;
% Run processing loop
for slotNum = 1:numSlotsSim

    % Update the UL and DL channel quality periodically
    if mod(slotNum, channelUpdatePeriodicitySlots) == 0
        for ueIdx = 1:simParameters.NumUEs
            uplinkCQIRBs = getChannelQualityStatus(gNB, 1, ueIdx); % Current UL CQI values
            downlinkCQIRBs = getChannelQualityStatus(gNB, 0, ueIdx); % Current DL CQI values
            % Update CQI values for RBs by randomly varying the current
            % values by CQIDelta, limited by the minimum and maximum
            % achievable CQI index value. You can customize the updating of
            % CQI values as necessary.
            updateType = [1 -1]; % Improvement/deterioration
            uplinkChannelQualityChange = updateType(randi(length(updateType)));
            downlinkChannelQualityChange = updateType(randi(length(updateType)));

            updatedCQIs = min(max(uplinkCQIRBs + simParameters.CQIDelta*uplinkChannelQualityChange, 1), maxUECQIs(ueIdx));
            % Update the UL channel quality at gNB (1 for UL)
            updateChannelQualityStatus(gNB, updatedCQIs, 1, ueIdx);

            updatedCQIs = min(max(downlinkCQIRBs + simParameters.CQIDelta*downlinkChannelQualityChange, 1), maxUECQIs(ueIdx));
            % Update the DL channel quality at gNB and UE (0 for DL)
            updateChannelQualityStatus(gNB, updatedCQIs, 0, ueIdx);
            updateChannelQualityStatus(UEs{ueIdx}, updatedCQIs);
        end
    end

    % Generate the UL and DL application traffic
    for ueIdx = 1:simParameters.NumUEs
        appConfigIndexList = find(simParameters.AppConfig.RNTI == ueIdx);
        % Receive data from upper layers based on application traffic
        % pattern
        for appIdx = 1:numel(appConfigIndexList)
            lcid = simParameters.AppConfig.LCID(appConfigIndexList(appIdx));
            % Application packet interval in terms of number of slots
            packetIntervalSlots = simParameters.AppConfig.PacketInterval(appConfigIndexList(appIdx))/slotDuration;
            if mod(slotNum, packetIntervalSlots) == 0
                packetSize = simParameters.AppConfig.PacketSize(appConfigIndexList(appIdx));
                deviceType = simParameters.AppConfig.HostDevice(appConfigIndexList(appIdx));
                % If the packet size is more than 9000 bytes, segment it
                % into multiples of 9000. In this case, the last segmented
                % packet need not be of 9000 bytes
                numRLCSDUs = ceil(packetSize / 9000);
                rlcSDU = randi([0 255], 9000, 1);
                for rlcSDUIdx = 1:numRLCSDUs
                    if (rlcSDUIdx == numRLCSDUs) && (mod(packetSize, 9000) ~= 0)
                        rlcSDU = randi([0 255], mod(packetSize, 9000), 1);
                    end
                    if (deviceType == 1) || (deviceType == 2)
                        % Send UL application traffic to UE RLC layer
                        receiveRLCSDU(UEs{ueIdx}, ueIdx, lcid , rlcSDU);
                    end
                    if (deviceType == 0) || (deviceType == 2)
                        % Send DL application traffic to gNB RLC layer
                        receiveRLCSDU(gNB, ueIdx, lcid , rlcSDU);
                    end
                end
            end
        end
    end

    % Run the gNB scheduler. Check if the scheduler is set to run in this
    % slot. If yes, schedule the resources and send the corresponding
    % UL assignments and DL assignments to UEs
    [resourceAssignmentsUL, resourceAssignmentsDL] = runSchedulerFDD(gNB);

    % Check if UL/DL assignments are done
    if ~isempty(resourceAssignmentsUL) || ~isempty(resourceAssignmentsDL)
        % Construct and send UL assignments and DL assignments to UEs
        controlTx(gNB, resourceAssignmentsUL, resourceAssignmentsDL);
    end

    % Run the Rx operation at UEs for simultaneous reception of control
    % packets
    for ueIdx = 1:simParameters.NumUEs
        controlRx(UEs{ueIdx}); % Receive UL assignments and DL assignments, if any sent by gNB
    end

    % Send the PDSCH packets, if any scheduled
    dataTx(gNB);
    % Read throughput and goodput bytes sent for each UE
    [UESlotMetricsDL(:, 1), UESlotMetricsDL(:, 2)] = getCurrTTIBytes(gNB);
    UESlotMetricsDL(:, 3) = getBufferStatus(gNB); % Read pending buffer (in bytes) on gNB

    % Send the UL packets, if any scheduled
    for ueIdx = 1:simParameters.NumUEs
        % UE sends the PUSCH packet if it is a Tx slot (as conveyed by gNB in earlier received UL assignments)
        dataTx(UEs{ueIdx});
        % Read throughput and goodput bytes transmitted for this UE in the current TTI (for logging purpose)
        [UESlotMetricsUL(ueIdx, 1), UESlotMetricsUL(ueIdx, 2)] = getCurrTTIBytes(UEs{ueIdx});
        UESlotMetricsUL(ueIdx, 3) = getBufferStatus(UEs{ueIdx}); % Read pending buffer (in bytes) on UE
        % UE sends BSR packet and PDSCH ACK/NACK
        controlTx(UEs{ueIdx});
    end

    rxResultUEsDL = cell(simParameters.NumUEs, 1);
    for ueIdx = 1:simParameters.NumUEs
        % Receive the PDSCH packets from gNB that are scheduled to
        % receive in this slot. Return the information of Rx
        % success/failure
        rxResultUEsDL{ueIdx} = dataRx(UEs{ueIdx});
    end

    % Receive the PUSCH packets from UEs that are scheduled to receive in
    % this slot. Return the information of Rx success/failure
    rxResultUEsUL = dataRx(gNB);
    % Run the Rx operation at gNB for simultaneous reception of control
    % packets
    controlRx(gNB); % Receive BSR and PDSCH ACK/NACK

    HARQProcessStatusUL = zeros(simParameters.NumUEs, simParameters.NumHARQ); % To store last sent HARQ process NDI flag
    HARQProcessStatusDL = zeros(simParameters.NumUEs, simParameters.NumHARQ); % To store last sent HARQ process NDI flag
    % Get RLC statistics, HARQ process context, and channel quality
    % information for logging purpose
    for ueIdx = 1:simParameters.NumUEs
        ueRLCStats{ueIdx} = getRLCStatistics(UEs{ueIdx}, ueIdx);
        gNBRLCStats{ueIdx} = getRLCStatistics(gNB, ueIdx);

        % Read the last received NDI flags for UE HARQ processes (for
        % logging purpose)
        HARQProcessStatusUL(ueIdx, :) = getLastNDIFlagHarq(UEs{ueIdx}, 1); % 1 for UL
        HARQProcessStatusDL(ueIdx, :) = getLastNDIFlagHarq(UEs{ueIdx}, 0); % 0 for DL

        % Read the UL channel quality at gNB for each of the UEs (For
        % logging purpose)
        uplinkChannelQuality(ueIdx,:) = getChannelQualityStatus(gNB, 1, ueIdx); % 1 for UL
        % Read the DL channel quality at gNB for each of the UEs (For
        % logging purpose)
        downlinkChannelQuality(ueIdx,:) = getChannelQualityStatus(gNB, 0, ueIdx); % 0 for DL
    end
    logRLCStats(simRLCLogger, ueRLCStats, gNBRLCStats);
    % Update scheduling logs based on the current slot run of UEs and gNB.
    % Logs are updated in each slot, RB grid visualizations are updated
    % every frame, and metrics plots are updated every metricsStepSize
    % slots
    logScheduling(simSchedulingLogger, symbolNum + 1, resourceAssignmentsUL, UESlotMetricsUL, uplinkChannelQuality, HARQProcessStatusUL, rxResultUEsUL, 1);
    logScheduling(simSchedulingLogger, symbolNum + 1, resourceAssignmentsDL, UESlotMetricsDL, downlinkChannelQuality, HARQProcessStatusDL, rxResultUEsDL, 0);

    % RB assignment visualization (if enabled)
    if simParameters.RBVisualization
        if mod(slotNum, numSlotsFrame) == 0
            plotRBGrids(simSchedulingLogger);
        end
    end

    % CQI grid visualization (if enabled)
    if simParameters.CQIVisualization
        if mod(slotNum, numSlotsFrame) == 0
            plotCQIRBGrids(simSchedulingLogger);
        end
    end

    % Plot scheduler metrics and RLC metrics visualization at slot
    % boundary, if the update periodicity is reached
    if mod(slotNum, simParameters.MetricsStepSize) == 0
        plotMetrics(simSchedulingLogger);
        plotMetrics(simRLCLogger);
    end

    % Advance timer ticks for gNB and UEs by the number of symbols per slot
    advanceTimer(gNB, 14);
    for ueIdx = 1:simParameters.NumUEs
        advanceTimer(UEs{ueIdx}, 14);
    end

    % Symbol number in the simulation
    symbolNum = symbolNum + 14; 
end

% Get MAC scheduling logs
[dlTimeStepLogs, ulTimeStepLogs] = getSchedulingLogs(simSchedulingLogger);
schedulingLogs = getGrantLogs(simSchedulingLogger); % Scheduling assignments log
% Get RLC statistics logs
rlcLogs = getRLCLogs(simRLCLogger);

save(simParameters.ParametersLogFile, 'simParameters'); % Save simulation parameters in a MAT-file
save(simParameters.SimulationLogFile, 'ulTimeStepLogs', ...
    'dlTimeStepLogs', 'schedulingLogs', 'rlcLogs'); % Save simulation logs in a MAT-file