/*
 * Copyright (c) 2020, University of Padova, Dep. of Information Engineering, SIGNET lab
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

/**
 * This is an example on how to configure the channel model classes to simulate
 * a vehicular environment.
 * The channel condition is determined using the model specified in [1], Table 6.2-1.
 * The pathloss is determined using the model specified in [1], Table 6.2.1-1.
 * The model for the fast fading is the one described in 3GPP TR 38.901 v15.0.0,
 * the model parameters are those specified in [1], Table 6.2.3-1.
 *
 * This example generates the output file 'example-output.txt'. Each row of the
 * file is organized as follows:
 * Time[s] TxPosX[m] TxPosY[m] RxPosX[m] RxPosY[m] ChannelState SNR[dB] Pathloss[dB]
 * We also provide a bash script which reads the output file and generates two
 * figures:
 * (i) map.gif, a GIF representing the simulation scenario and vehicle mobility;
 * (ii) snr.png, which represents the behavior of the SNR.
 *
 * [1] 3GPP TR 37.885, v15.3.0
 */

#include "ns3/buildings-module.h"
#include "ns3/core-module.h"
#include "ns3/mobility-module.h"
#include "ns3/network-module.h"
#include "ns3/spectrum-signal-parameters.h"
#include "ns3/three-gpp-channel-model.h"
#include "ns3/three-gpp-spectrum-propagation-loss-model.h"
#include "ns3/three-gpp-v2v-propagation-loss-model.h"
#include "ns3/uniform-planar-array.h"

#include <fstream>

using namespace ns3;

NS_LOG_COMPONENT_DEFINE("ThreeGppV2vChannelExample");

static Ptr<ThreeGppPropagationLossModel>
    m_propagationLossModel; //!< the PropagationLossModel object
static Ptr<ThreeGppSpectrumPropagationLossModel>
    m_spectrumLossModel;                       //!< the SpectrumPropagationLossModel object
static Ptr<ChannelConditionModel> m_condModel; //!< the ChannelConditionModel object

/*
 * \brief A structure that holds the parameters for the ComputeSnr
 * function. In this way the problem with the limited
 * number of parameters of method Schedule is avoided.
 */
struct ComputeSnrParams
{
    Ptr<MobilityModel> txMob;               //!< the tx mobility model
    Ptr<MobilityModel> rxMob;               //!< the rx mobility model
    Ptr<SpectrumSignalParameters> txParams; //!< the params of the tx signal
    double noiseFigure;                     //!< the noise figure in dB
    Ptr<PhasedArrayModel> txAntenna;        //!< the tx antenna array
    Ptr<PhasedArrayModel> rxAntenna;        //!< the rx antenna array
};

/**
 * Perform the beamforming using the DFT beamforming method
 * \param thisDevice the device performing the beamforming
 * \param thisAntenna the antenna object associated to thisDevice
 * \param otherDevice the device towards which point the beam
 */
static void
DoBeamforming(Ptr<NetDevice> thisDevice,
              Ptr<PhasedArrayModel> thisAntenna,
              Ptr<NetDevice> otherDevice)
{
    PhasedArrayModel::ComplexVector antennaWeights;

    // retrieve the position of the two devices
    Vector aPos = thisDevice->GetNode()->GetObject<MobilityModel>()->GetPosition();
    Vector bPos = otherDevice->GetNode()->GetObject<MobilityModel>()->GetPosition();

    // compute the azimuth and the elevation angles
    Angles completeAngle(bPos, aPos);

    PhasedArrayModel::ComplexVector bf = thisAntenna->GetBeamformingVector(completeAngle);
    thisAntenna->SetBeamformingVector(bf);
}

/**
 * Compute the average SNR
 * \param params A structure that holds a bunch of parameters needed by ComputSnr function to
 * calculate the average SNR
 */
static void
ComputeSnr(const ComputeSnrParams& params)
{
    // check the channel condition
    Ptr<ChannelCondition> cond = m_condModel->GetChannelCondition(params.txMob, params.rxMob);

    // apply the pathloss
    double propagationGainDb = m_propagationLossModel->CalcRxPower(0, params.txMob, params.rxMob);
    NS_LOG_DEBUG("Pathloss " << -propagationGainDb << " dB");
    double propagationGainLinear = std::pow(10.0, (propagationGainDb) / 10.0);
    *(params.txParams->psd) *= propagationGainLinear;

    // apply the fast fading and the beamforming gain
    Ptr<SpectrumValue> rxPsd = m_spectrumLossModel->CalcRxPowerSpectralDensity(params.txParams,
                                                                               params.txMob,
                                                                               params.rxMob,
                                                                               params.txAntenna,
                                                                               params.rxAntenna);
    NS_LOG_DEBUG("Average rx power " << 10 * log10(Sum(*rxPsd) * 180e3) << " dB");

    // create the noise psd
    // taken from lte-spectrum-value-helper
    const double kT_dBm_Hz = -174.0; // dBm/Hz
    double kT_W_Hz = std::pow(10.0, (kT_dBm_Hz - 30) / 10.0);
    double noiseFigureLinear = std::pow(10.0, params.noiseFigure / 10.0);
    double noisePowerSpectralDensity = kT_W_Hz * noiseFigureLinear;
    Ptr<SpectrumValue> noisePsd = Create<SpectrumValue>(params.txParams->psd->GetSpectrumModel());
    (*noisePsd) = noisePowerSpectralDensity;

    // compute the SNR
    NS_LOG_DEBUG("Average SNR " << 10 * log10(Sum(*rxPsd) / Sum(*noisePsd)) << " dB");

    // print the SNR and pathloss values in the snr-trace.txt file
    std::ofstream f;
    f.open("example-output.txt", std::ios::out | std::ios::app);
    f << Simulator::Now().GetSeconds() << " " // time [s]
      << params.txMob->GetPosition().x << " " << params.txMob->GetPosition().y << " "
      << params.rxMob->GetPosition().x << " " << params.rxMob->GetPosition().y << " "
      << cond->GetLosCondition() << " "                  // channel state
      << 10 * log10(Sum(*rxPsd) / Sum(*noisePsd)) << " " // SNR [dB]
      << -propagationGainDb << std::endl;                // pathloss [dB]
    f.close();
}

/**
 * Generates a GNU-plottable file representing the buildings deployed in the
 * scenario
 * \param filename the name of the output file
 */
void
PrintGnuplottableBuildingListToFile(std::string filename)
{
    std::ofstream outFile;
    outFile.open(filename, std::ios_base::out | std::ios_base::trunc);
    if (!outFile.is_open())
    {
        NS_LOG_ERROR("Can't open file " << filename);
        return;
    }
    uint32_t index = 0;
    for (BuildingList::Iterator it = BuildingList::Begin(); it != BuildingList::End(); ++it)
    {
        ++index;
        Box box = (*it)->GetBoundaries();
        outFile << "set object " << index << " rect from " << box.xMin << "," << box.yMin << " to "
                << box.xMax << "," << box.yMax << std::endl;
    }
}

int
main(int argc, char* argv[])
{
    double frequency = 28.0e9;          // operating frequency in Hz
    double txPow_dbm = 30.0;            // tx power in dBm
    double noiseFigure = 9.0;           // noise figure in dB
    Time simTime = Seconds(40);         // simulation time
    Time timeRes = MilliSeconds(10);    // time resolution
    std::string scenario = "V2V-Urban"; // 3GPP propagation scenario, V2V-Urban or V2V-Highway
    double vScatt = 0;                  // maximum speed of the vehicles in the scenario [m/s]
    double subCarrierSpacing = 60e3;    // subcarrier spacing in kHz
    uint32_t numRb = 275;               // number of resource blocks

    CommandLine cmd(__FILE__);
    cmd.AddValue("frequency", "operating frequency in Hz", frequency);
    cmd.AddValue("txPow", "tx power in dBm", txPow_dbm);
    cmd.AddValue("noiseFigure", "noise figure in dB", noiseFigure);
    cmd.AddValue("scenario", "3GPP propagation scenario, V2V-Urban or V2V-Highway", scenario);
    cmd.Parse(argc, argv);

    // create the nodes
    NodeContainer nodes;
    nodes.Create(2);

    // create the tx and rx devices
    Ptr<SimpleNetDevice> txDev = CreateObject<SimpleNetDevice>();
    Ptr<SimpleNetDevice> rxDev = CreateObject<SimpleNetDevice>();

    // associate the nodes and the devices
    nodes.Get(0)->AddDevice(txDev);
    txDev->SetNode(nodes.Get(0));
    nodes.Get(1)->AddDevice(rxDev);
    rxDev->SetNode(nodes.Get(1));

    // create the antenna objects and set their dimensions
    Ptr<PhasedArrayModel> txAntenna =
        CreateObjectWithAttributes<UniformPlanarArray>("NumColumns",
                                                       UintegerValue(2),
                                                       "NumRows",
                                                       UintegerValue(2),
                                                       "BearingAngle",
                                                       DoubleValue(-M_PI / 2));
    Ptr<PhasedArrayModel> rxAntenna =
        CreateObjectWithAttributes<UniformPlanarArray>("NumColumns",
                                                       UintegerValue(2),
                                                       "NumRows",
                                                       UintegerValue(2),
                                                       "BearingAngle",
                                                       DoubleValue(M_PI / 2));

    Ptr<MobilityModel> txMob;
    Ptr<MobilityModel> rxMob;
    if (scenario == "V2V-Urban")
    {
        // 3GPP defines that the maximum speed in urban scenario is 60 km/h
        vScatt = 60 / 3.6;

        // create a grid of buildings
        double buildingSizeX = 250 - 3.5 * 2 - 3; // m
        double buildingSizeY = 433 - 3.5 * 2 - 3; // m
        double streetWidth = 20;                  // m
        double buildingHeight = 10;               // m
        uint32_t numBuildingsX = 2;
        uint32_t numBuildingsY = 2;
        double maxAxisX = (buildingSizeX + streetWidth) * numBuildingsX;
        double maxAxisY = (buildingSizeY + streetWidth) * numBuildingsY;

        std::vector<Ptr<Building>> buildingVector;
        for (uint32_t buildingIdX = 0; buildingIdX < numBuildingsX; ++buildingIdX)
        {
            for (uint32_t buildingIdY = 0; buildingIdY < numBuildingsY; ++buildingIdY)
            {
                Ptr<Building> building;
                building = CreateObject<Building>();

                building->SetBoundaries(
                    Box(buildingIdX * (buildingSizeX + streetWidth),
                        buildingIdX * (buildingSizeX + streetWidth) + buildingSizeX,
                        buildingIdY * (buildingSizeY + streetWidth),
                        buildingIdY * (buildingSizeY + streetWidth) + buildingSizeY,
                        0.0,
                        buildingHeight));
                building->SetNRoomsX(1);
                building->SetNRoomsY(1);
                building->SetNFloors(1);
                buildingVector.push_back(building);
            }
        }

        // set the mobility model
        double vTx = vScatt;
        double vRx = vScatt / 2;
        txMob = CreateObject<WaypointMobilityModel>();
        rxMob = CreateObject<WaypointMobilityModel>();
        Time nextWaypoint = Seconds(0.0);
        txMob->GetObject<WaypointMobilityModel>()->AddWaypoint(
            Waypoint(nextWaypoint, Vector(maxAxisX / 2 - streetWidth / 2, 1.0, 1.5)));
        nextWaypoint += Seconds((maxAxisY - streetWidth) / 2 / vTx);
        txMob->GetObject<WaypointMobilityModel>()->AddWaypoint(
            Waypoint(nextWaypoint,
                     Vector(maxAxisX / 2 - streetWidth / 2, maxAxisY / 2 - streetWidth / 2, 1.5)));
        nextWaypoint += Seconds((maxAxisX - streetWidth) / 2 / vTx);
        txMob->GetObject<WaypointMobilityModel>()->AddWaypoint(
            Waypoint(nextWaypoint, Vector(0.0, maxAxisY / 2 - streetWidth / 2, 1.5)));
        nextWaypoint = Seconds(0.0);
        rxMob->GetObject<WaypointMobilityModel>()->AddWaypoint(
            Waypoint(nextWaypoint, Vector(maxAxisX / 2 - streetWidth / 2, 0.0, 1.5)));
        nextWaypoint += Seconds(maxAxisY / vRx);
        rxMob->GetObject<WaypointMobilityModel>()->AddWaypoint(
            Waypoint(nextWaypoint, Vector(maxAxisX / 2 - streetWidth / 2, maxAxisY, 1.5)));

        nodes.Get(0)->AggregateObject(txMob);
        nodes.Get(1)->AggregateObject(rxMob);

        // create the channel condition model
        m_condModel = CreateObject<ThreeGppV2vUrbanChannelConditionModel>();

        // create the propagation loss model
        m_propagationLossModel = CreateObject<ThreeGppV2vUrbanPropagationLossModel>();
    }
    else if (scenario == "V2V-Highway")
    {
        // Two vehicles are travelling one behid the other with constant velocity
        // along the y axis. The distance between the two vehicles is 20 meters.

        // 3GPP defines that the maximum speed in urban scenario is 140 km/h
        vScatt = 140 / 3.6;
        double vTx = vScatt;
        double vRx = vScatt / 2;

        txMob = CreateObject<ConstantVelocityMobilityModel>();
        rxMob = CreateObject<ConstantVelocityMobilityModel>();
        txMob->GetObject<ConstantVelocityMobilityModel>()->SetPosition(Vector(300.0, 20.0, 1.5));
        txMob->GetObject<ConstantVelocityMobilityModel>()->SetVelocity(Vector(0.0, vTx, 0.0));
        rxMob->GetObject<ConstantVelocityMobilityModel>()->SetPosition(Vector(300.0, 0.0, 1.5));
        rxMob->GetObject<ConstantVelocityMobilityModel>()->SetVelocity(Vector(0.0, vRx, 0.0));

        nodes.Get(0)->AggregateObject(txMob);
        nodes.Get(1)->AggregateObject(rxMob);

        // create the channel condition model
        m_condModel = CreateObject<ThreeGppV2vHighwayChannelConditionModel>();

        // create the propagation loss model
        m_propagationLossModel = CreateObject<ThreeGppV2vHighwayPropagationLossModel>();
    }
    else
    {
        NS_FATAL_ERROR("Unknown scenario");
    }

    m_condModel->SetAttribute("UpdatePeriod", TimeValue(MilliSeconds(100)));

    m_propagationLossModel->SetAttribute("Frequency", DoubleValue(frequency));
    m_propagationLossModel->SetAttribute("ShadowingEnabled", BooleanValue(false));
    m_propagationLossModel->SetAttribute("ChannelConditionModel", PointerValue(m_condModel));

    // create the channel model
    Ptr<ThreeGppChannelModel> channelModel = CreateObject<ThreeGppChannelModel>();
    channelModel->SetAttribute("Scenario", StringValue(scenario));
    channelModel->SetAttribute("Frequency", DoubleValue(frequency));
    channelModel->SetAttribute("ChannelConditionModel", PointerValue(m_condModel));
    channelModel->SetAttribute("vScatt", DoubleValue(vScatt));

    // create the spectrum propagation loss model
    m_spectrumLossModel = CreateObjectWithAttributes<ThreeGppSpectrumPropagationLossModel>(
        "ChannelModel",
        PointerValue(channelModel));

    BuildingsHelper::Install(nodes);

    // set the beamforming vectors
    DoBeamforming(txDev, txAntenna, rxDev);
    DoBeamforming(rxDev, rxAntenna, txDev);

    // create the tx power spectral density
    Bands rbs;
    double freqSubBand = frequency;
    for (uint32_t n = 0; n < numRb; ++n)
    {
        BandInfo rb;
        rb.fl = freqSubBand;
        freqSubBand += subCarrierSpacing / 2;
        rb.fc = freqSubBand;
        freqSubBand += subCarrierSpacing / 2;
        rb.fh = freqSubBand;
        rbs.push_back(rb);
    }
    Ptr<SpectrumModel> spectrumModel = Create<SpectrumModel>(rbs);
    Ptr<SpectrumValue> txPsd = Create<SpectrumValue>(spectrumModel);
    Ptr<SpectrumSignalParameters> txParams = Create<SpectrumSignalParameters>();
    double txPow_w = std::pow(10., (txPow_dbm - 30) / 10);
    double txPowDens = (txPow_w / (numRb * subCarrierSpacing));
    (*txPsd) = txPowDens;
    txParams->psd = txPsd->Copy();

    for (int i = 0; i < simTime / timeRes; i++)
    {
        ComputeSnrParams params{txMob, rxMob, txParams, noiseFigure, txAntenna, rxAntenna};
        Simulator::Schedule(timeRes * i, &ComputeSnr, params);
    }

    // initialize the output file
    std::ofstream f;
    f.open("example-output.txt", std::ios::out);
    f << "Time[s] TxPosX[m] TxPosY[m] RxPosX[m] RxPosY[m] ChannelState SNR[dB] Pathloss[dB]"
      << std::endl;
    f.close();

    // print the list of buildings to file
    PrintGnuplottableBuildingListToFile("buildings.txt");

    Simulator::Run();
    Simulator::Destroy();
    return 0;
}