maincontroller.cpp

#include "maincontroller.h"

#include <QMessageBox>
#include <QDebug>

#include <QJsonArray>

#include "domjudgeapimanager.h"
#include "contest.h"
#include "team.h"
#include "group.h"
#include "problem.h"
#include "submission.h"
#include "judging.h"

namespace DJ {
namespace Controller {

MainController::MainController(QObject *parent) : QObject(parent) {

    this->mainDialog = new View::MainDialog;
    this->aboutDialog = new View::AboutDialog(this->mainDialog);
    this->settingsDialog = new View::SettingsDialog(this->mainDialog);
    this->resultsWindow = new View::ResultsWindow;
    this->standingsController = nullptr;
    this->contest = nullptr;

    connect(this->mainDialog, &View::MainDialog::aboutClicked, this->aboutDialog, &View::AboutDialog::exec);
    connect(this->mainDialog, &View::MainDialog::connectClicked, this, &MainController::connectToServer);
    connect(this->mainDialog, &View::MainDialog::settingsClicked, this->settingsDialog, &View::SettingsDialog::exec);
    connect(this->mainDialog, &View::MainDialog::startClicked, this, &MainController::showResults);
    connect(this->mainDialog, &View::MainDialog::loadContestsClicked, this, &MainController::loadContest);

    Shared::DomjudgeApiManager *apiManager = Shared::DomjudgeApiManager::sharedApiManager();
    connect(apiManager, &Shared::DomjudgeApiManager::userLoaded, this, &MainController::processUser);
    connect(apiManager, &Shared::DomjudgeApiManager::userDataFailedLoading, this, &MainController::processUserLoadError);
    connect(apiManager, &Shared::DomjudgeApiManager::contestsDataLoaded, this, &MainController::processContestsData);
    connect(apiManager, &Shared::DomjudgeApiManager::contestsDataFailedLoading, this, &MainController::processContestsLoadError);
    connect(apiManager, &Shared::DomjudgeApiManager::teamsDataLoaded, this, &MainController::processTeamData);
    connect(apiManager, &Shared::DomjudgeApiManager::teamsDataFailedLoading, this, &MainController::processTeamsLoadError);
    connect(apiManager, &Shared::DomjudgeApiManager::groupsDataLoaded, this, &MainController::processGroupData);
    connect(apiManager, &Shared::DomjudgeApiManager::groupsDataFailedLoading, this, &MainController::processGroupsLoadError);
    connect(apiManager, &Shared::DomjudgeApiManager::problemsDataLoaded, this, &MainController::processProblemData);
    connect(apiManager, &Shared::DomjudgeApiManager::problemsDataFailedLoading, this, &MainController::processProblemsLoadError);

    connect(apiManager, &Shared::DomjudgeApiManager::submissionsDataLoaded, this, &MainController::processSubmissionData);
    connect(apiManager, &Shared::DomjudgeApiManager::submissionsDataFailedLoading, this, &MainController::processEventLoadError);
    connect(apiManager, &Shared::DomjudgeApiManager::judgingsDataLoaded, this, &MainController::processJudgingData);
    connect(apiManager, &Shared::DomjudgeApiManager::judgingsDataFailedLoading, this, &MainController::processEventLoadError);

    connect(this->resultsWindow, &View::ResultsWindow::newStandingNeeded, this, &MainController::updateStanding);
}

MainController::~MainController() {
    delete this->resultsWindow;
    delete this->mainDialog;
    if (this->standingsController) {
        delete this->standingsController;
        this->standingsController = nullptr;
    }
}

void MainController::showMainWindow() {
    this->mainDialog->show();
}

void MainController::connectToServer() {
    this->contest = this->mainDialog->getContest();

    if (!this->groups.empty()) {
        qDeleteAll(this->groups);
        this->groups.clear();
    }

    if (!this->teams.empty()) {
        qDeleteAll(this->teams);
        this->teams.clear();
    }

    if (!this->problems.empty()) {
        qDeleteAll(this->problems);
        this->problems.clear();
    }

    if (!this->judgings.empty()) {
        qDeleteAll(this->judgings);
        this->judgings.clear();
    }

    if (!this->submissions.empty()) {
        qDeleteAll(this->submissions);
        this->submissions.clear();
    }

    this->mainDialog->hideContest();

    Shared::DomjudgeApiManager *apiManager = Shared::DomjudgeApiManager::sharedApiManager();
    apiManager->setConnectionInfo(this->mainDialog->getProtocol(), this->mainDialog->getURL(), this->mainDialog->getUsername(), this->mainDialog->getPassword());
    apiManager->loadUserData();
}

void MainController::processUser(QJsonDocument userData) {
    QJsonObject user = userData.object();
    QJsonArray roles = user.value("roles").toArray();
    if (!roles.contains(QString("admin")) && !roles.contains(QString("jury"))) {
        this->processUserLoadError("You need at least the jury or admin role. Did you forget to enter a username / password?");
    } else {
        Shared::DomjudgeApiManager *apiManager = Shared::DomjudgeApiManager::sharedApiManager();
        apiManager->loadGroupsData(this->contest->getId());
    }
}

void MainController::processUserLoadError(QString error){
    QMessageBox::warning(this->mainDialog, "DOMjura failed loading data", "Failed loading user data: " + error);

    this->mainDialog->hideContest();
}

void MainController::processContestsData(QJsonDocument contestsData) {
    foreach (auto contestValue, contestsData.array()) {
        auto contestObject = contestValue.toObject();
        Model::Contest *contest = new Model::Contest(contestObject);
        this->contests[contest->getId()] = contest;
    }

    this->mainDialog->setContestsComboboxData(this->contests);
}

void MainController::processContestsLoadError(QString error) {
    QMessageBox::warning(this->mainDialog, "DOMjura failed loading data", "Failed loading contests data: " + error);

    this->mainDialog->hideContest();
}

void MainController::processGroupData(QJsonDocument groupsData) {
    foreach (auto groupValue, groupsData.array()) {
        auto groupObject = groupValue.toObject();
        Model::Group *group = new Model::Group(groupObject);
        this->groups[group->getId()] = group;
    }

    Shared::DomjudgeApiManager *apiManager = Shared::DomjudgeApiManager::sharedApiManager();
    apiManager->loadTeamData(this->contest->getId());
}

void MainController::processGroupsLoadError(QString error){
    QMessageBox::warning(this->mainDialog, "DOMjura failed loading data", "Failed loading groups data: " + error);

    this->mainDialog->hideContest();
}

void MainController::processTeamData(QJsonDocument teamData) {
    foreach (auto teamValue, teamData.array()) {
        auto teamObject = teamValue.toObject();
        Model::Team *team = new Model::Team(teamObject, this->groups);
        if (team->getGroup()) {
            // Only teams in a category are useful
            this->teams[team->getId()] = team;
        } else {
            delete team;
        }
    }

    Shared::DomjudgeApiManager *apiManager = Shared::DomjudgeApiManager::sharedApiManager();
    apiManager->loadProblemData(this->contest->getId());
}

void MainController::processTeamsLoadError(QString error){
    QMessageBox::warning(this->mainDialog, "DOMjura failed loading data", "Failed loading teams data: " + error);

    this->mainDialog->hideContest();
}

void MainController::processProblemData(QJsonDocument problemData) {
    foreach (auto problemValue, problemData.array()) {
        auto problemObject = problemValue.toObject();
        Model::Problem *problem = new Model::Problem(problemObject);
        this->problems[problem->getId()] = problem;
    }

    this->mainDialog->displayContest(this->contest, this->groups);
}

void MainController::processProblemsLoadError(QString error){
    QMessageBox::warning(this->mainDialog, "DOMjura failed loading data", "Failed loading problems data: " + error);

    this->mainDialog->hideContest();
}

void MainController::processEventLoadError(QString error) {
    QMessageBox::warning(this->mainDialog, "DOMjura failed loading data", "Failed loading submissions and/or judgings: " + error);
}

void MainController::processSubmissionData(QJsonDocument submissionData) {
    foreach (QJsonValue submissionValue, submissionData.array()) {
        QJsonObject submisionObject = submissionValue.toObject();
        Model::Submission *submission = new Model::Submission(submisionObject,
                                                              this->teams,
                                                              this->problems);
        if (submission->getProblem() && submission->getTeam()) {
            this->submissions[submission->getId()] = submission;
        } else {
            delete submission;
        }
    }

    Shared::DomjudgeApiManager *apiManager = Shared::DomjudgeApiManager::sharedApiManager();
    apiManager->loadJudgings(this->contest->getId());
}

void MainController::processJudgingData(QJsonDocument judgingData) {
    foreach (QJsonValue judgingValue, judgingData.array()) {
        QJsonObject judgingObject = judgingValue.toObject();
        Model::Judging *judging = new Model::Judging(judgingObject,
                                                     this->submissions);
        if (judging->getSubmission()) {
            this->judgings.append(judging);
        } else {
            delete judging;
        }
    }

    if (this->standingsController) {
        delete this->standingsController;
        this->standingsController = nullptr;
    }

    QHash<QString, Model::Team *> selectedTeams;
    QList<QString> selectedGroups = this->mainDialog->selectedGroups().keys();
    foreach (Model::Team *team, this->teams) {
        if (selectedGroups.contains(team->getGroup()->getId())) {
            selectedTeams[team->getId()] = team;
        }
    }

    this->standingsController = new StandingsController(this->contest,
                                                        selectedTeams,
                                                        this->problems,
                                                        this->judgings);
    this->standingsController->initStandings();

    int curRank = 1;
    QList<ResultTeam> teams;
    QList<Model::RankedTeam *> ranking = this->standingsController->getCurrentRanking();
    for (int i = 0; i < ranking.size(); i++) {
        ResultTeam team;
        Model::RankedTeam *rankedTeam = ranking.at(i);
        team.name = rankedTeam->getName();
        team.id = rankedTeam->getId();
        team.solved = rankedTeam->getNumSolved();
        if (i > 0) {
            Model::RankedTeam *prevTeam = ranking.at(i - 1);
            if (rankedTeam->getNumSolved() == prevTeam->getNumSolved()
                    && rankedTeam->getTotalTime() == prevTeam->getTotalTime()) {
                team.rank = curRank;
            } else {
                curRank = i + 1;
                team.rank = curRank;
            }
        } else {
            team.rank = 1;
            curRank = 1;
        }
        team.time = rankedTeam->getTotalTime();
        QList<ResultProblem> problems;
        for (int j = 0; j < rankedTeam->getNumProblems(); j++) {
            Model::RankedProblem *rankedProblem = rankedTeam->getProblem(j);
            ResultProblem problem;
            problem.state = rankedProblem->problemState;
            problem.problemId = rankedProblem->shortname;
            if (rankedProblem->problemState == SOLVED){
                problem.time = rankedProblem->timeFirstCorrectTry;
                problem.numTries = rankedProblem->tries;
            } else {
                problem.time = rankedProblem->timeLastTry;
                problem.numTries = rankedProblem->total_tries;
            }
            problems.append(problem);
        }
        team.problems = problems;
        teams.append(team);
    }

    this->resultsWindow->setContest(this->contest);
    this->resultsWindow->stopAnimations();
    this->resultsWindow->reload();
    this->resultsWindow->setTeams(teams);
    this->resultsWindow->showFullScreen();
}

//void MainController::showStats() {
//    QString stats;

//    StatsController *statsController = new StatsController(this->readDataController->getScoreboard(), this->readDataController->getEvents());

//    stats += "Total number of submissions: " + QString::number(statsController->getTotalSubmissions()) + "\n";
//    stats += "Total number of correct submissions: " + QString::number(statsController->getTotalCorrect()) + "\n";
//    for (int i = 0; i < this->readDataController->getScoreboard()->getNumProblems(); i++) {
//        QString problemid = this->readDataController->getScoreboard()->getProblem(i)->getId();
//        stats += "\n== Problem " + problemid + " ==\n";
//        stats += "Number of submissions: " + QString::number(statsController->getNumSubmissionsOfProblem(problemid)) + "\n";
//        if (statsController->getNumSubmissionsOfProblem(problemid) > 0) {
//            stats += "Last submission time: " + statsController->getLastSubmission(problemid).toString("dd-MM-yyyy hh:mm:ss") + "\n";
//        }
//        stats += "Is solved? " + QString(statsController->problemIsSolved(problemid) ? "Yes" : "No") + "\n";
//        if (statsController->problemIsSolved(problemid)) {
//            stats += "First solve time: " + statsController->getFirstSolved(problemid).toString("dd-MM-yyyy hh:mm:ss") + "\n";
//            stats += "Number of correct submissions: " + QString::number(statsController->getNumCorrectofProblem(problemid)) + "\n";
//        }
//    }

//    delete statsController;

//    this->statsDialog->setStats(stats);
//    this->statsDialog->exec();
//}

void MainController::loadContest(){
    if (!this->contests.empty()){
        qDeleteAll(this->contests);
        this->contests.clear();
    }

    Shared::DomjudgeApiManager *apiManager = Shared::DomjudgeApiManager::sharedApiManager();
    apiManager->setConnectionInfo(this->mainDialog->getProtocol(), this->mainDialog->getURL(), this->mainDialog->getUsername(), this->mainDialog->getPassword());
    apiManager->loadContestsData();
}

void MainController::showResults() {
    if (!this->judgings.empty()) {
        qDeleteAll(this->judgings);
        this->judgings.clear();
    }

    if (!this->submissions.empty()) {
        qDeleteAll(this->submissions);
        this->submissions.clear();
    }

    Shared::DomjudgeApiManager *apiManager = Shared::DomjudgeApiManager::sharedApiManager();
    apiManager->loadSubmissions(this->contest->getId());
}

void MainController::updateStanding() {
    if (this->standingsController->nextStanding()) {
        QList<Model::RankedTeam *> ranking = this->standingsController->getCurrentRanking();
        QList<ResultTeam> teams;
        int curRank = 1;
        for (int i = 0; i < ranking.size(); i++) {
            ResultTeam team;
            Model::RankedTeam *rankedTeam = ranking.at(i);
            team.name = rankedTeam->getName();
            team.id = rankedTeam->getId();
            team.solved = rankedTeam->getNumSolved();
            if (i > 0) {
                Model::RankedTeam *prevTeam = ranking.at(i - 1);
                if (rankedTeam->getNumSolved() == prevTeam->getNumSolved()
                        && rankedTeam->getTotalTime() == prevTeam->getTotalTime()) {
                    team.rank = curRank;
                } else {
                    curRank = i + 1;
                    team.rank = curRank;
                }
            } else {
                team.rank = 1;
                curRank = 1;
            }
            team.time = rankedTeam->getTotalTime();
            QList<ResultProblem> problems;
            for (int j = 0; j < rankedTeam->getNumProblems(); j++) {
                Model::RankedProblem *rankedProblem = rankedTeam->getProblem(j);
                ResultProblem problem;
                problem.state = rankedProblem->problemState;
                problem.problemId = rankedProblem->shortname;
                if (rankedProblem->problemState == SOLVED){
                    problem.time = rankedProblem->timeFirstCorrectTry;
                    problem.numTries = rankedProblem->tries;
                } else {
                    problem.time = rankedProblem->timeLastTry;
                    problem.numTries = rankedProblem->total_tries;
                }
                problems.append(problem);
            }
            team.problems = problems;
            teams.append(team);
        }
        this->resultsWindow->setTeams(teams, true,
                                      this->standingsController->getLastResolvedTeam(),
                                      this->standingsController->getLastResolvedProblem(),
                                      this->standingsController->getCurrentPos());
    } else {
        QList<Model::RankedTeam *> ranking = this->standingsController->getCurrentRanking();
        QList<ResultTeam> teams;
        int curRank = 1;
        for (int i = 0; i < ranking.size(); i++) {
            ResultTeam team;
            Model::RankedTeam *rankedTeam = ranking.at(i);
            team.name = rankedTeam->getName();
            team.id = rankedTeam->getId();
            team.solved = rankedTeam->getNumSolved();
            if (i > 0) {
                Model::RankedTeam *prevTeam = ranking.at(i - 1);
                if (rankedTeam->getNumSolved() == prevTeam->getNumSolved()
                        && rankedTeam->getTotalTime() == prevTeam->getTotalTime()) {
                    team.rank = curRank;
                } else {
                    curRank = i + 1;
                    team.rank = curRank;
                }
            } else {
                team.rank = 1;
                curRank = 1;
            }
            team.time = rankedTeam->getTotalTime();
            QList<ResultProblem> problems;
            for (int j = 0; j < rankedTeam->getNumProblems(); j++) {
                Model::RankedProblem *rankedProblem = rankedTeam->getProblem(j);
                ResultProblem problem;
                problem.state = rankedProblem->problemState;
                problem.problemId = rankedProblem->shortname;
                if (rankedProblem->problemState == SOLVED){
                    problem.time = rankedProblem->timeFirstCorrectTry;
                    problem.numTries = rankedProblem->tries;
                } else {
                    problem.time = rankedProblem->timeLastTry;
                    problem.numTries = rankedProblem->total_tries;
                }
                problems.append(problem);
            }
            team.problems = problems;
            teams.append(team);
        }
        this->resultsWindow->setTeams(teams, false);
        this->resultsWindow->setResolvDone();
    }
}

} // namespace Controller
} // namespace DJ