/* Copyright (c) V-Nova International Limited 2026. All rights reserved.
 * This software is licensed under the BSD-3-Clause-Clear License by V-Nova Limited.
 * No patent licenses are granted under this license. For enquiries about patent licenses,
 * please contact legal@v-nova.com.
 * The LCEVCdec software is a stand-alone project and is NOT A CONTRIBUTION to any other project.
 * If the software is incorporated into another project, THE TERMS OF THE BSD-3-CLAUSE-CLEAR LICENSE
 * AND THE ADDITIONAL LICENSING INFORMATION CONTAINED IN THIS FILE MUST BE MAINTAINED, AND THE
 * SOFTWARE DOES NOT AND MUST NOT ADOPT THE LICENSE OF THE INCORPORATING PROJECT. However, the
 * software may be incorporated into a project under a compatible license provided the requirements
 * of the BSD-3-Clause-Clear license are respected, and V-Nova Limited remains
 * licensor of the software ONLY UNDER the BSD-3-Clause-Clear license (not the compatible license).
 * ANY ONWARD DISTRIBUTION, WHETHER STAND-ALONE OR AS PART OF ANY OTHER PROJECT, REMAINS SUBJECT TO
 * THE EXCLUSION OF PATENT LICENSES PROVISION OF THE BSD-3-CLAUSE-CLEAR LICENSE. */

#ifndef VN_LCEVC_COMMON_DETAIL_THREADS_OFF_H
#define VN_LCEVC_COMMON_DETAIL_THREADS_OFF_H

#include <stddef.h>
#include <time.h>

struct Thread
{
    ThreadFunction function;
    void* argument;
    intptr_t result;
};

enum ThreadResult
{
    ThreadResultSuccess = 0,
};

static inline int32_t threadNumCores(void) { return 1; }

static inline int threadCreate(Thread* thread, ThreadFunction function, void* argument)
{
    thread->function = function;
    thread->argument = argument;
    thread->result = 0;
    return ThreadResultSuccess;
}

static inline void threadSetPriority(Thread* thread, ThreadPriority priority)
{
    VNUnused(thread);
    VNUnused(priority);
}

static inline void threadExit(void) {}

static inline int threadJoin(Thread* thread, intptr_t* resultPtr)
{
    if (thread->function) {
        thread->result = thread->function(thread->argument);
        thread->function = NULL;
    }
    if (resultPtr) {
        *resultPtr = thread->result;
    }
    return ThreadResultSuccess;
}

static inline int threadSleep(uint32_t milliseconds)
{
    VNUnused(milliseconds);
    return ThreadResultSuccess;
}

static inline void threadYield(void) {}

static inline void threadSetName(const char* name) { VNUnused(name); }

static inline uint64_t threadTimeMicroseconds(int32_t offset)
{
    if (offset == UINT32_MAX) {
        return UINT64_MAX;
    }

    struct timespec ts;
    clock_gettime(CLOCK_REALTIME, &ts);
    const uint64_t uSecs = ts.tv_sec * 1000000LL + ts.tv_nsec / 1000L;

    return uSecs + offset;
}

// Stub Mutexes
//
struct ThreadMutex
{
    int unused;
};

#define VNThreadMutexInit \
    {                     \
        0                 \
    }

static inline int threadMutexInitialize(ThreadMutex* mutex)
{
    VNUnused(mutex);
    return ThreadResultSuccess;
}

static inline int threadMutexDestroy(ThreadMutex* mutex)
{
    VNUnused(mutex);
    return ThreadResultSuccess;
}

static inline int threadMutexLock(ThreadMutex* mutex)
{
    VNUnused(mutex);
    return ThreadResultSuccess;
}

static inline int threadMutexTrylock(ThreadMutex* mutex)
{
    VNUnused(mutex);
    return ThreadResultSuccess;
}

static inline int threadMutexUnlock(ThreadMutex* mutex)
{
    VNUnused(mutex);
    return ThreadResultSuccess;
}

// Stub Conditional Variables
//
struct ThreadCondVar
{
    int unused;
};

#define VNThreadCondVarInit \
    {                       \
        0                   \
    }

static inline int threadCondVarInitialize(ThreadCondVar* condVar)
{
    VNUnused(condVar);
    return ThreadResultSuccess;
}

static inline void threadCondVarDestroy(ThreadCondVar* condVar) { VNUnused(condVar); }

static inline int threadCondVarSignal(ThreadCondVar* condVar)
{
    VNUnused(condVar);
    return ThreadResultSuccess;
}

static inline int threadCondVarBroadcast(ThreadCondVar* condVar)
{
    VNUnused(condVar);
    return ThreadResultSuccess;
}

static inline int threadCondVarWait(ThreadCondVar* condVar, ThreadMutex* mutex)
{
    VNUnused(condVar);
    VNUnused(mutex);
    return ThreadResultSuccess;
}

static inline int threadCondVarWaitDeadline(ThreadCondVar* condVar, ThreadMutex* mutex, uint64_t deadline)
{
    VNUnused(condVar);
    VNUnused(mutex);
    VNUnused(deadline);
    return ThreadResultSuccess;
}

#endif // VN_LCEVC_COMMON_DETAIL_THREADS_OFF_H
