FlightPlan * RequestManager::createFlightPlanFromJson(const QVariantMap &jsonObject)
{
    FlightPlan *fp = new FlightPlan();

    // M633 header timestamp

    fp->M633Header().timestamp().day(QDate::currentDate().day());
    fp->M633Header().timestamp().month(QDate::currentDate().month());
    fp->M633Header().timestamp().year(QDate::currentDate().year());
    fp->M633Header().timestamp().hours(QTime::currentTime().hour());
    fp->M633Header().timestamp().minutes(QTime::currentTime().minute());

    // M633 header version number

    fp->M633Header().versionNumber().base_value(3);

    // flight origin date

    QString jsonEtdString = jsonObject.value("estimatedOffBlockTime").toString();
    QDateTime jsonEtd = QDateTime::fromString(jsonEtdString, Qt::ISODate).toUTC();

    fp->M633SupplementaryHeader().Flight().flightOriginDate().day(  jsonEtd.date().day());
    fp->M633SupplementaryHeader().Flight().flightOriginDate().month(jsonEtd.date().month());
    fp->M633SupplementaryHeader().Flight().flightOriginDate().year( jsonEtd.date().year());

    fp->M633SupplementaryHeader().Flight().scheduledTimeOfDeparture_present(true);
    fp->M633SupplementaryHeader().Flight().scheduledTimeOfDeparture().day(    jsonEtd.date().day());
    fp->M633SupplementaryHeader().Flight().scheduledTimeOfDeparture().month(  jsonEtd.date().month());
    fp->M633SupplementaryHeader().Flight().scheduledTimeOfDeparture().year(   jsonEtd.date().year());
    fp->M633SupplementaryHeader().Flight().scheduledTimeOfDeparture().hours(  jsonEtd.time().hour());
    fp->M633SupplementaryHeader().Flight().scheduledTimeOfDeparture().minutes(jsonEtd.time().minute());

    // flight identification

    QString fid = jsonObject.value("aircraftId").toString();

    fp->M633SupplementaryHeader().Flight().FlightIdentification().choice_arm(FlightIdentificationType::sequence_tag);
    fp->M633SupplementaryHeader().Flight().FlightIdentification().sequence().FlightIdentifier().basic_string::operator=(fid.toStdString());

    // departure airport

    QVariantMap jsonDeparture = jsonObject.value("departure").toMap();
    QString depAirportName = jsonDeparture["airport"].toString();
    QString depAirportIata = jsonDeparture["iata"].toString();
    QString depAirportIcao = jsonDeparture["icao"].toString();

    fp->M633SupplementaryHeader().Flight().DepartureAirport().airportName_present(true);
    fp->M633SupplementaryHeader().Flight().DepartureAirport().airportName().basic_string::operator=(depAirportName.toStdString());
    fp->M633SupplementaryHeader().Flight().DepartureAirport().choice_arm(AirportIdentificationType::sequence_tag);
    fp->M633SupplementaryHeader().Flight().DepartureAirport().sequence().AirportIATACode_present(true);
    fp->M633SupplementaryHeader().Flight().DepartureAirport().sequence().AirportIATACode().basic_string::operator=(depAirportIata.toStdString());
    fp->M633SupplementaryHeader().Flight().DepartureAirport().sequence().AirportICAOCode().basic_string::operator=(depAirportIcao.toStdString());

    // arrival airport

    QVariantMap jsonArrival = jsonObject.value("destination").toMap();
    QString arrAirportName = jsonArrival["airport"].toString();
    QString arrAirportIata = jsonArrival["iata"].toString();
    QString arrAirportIcao = jsonArrival["icao"].toString();

    fp->M633SupplementaryHeader().Flight().ArrivalAirport().airportName_present(true);
    fp->M633SupplementaryHeader().Flight().ArrivalAirport().airportName().basic_string::operator=(arrAirportName.toStdString());
    fp->M633SupplementaryHeader().Flight().ArrivalAirport().choice_arm(AirportIdentificationType::sequence_tag);
    fp->M633SupplementaryHeader().Flight().ArrivalAirport().sequence().AirportIATACode_present(true);
    fp->M633SupplementaryHeader().Flight().ArrivalAirport().sequence().AirportIATACode().basic_string::operator=(arrAirportIata.toStdString());
    fp->M633SupplementaryHeader().Flight().ArrivalAirport().sequence().AirportICAOCode().basic_string::operator=(arrAirportIcao.toStdString());

    // aircraft registration

    QString acReg = jsonObject.value("registrationMark").toString();
    QString acType = jsonObject.value("aircraftType").toString();

    fp->M633SupplementaryHeader().Aircraft().aircraftRegistration().basic_string::operator=(acReg.toStdString());
    fp->M633SupplementaryHeader().Aircraft().AircraftModel().AircraftICAOType().basic_string::operator=(acType.toStdString());

    // waypoints

    QVariantList waypoints = jsonObject.value("routeDetails").toMap().value("features").toList();

    fp->Waypoints(new Waypoints());
    //qDebug() << waypoints.size();

    for (const QVariant &var_waypoint : waypoints)
    {
        QVariantMap jsonWaypointGeometry = var_waypoint.toMap().value("geometry").toMap();
        QVariantMap jsonWaypointProperty = var_waypoint.toMap().value("properties").toMap();

        WaypointType * waypoint = new WaypointType();

        // sequence id and passed attribute

        int seq = jsonWaypointProperty.value("pointIndex").toDouble();

        waypoint->sequenceId_present(true);
        waypoint->sequenceId(seq);

        waypoint->passed_present(true);
        waypoint->passed(false);

        // icao, name and long name

        QString jsonName = jsonWaypointProperty.value("designator").toString();
        QString jsonLongName = jsonWaypointProperty.value("pointName").toString();

        waypoint->waypointLongName_present(true);
        waypoint->waypointName_present(true);
        waypoint->waypointId_present(true);

        if (jsonLongName.isEmpty())
            waypoint->waypointLongName().basic_string::operator=(jsonName.toStdString());
        else
            waypoint->waypointLongName().basic_string::operator=(jsonLongName.toStdString());

        waypoint->waypointName().basic_string::operator=(jsonName.toStdString());
        waypoint->waypointId().basic_string::operator=(jsonName.toStdString());

        // coordinates

        if (jsonWaypointGeometry.value("coordinates").toList().size() >= 2)
        {
            double lon = jsonWaypointGeometry.value("coordinates").toList().at(0).toDouble();
            double lat = jsonWaypointGeometry.value("coordinates").toList().at(1).toDouble();

            waypoint->Coordinates_present(true);
            waypoint->Coordinates().latitude().base_value(MathUtils::convert(MathUtils::Hour, MathUtils::Second, lat));
            waypoint->Coordinates().longitude().base_value(MathUtils::convert(MathUtils::Hour, MathUtils::Second, lon));
        }

        // airway

        QString airway = jsonWaypointProperty.value("onRoute").toString();

        waypoint->Airway_present(true);
        waypoint->Airway().basic_string::operator=(airway.toStdString());
        waypoint->Airway().type_present(true);

        // altitude

        double alt = jsonWaypointProperty.value("flightRule").toMap().value("altitude").toDouble();

        waypoint->Altitude_present(true);
        waypoint->Altitude().EstimatedAltitude().Value().unit(altitudeUnitType::ft_100);
        waypoint->Altitude().EstimatedAltitude().Value().base_value(alt);

        // ground speed

        double spd = jsonWaypointProperty.value("flightRule").toMap().value("speed").toString().toDouble();

        waypoint->GroundSpeed_present(true);
        waypoint->GroundSpeed().EstimatedSpeed().Value().unit(speedUnitType::kt);
        waypoint->GroundSpeed().EstimatedSpeed().Value().base_value(spd);

        // distance

        double dist = jsonWaypointProperty.value("distanceFromPreviousPoint").toDouble();

        waypoint->GroundDistance_present(true);
        waypoint->GroundDistance().Value().unit(distanceUnitType::NM);
        waypoint->GroundDistance().Value().base_value(dist);

        // timeOverWaypoint

        qint64 elapsed = jsonWaypointProperty.value("estimatedElapsedTime").toDouble();
        QDateTime jsonTime = jsonEtd.addSecs(elapsed * 60);

        waypoint->TimeOverWaypoint_present(true);
        waypoint->TimeOverWaypoint().EstimatedTime().Value().day(    jsonTime.date().day());
        waypoint->TimeOverWaypoint().EstimatedTime().Value().month(  jsonTime.date().month());
        waypoint->TimeOverWaypoint().EstimatedTime().Value().year(   jsonTime.date().year());
        waypoint->TimeOverWaypoint().EstimatedTime().Value().minutes(jsonTime.time().minute());
        waypoint->TimeOverWaypoint().EstimatedTime().Value().hours(  jsonTime.time().hour());

        // add waypoint
        fp->Waypoints().Waypoint().push_back(waypoint);
    }

    // estimated time of arrival

    QString jsonEtaString = jsonObject.value("estimatedArrivalTime").toString();
    QDateTime jsonEta = QDateTime::fromString(jsonEtaString, Qt::ISODate).toUTC();

    fp->FlightPlanSummary_present(true);
    fp->FlightPlanSummary().ScheduledTimeOfArrival_present(true);
    fp->FlightPlanSummary().ScheduledTimeOfArrival().year(jsonEta.date().year());
    fp->FlightPlanSummary().ScheduledTimeOfArrival().month(jsonEta.date().month());
    fp->FlightPlanSummary().ScheduledTimeOfArrival().day(jsonEta.date().day());
    fp->FlightPlanSummary().ScheduledTimeOfArrival().hours(jsonEta.time().hour());
    fp->FlightPlanSummary().ScheduledTimeOfArrival().minutes(jsonEta.time().minute());

    // test
//    for (size_t i = 0; i < fp->Waypoints().Waypoint().size(); ++i) {
//        WaypointType *wpt = &fp->Waypoints().Waypoint()[i];
//        qDebug() << QString(wpt->waypointName().data()) << wpt->Coordinates().latitude().base_value() << wpt->Coordinates().longitude().base_value();
//    }

    return fp;
}