app/sources/provider/brproviderdr.cpp

#include "brproviderdr.h"

BRProviderDr::BRProviderDr(QObject *parent) : BRProvider(parent)
{
    // leagues source:
    // - https://github.com/ralfbecker/ranking/blob/master/sitemgr/digitalrock/dav_calendar.php
    // - https://github.com/ralfbecker/ranking/blob/master/sitemgr/digitalrock/sac_calendar.php

    this->leagues.insert(
        BRWidget::DAV,
    {
        {
            {"id", 0},
            {"name", "Deutsche Meisterschaft"},
            {"color", "#A8F0A8"},
            {"leagueIDs", QVariantList({59, 57, 60})}
        },
        {
            {"id", 1},
            {"name", "Deutscher Jugendcup"},
            {"color", "#D8FFD8"},
            {"leagueIDs", QVariantList({58})}
        },
        {
            {"id", 2},
            {"name", "Landesmeisterschaft"},
            {"color", "#F0F0F0"},
            {"leagueIDs", QVariantList({61, 56})}
        }
    });

    this->leagues.insert(
        BRWidget::SAC,
    {
        {
            {"id", 0},
            {"name", "Erwachsene"},
            {"color", "#A8F0A8"},
            {"leagueIDs", QVariantList({57, 59, 60})}
        },
        {
            {"id", 1},
            {"name", "Jugend"},
            {"color", "#D8FFD8"},
            {"leagueIDs", QVariantList({65})}
        },
        {
            {"id", 2},
            {"name", "RegioCups"},
            {"color", "#F0F0F0"},
            {"leagueIDs", QVariantList({64})}
        },
        {
            {"id", 3},
            {"name", "Iceclimbing"},
            {"color", "#F0F0F0"},
            {"leagueIDs", QVariantList({84})}
        }
    });
}

BRWidget::BRWidgetStatusCode BRProviderDr::getWidgetData(BRCalendar::BRCalendarData*  calendarData)
{
    // load some data
    QString nationStr = calendarData->calendar->getFederation() == BRWidget::SAC ? "SUI":"GER";
    qDebug() << "Nation str: " << nationStr << " federation: " << calendarData->calendar->getFederation();
    int year = QDate::currentDate().year();
    QString requestUrl = "https://www.digitalrock.de/egroupware/ranking/json.php?nation=" + nationStr + "&year=" + QString::number(year);
    QVariantMap ret = this->serverRequest(QUrl(requestUrl));

    if(ret["status"] != 200) {
        // request was a failure
        return BRWidget::BRWidgetStatusCode(ret["status"].toInt());
    }

    QVariantMap data = QJsonDocument::fromJson(ret["text"].toString().toUtf8()).toVariant().toMap();
    data.insert("year", year);
    data.insert("federation", calendarData->calendar->getFederation());

    // create seasons
    QVariantList seasons = data["years"].toList();

    for(QVariant seasonVar : seasons) {
        int seasonId = seasonVar.toString().toInt();
        BRSeason* season = this->getSeason(
                               calendarData->calendar->getFederation(),
                               seasonId,
                               this->parseSeasonData(seasonId, data)
                           );

        calendarData->seasons.append(season);

        if(seasonId == year)
            calendarData->currentSeason = season;
    }

    return BRWidget::Success;
}

BRWidget::BRWidgetStatusCode BRProviderDr::getWidgetData(BRSeason::BRSeasonData*  seasonData) {

    // load some data
    QString nationStr = seasonData->season->getFederation() == BRWidget::SAC ? "SUI":"GER";
    qDebug() << "Nation str: " << nationStr << " federation: " << seasonData->season->getFederation();
    int year = seasonData->season->getYear();
    QString requestUrl = "https://www.digitalrock.de/egroupware/ranking/json.php?nation=" + nationStr + "&year=" + QString::number(year);
    QVariantMap ret = this->serverRequest(QUrl(requestUrl));

    if(ret["status"] != 200) {
        // request was a failure
        return BRWidget::BRWidgetStatusCode(ret["status"].toInt());
    }

    QVariantMap data = QJsonDocument::fromJson(ret["text"].toString().toUtf8()).toVariant().toMap();
    data.insert("year", year);
    data.insert("federation", seasonData->season->getFederation());

    // populate season
    QVariantList seasons = data["years"].toList();

    this->parseSeasonData(seasonData, year, data);

    return BRWidget::Success;
}

BRSeason::BRSeasonData BRProviderDr::parseSeasonData(int id, QVariantMap rawData) {
    BRSeason::BRSeasonData data;
    this->parseSeasonData(&data, id, rawData);
    return data;
}

void BRProviderDr::parseSeasonData(BRSeason::BRSeasonData* seasonData, int id, QVariantMap rawData) {
    seasonData->year = id;
    seasonData->nativeMultiLeagueSupport = true;
    seasonData->name = QString::number(id);

    qDebug() << "Parsing season: " << seasonData->name;

    BRWidget::BRFederation federation = BRWidget::BRFederation(rawData["federation"].toInt(0));

    // insert the leagues if the season is the current one
    if(seasonData->name == rawData["year"].toString())
        for(QVariantMap leagueVar : this->leagues[federation]) {
            BRLeague* league = this->getLeague(federation, leagueVar["id"].toInt(), this->parseLeagueData(leagueVar, rawData));
            seasonData->leagues.append(league);
        }
}

BRWidget::BRWidgetStatusCode BRProviderDr::getWidgetData(BRLeague::BRLeagueData*  leagueData) {
    Q_UNUSED(leagueData)
    return BRWidget::NotImplementedError;
}

BRLeague::BRLeagueData BRProviderDr::parseLeagueData(QVariantMap leagueProperties, QVariantMap rawData) {

    BRLeague::BRLeagueData data;

    BRWidget::BRFederation federation = BRWidget::BRFederation(rawData["federation"].toInt(0));

    data.name = leagueProperties["name"].toString();
    data.color = QColor(leagueProperties["color"].toString());
    data.enabled = true;

    qDebug() << "- Parsing league: " << data.name;

    // parse competitions
    QVariantList competitionsVar = rawData["competitions"].toList();

    // TODO: make more efficient

    for(QVariant competitionVar : competitionsVar) {
        QVariantMap competitionMap = competitionVar.toMap();

        // check if this competition is part of this league
        if(leagueProperties["leagueIDs"].toList().contains(competitionMap["cat_id"].toInt())) {
            BRCompetition* competition = this->getCompetition(federation, competitionVar.toMap()["WetId"].toInt(), this->parseCompetitionData(competitionMap, rawData["cats"].toList(), federation));
            data.competitions.append(competition);
        }
    }

    // if this is league with id 0
    if(leagueProperties["id"].toInt() == 0) {
        // parse cups
        QVariantList cupsVar = rawData["cups"].toList();

        for(QVariant cupVar : cupsVar) {
            QVariantMap cupMap = cupVar.toMap();
            BRCup* cup = this->getCup(federation, cupMap["SerId"].toInt(), this->parseCupData(rawData["cats"].toList(), cupMap, federation));
            data.cups.append(cup);
        }
    }

    return data;
}

BRWidget::BRWidgetStatusCode BRProviderDr::getWidgetData(BRCompetition::BRCompetitionData* competitionData) {

    if(competitionData->competition->getCurrentCategory() == nullptr)
        return BRWidget::OpeationNotSupportedError;

    // reload all data
    BRCategory* currentCategory = competitionData->competition->getCurrentCategory();
    QVariantMap ret;
    int retryCount = 0;

    // handle route not found errors
    do {
        retryCount ++;
        // load category data
        QString competitionId = QString::number(currentCategory->getCompetition()->getId());
        QString categoryId = QString::number(currentCategory->getId());
        QString requestUrl = "https://www.digitalrock.de/egroupware/ranking/json.php?comp=" + competitionId + "&cat=" + categoryId;

        if(currentCategory->getCurrentRound() != nullptr && currentCategory->getCurrentRound()->getId() >= 0)
            requestUrl += "&route=" + QString::number(currentCategory->getCurrentRound()->getId());

        ret = this->serverRequest(QUrl(requestUrl));

        // handle route not found errors
        if(ret["status"] != 200 && (ret["status"] != 404 || retryCount > 1)) {
            // request was a failure
            return BRWidget::BRWidgetStatusCode(ret["status"].toInt());
        }

        // if 404 is returned, the route probaply does not exist -> try again without route
        currentCategory->setCurrentRound(currentCategory->getGeneralResult());

    } while(ret["status"] != 200);

    QVariantMap data = QJsonDocument::fromJson(ret["text"].toString().toUtf8()).toVariant().toMap();

    this->parseCompetitionData(competitionData, data, competitionData->competition->getFederation());

    return BRWidget::Success;
}

BRCompetition::BRCompetitionData BRProviderDr::parseCompetitionData(QVariantMap rawData, QVariantList globalCategoriesList, BRWidget::BRFederation federation) {
    // Load competition data from calendar
    BRCompetition::BRCompetitionData data;

    data.name = rawData["name"].toString();

    qDebug() << "-- Parsing competition: " << data.name;

    if(rawData.contains("date"))
        data.startDate = QDate::fromString(rawData["date"].toString(), "yyyy-MM-dd");
    if(rawData.contains("date_end"))
        data.endDate = QDate::fromString(rawData["date_end"].toString(), "yyyy-MM-dd");

    if(rawData.contains("homepage"))
        data.eventWebsiteUrl = rawData["homepage"].toString();

    // load infosheet URLs
    for(int i = 0; i < 2; i++) {
        QString infosheetName = QStringList({"info", "info2"})[i];
        if(rawData.contains(infosheetName)) {
            QString url = rawData[infosheetName].toString();

            if(federation == BRWidget::DAV)
                url = "http://ranking.alpenverein.de/" + QString::number(data.startDate.year()) + "/GER/" + rawData["rkey"].toString() + ".pdf";

            data.infosheetUrls.append(url);
        }
    }

    // load categories
    QVariantList categoriesList = rawData["cats"].toList();
    data.categories.clear();

    for(QVariant categoryVar : categoriesList) {
        QVariantMap categoryMap = categoryVar.toMap();

        // parse discipline
        QString discipline;
        if(rawData.contains("discipline")) {
            // all categories have the same discipline
            discipline = rawData["discipline"].toString();
            // remove numbers (the Year of a competition is in the discipline somtimes)
            discipline = discipline.remove( QRegExp("/[0-9]/g") );
        }
        else
            // categories discipline may differ
            // search category in global categories list
            for(QVariant globalCategoryVar : globalCategoriesList) {
                QVariantMap globalCategoryMap = globalCategoryVar.toMap();
                if(categoryMap["GrpId"].toInt() == globalCategoryMap["GrpId"].toInt()) {
                    // TODO: gender
                    discipline = globalCategoryMap["discipline"].toString();
                    break;
                }
            }

        categoryMap.insert("discipline", discipline);

        BRCategory* category = this->getCategory(federation, categoryMap["GrpId"].toInt(), this->parseCategoryData(categoryMap));
        data.categories.append(category);
    }

    data.currentCategory = nullptr;

    return data;
}

void BRProviderDr::parseCompetitionData(BRCompetition::BRCompetitionData* competitionData, QVariantMap rawData, BRWidget::BRFederation federation) {

    // load competition data from category page (?comp=X&cat=Y)
    competitionData->name = rawData["comp_name"].toString();

    // reload categories
    // As digitalrock does not allow to get rounds in the competiton calendar
    // we need to populate all categories with their rounds when the first category is loaded.
    // for that, all categories are recreated
    QVariantList categoriesList = rawData["categorys"].toList();

    // store old categories
    QMap<int, BRCategory*> oldCategories;
    for(BRCategory* category : competitionData->categories)
        if(!oldCategories.contains(category->getId()))
            oldCategories.insert(category->getId(), category);

    competitionData->categories.clear();

    for(QVariant categoryVar : categoriesList) {
        QVariantMap categoryMap = categoryVar.toMap();
        int categoryId = categoryMap["GrpId"].toInt();

        BRCategory::BRCategoryData categoryData;
        categoryData.name = categoryMap["name"].toString();

        // restore data that is not available in competition view of the API
        if(oldCategories.contains(categoryId)) {
            categoryData.status = oldCategories[categoryId]->getStatus();
            categoryData.discipline = oldCategories[categoryId]->getDiscipline();
        }

        categoryData.currentRound = nullptr;
        categoryData.generalResult = nullptr;

        qDebug() << "Loading category: " << categoryData.name << " with discipline: " << categoryData.discipline;

        QVariantMap roundList;
        // check if route_names are given:
        if(rawData.contains("route_names"))
            roundList = rawData["route_names"].toMap();

        // load rounds
        for(QString roundId : roundList.keys()) {
            if(roundId.toInt() < 0)
                continue;

            BRRound::BRRoundData roundData;
            roundData.name = roundList[roundId].toString();
            BRRound* round = this->getRound(competitionData->competition->getFederation(), roundId.toInt(), roundData);
            categoryData.rounds.append(round);

            // if this was the previous round -> restore it!
            if(round->getId() == rawData["route_order"].toInt())
                categoryData.currentRound = round;
        }

        // general result
        BRRound::BRRoundData generalResultRoundData;
        generalResultRoundData.name = "Gesamtergebnis";
        categoryData.generalResult = this->getRound(competitionData->competition->getFederation(), -1, generalResultRoundData, true);

        // set default round if it was not restored
        if(categoryData.currentRound == nullptr)
            categoryData.currentRound = categoryData.generalResult;

        BRCategory* category = this->getCategory(federation, categoryId, categoryData);
        competitionData->categories.append(category);

        // restore current category and load its reults
        if(category->getId() == rawData["GrpId"]) {
            competitionData->currentCategory = category;

            // if we have a currentRound or a general result
            if(categoryData.currentRound != nullptr) {
                qDebug() << "-- Current Round is: " << categoryData.currentRound->getName() << " with id: " << categoryData.currentRound->getId();
                BRRound::BRRoundData roundData = categoryData.currentRound->getData();
                this->parseRoundData(&roundData, rawData);
                this->setRoundData(categoryData.currentRound, roundData);

                // if we have a general result -> load all other round results
                if(categoryData.currentRound->isGeneralResult()) {
                    for(BRRound* round : categoryData.rounds) {
                        BRRound::BRRoundData roundData = round->getData();
                        this->parseRoundData(&roundData, rawData, QString::number(round->getId()));
                        this->setRoundData(round, roundData);
                    }
                }
            }
        }

        // delete old categories
        for(int categoryId : oldCategories.keys()) {
            oldCategories[categoryId]->deleteLater();
        }

    }
}

BRCup::BRCupData BRProviderDr::parseCupData(QVariantList categoriesList, QVariantMap rawData, BRWidget::BRFederation federation) {
    BRCup::BRCupData data;

    data.name = rawData["name"].toString();

    qDebug() << "- Parsing Cup: " << data.name;

    // parse categories
    for(QVariant categoryName : rawData["cats"].toList()) {
        // find category name in cats:

        for(QVariant categoryVar : categoriesList) {
            QVariantMap categoryMap = categoryVar.toMap();
            if(categoryMap["rkey"].toString() == categoryName.toString()) {
                BRCategory* category = this->getCategory(federation, rawData["GrpId"].toInt(), this->parseCategoryData(categoryMap));
                data.categories.append(category);
                break;
            }
        }
    }

    return data;
}

BRCategory::BRCategoryData BRProviderDr::parseCategoryData(QVariantMap rawData) {
    BRCategory::BRCategoryData data;
    // TODO: gender

    data.name = rawData["name"].toString();
    data.currentRound = nullptr;
    data.generalResult = nullptr;

    QMap<int, BRCategory::BRCategoryStatus> statusTranslations = {
        {4, BRCategory::Registration},
        {2, BRCategory::Startlist},
        {1, BRCategory::Result},
        {0, BRCategory::Result}
    };

    QMap<QString, BRCategory::BRDiscipline> disciplineTranslations = {
        {"boulder", BRCategory::Boulder},
        {"lead", BRCategory::Lead},
        {"speed", BRCategory::Speed}
    };

    if(disciplineTranslations.contains(rawData["discipline"].toString()))
        data.discipline = disciplineTranslations[rawData["discipline"].toString()];
    else
        data.discipline = BRCategory::UnknownDiscipline;

    // parse status
    if(rawData.contains("status") && statusTranslations.contains(rawData["status"].toInt()))
        data.status = statusTranslations[rawData["status"].toInt()];
    else
        data.status = BRCategory::UnknownStatus;

    qDebug() << "-- Parsing category: " << data.name << " with discipline: " << data.discipline << " and status: " << data.status;

    return data;
}

void BRProviderDr::parseCategoryData(BRCategory::BRCategoryData* categoryData, QVariantMap rawData) {

    // category is already set-up -> only load rounds!


}

void BRProviderDr::parseRoundData(BRRound::BRRoundData* roundData, QVariantMap rawData, QString resultKeyAttachment) {
    roundData->results = {};
    // load results
    QVariantList resultList = rawData["participants"].toList();
    for(QVariant resultVar : resultList) {
        QVariantMap resultMap = resultVar.toMap();
        // load athlete
        BRAthlete* athlete = this->getAthlete(roundData->round->getFederation(), resultMap["PerId"].toInt(), this->parseAthletedata(resultMap));

        // load result
        // TODO: start number
        BRResult::BRResultData resultData;
        resultData.startNumber = resultMap["start_number"].toInt();
        resultData.athlete = athlete;
        resultData.rank = resultMap["result_rank" + resultKeyAttachment].toInt();
        resultData.details = nullptr;

        // load details:
        // - check if we have a general result
        if(roundData->round->isGeneralResult())
            resultData.details = new BRResultDetailsGeneralResult();
        else
            resultData.details = new BRResultDetailsUnknown(resultMap["result" + resultKeyAttachment].toString());

        BRResult* result = this->getResult(resultData);
        roundData->results.append(result);
    }
}

BRAthlete::BRAthleteData BRProviderDr::parseAthletedata(QVariantMap rawData) {
    BRAthlete::BRAthleteData data;

    data.firstName = rawData["firstname"].toString();
    data.lastName = rawData["lastname"].toString();
    data.federation = rawData["federation"].toString();
    data.federationUrl = rawData["fed_url"].toUrl();
    data.nation = rawData["nation"].toString();
    data.city = rawData["city"].toString();
    data.yearOfBirth = rawData["birthyear"].toInt();
    qDebug() << "--- Parsing athlete: " << data.firstName << " " << data.lastName;

    return data;
}

BRResult::BRResultData BRProviderDr::parseResultData(QVariantMap rawData) {

}