/*
 * Copyright 2023-2025 The OpenSSL Project Authors. All Rights Reserved.
 *
 * Licensed under the Apache License 2.0 (the "License").  You may not use
 * this file except in compliance with the License.  You can obtain a copy
 * in the file LICENSE in the source distribution or at
 * https://www.openssl.org/source/license.html
 */

#include <openssl/macros.h>
#include "quic_local.h"
#include "internal/time.h"
#include "internal/thread.h"
#include "internal/thread_arch.h"
#include "internal/quic_thread_assist.h"

#if !defined(OPENSSL_NO_QUIC_THREAD_ASSIST)

/* Main loop for the QUIC assist thread. */
static unsigned int assist_thread_main(void *arg)
{
    QUIC_THREAD_ASSIST *qta = arg;
    CRYPTO_MUTEX *m = ossl_quic_channel_get_mutex(qta->ch);
    QUIC_REACTOR *rtor;
    QUIC_ENGINE *eng = ossl_quic_channel_get0_engine(qta->ch);

    ossl_crypto_mutex_lock(m);

    rtor = ossl_quic_channel_get_reactor(qta->ch);

    for (;;) {
        OSSL_TIME deadline;

        if (qta->teardown)
            break;

        deadline = ossl_quic_reactor_get_tick_deadline(rtor);
        /*
         * ossl_crypto_condvar_wait_timeout needs to use real time for the
         * deadline
         */
        deadline = ossl_quic_engine_make_real_time(eng, deadline);
        ossl_crypto_condvar_wait_timeout(qta->cv, m, deadline);

        /*
         * We have now been woken up. This can be for one of the following
         * reasons:
         *
         *   - We have been asked to teardown (qta->teardown is set);
         *   - The tick deadline has passed.
         *   - The tick deadline has changed.
         *
         * For robustness, this loop also handles spurious wakeups correctly
         * (which does not require any extra code).
         */
        if (qta->teardown)
            break;

        ossl_quic_reactor_tick(rtor, QUIC_REACTOR_TICK_FLAG_CHANNEL_ONLY);
    }

    ossl_crypto_mutex_unlock(m);
    return 1;
}

int ossl_quic_thread_assist_init_start(QUIC_THREAD_ASSIST *qta,
                                       QUIC_CHANNEL *ch)
{
    CRYPTO_MUTEX *mutex = ossl_quic_channel_get_mutex(ch);

    if (mutex == NULL)
        return 0;

    qta->ch         = ch;
    qta->teardown   = 0;
    qta->joined     = 0;

    qta->cv = ossl_crypto_condvar_new();
    if (qta->cv == NULL)
        return 0;

    qta->t = ossl_crypto_thread_native_start(assist_thread_main,
                                             qta, /*joinable=*/1);
    if (qta->t == NULL) {
        ossl_crypto_condvar_free(&qta->cv);
        return 0;
    }

    return 1;
}

int ossl_quic_thread_assist_stop_async(QUIC_THREAD_ASSIST *qta)
{
    if (!qta->teardown) {
        qta->teardown = 1;
        ossl_crypto_condvar_signal(qta->cv);
    }

    return 1;
}

int ossl_quic_thread_assist_wait_stopped(QUIC_THREAD_ASSIST *qta)
{
    CRYPTO_THREAD_RETVAL rv;
    CRYPTO_MUTEX *m = ossl_quic_channel_get_mutex(qta->ch);

    if (qta->joined)
        return 1;

    if (!ossl_quic_thread_assist_stop_async(qta))
        return 0;

    ossl_crypto_mutex_unlock(m);

    if (!ossl_crypto_thread_native_join(qta->t, &rv)) {
        ossl_crypto_mutex_lock(m);
        return 0;
    }

    qta->joined = 1;

    ossl_crypto_mutex_lock(m);
    return 1;
}

int ossl_quic_thread_assist_cleanup(QUIC_THREAD_ASSIST *qta)
{
    if (!ossl_assert(qta->joined))
        return 0;

    ossl_crypto_condvar_free(&qta->cv);
    ossl_crypto_thread_native_clean(qta->t);

    qta->ch     = NULL;
    qta->t      = NULL;
    return 1;
}

int ossl_quic_thread_assist_notify_deadline_changed(QUIC_THREAD_ASSIST *qta)
{
    if (qta->teardown)
        return 0;

    ossl_crypto_condvar_signal(qta->cv);
    return 1;
}

#endif