/*
 * Copyright (c) 2016 MariaDB Corporation Ab
 *
 * Use of this software is governed by the Business Source License included
 * in the LICENSE.TXT file and at www.mariadb.com/bsl11.
 *
 * Change Date: 2024-10-14
 *
 * On the date above, in accordance with the Business Source License, use
 * of this software will be governed by version 2 or later of the General
 * Public License.
 */

#include <maxscale/ccdefs.hh>
#include <maxscale/maxscale.h>

#include <time.h>

#include <maxscale/mainworker.hh>
#include <maxscale/routingworker.hh>

#include "internal/maxscale.hh"
#include "internal/service.hh"
#include "internal/admin.hh"
#include "internal/monitormanager.hh"

static time_t started;

namespace
{
    struct ThisUnit
    {
        std::atomic<const mxb::Worker*> admin_worker {nullptr};
    };
    ThisUnit this_unit;
}

void maxscale_reset_starttime(void)
{
    started = time(0);
}

time_t maxscale_started(void)
{
    return started;
}

int maxscale_uptime()
{
    return time(0) - started;
}

static sig_atomic_t n_shutdowns = 0;

bool maxscale_is_shutting_down()
{
    return n_shutdowns != 0;
}

int maxscale_shutdown()
{
    int n = n_shutdowns++;

    if (n == 0)
    {
        auto func = []() {
                if (mxs::MainWorker::created())
                {
                    mxs::MainWorker::get().shutdown();
                }

                /*< Stop all monitors */
                MonitorManager::stop_all_monitors();

                mxs_admin_shutdown();
                mxs::RoutingWorker::shutdown_all();
            };

        auto w = mxs::RoutingWorker::get(mxs::RoutingWorker::MAIN);
        w->execute(func, nullptr, mxs::RoutingWorker::EXECUTE_QUEUED);
    }

    return n + 1;
}

static bool teardown_in_progress = false;

bool maxscale_teardown_in_progress()
{
    return teardown_in_progress;
}

void maxscale_start_teardown()
{
    teardown_in_progress = true;
}

bool running_in_admin_thread()
{
    auto current_worker = mxb::Worker::get_current();
    return current_worker == this_unit.admin_worker.load(std::memory_order_acquire);
}

void set_admin_worker(const mxb::Worker* admin_worker)
{
    this_unit.admin_worker.store(admin_worker, std::memory_order_release);
}