//SPDX-FileCopyrightText: 2023 Yury Gubich <blue@macaw.me>
//SPDX-License-Identifier: GPL-3.0-or-later

#include "session.h"

#include "handler/poll.h"

Session::Session(
    std::weak_ptr<TM::Scheduler> scheduler,
    unsigned int id,
    const std::string& access,
    const std::string& renew,
    unsigned int timeout
):
    scheduler(scheduler),
    id(id),
    access(access),
    renew(renew),
    polling(nullptr),
    timeoutId(TM::Scheduler::none),
    timeout(timeout)
{}

Session::~Session () {
    if (timeoutId != TM::Scheduler::none) {
        if (std::shared_ptr<TM::Scheduler> sch = scheduler.lock())
            sch->cancel(timeoutId);
    }
}

std::string Session::getAccessToken() const {
    return access;
}

std::string Session::getRenewToken() const {
    return renew;
}

void Session::accept(std::unique_ptr<Request> request) {
    std::shared_ptr<TM::Scheduler> sch = scheduler.lock();
    if (polling) {
        if (timeoutId != TM::Scheduler::none) {
            if (sch)
                sch->cancel(timeoutId);

            timeoutId = TM::Scheduler::none;
        }
        Handler::Poll::error(*polling.get(), Handler::Poll::Result::replace, Response::Status::ok);
        polling.reset();
    }

    if (!sch) {
        std::cerr << "Was unable to schedule polling timeout, replying with an error" << std::endl;
        Handler::Poll::error(*request.get(), Handler::Poll::Result::unknownError, Response::Status::internalError);
        return;
    }
    timeoutId = sch->schedule(std::bind(&Session::onTimeout, this), timeout);
    polling = std::move(request);
}

void Session::onTimeout () {
    timeoutId = TM::Scheduler::none;
    Handler::Poll::error(*polling.get(), Handler::Poll::Result::timeout, Response::Status::ok);
    polling.reset();
}