// Public nt-lite DDK system-thread declarations.

#pragma once

#include <stdint.h>
#include <ntlite/status.h>
#include <ntlite/thread.h>

typedef struct THREAD THREAD;

#ifndef NTL_THREAD_PRIORITY_DEFINED
typedef enum THREAD_PRIORITY {
    PriorityLow = 0,
    PriorityNormal = 1,
    PriorityHigh = 2,
    PriorityCount = 3,
} THREAD_PRIORITY;
#define NTL_THREAD_PRIORITY_DEFINED 1
#endif

// Selects dynamic normal scheduling or static real-time scheduling.
typedef enum KE_SCHEDULING_CLASS {
    KeSchedulingNormal = 0,
    KeSchedulingRealtime = 1,
    KeSchedulingClassCount = 2,
} KE_SCHEDULING_CLASS;

// Higher real-time values outrank lower values. Real-time threads always
// outrank normal threads and round-robin with equal-priority peers.
#define KE_REALTIME_PRIORITY_MIN   0u
#define KE_REALTIME_PRIORITY_MAX  31u
#define KE_REALTIME_PRIORITY_COUNT 32u

// Creates a thread without placing it on a scheduler ready queue. The caller
// must retain the returned THREAD reference and call KeResumeThread().
#define KE_THREAD_CREATE_FLAG_SUSPENDED 0x00000001u

// Describes initial scheduling, execution state, affinity, and diagnostics for
// one new thread. Zero affinity selects the kernel default rather than an empty
// CPU set. Name may be NULL; otherwise it must be a NUL-terminated UTF-8 name
// shorter than NTL_THREAD_NAME_MAX bytes.
typedef struct KE_THREAD_CREATE_PARAMETERS {
    KE_SCHEDULING_CLASS SchedulingClass;
    uint32_t Priority;
    uint32_t Flags;
    uint64_t AffinityMask;
    const char* Name;
} KE_THREAD_CREATE_PARAMETERS;

#define KE_THREAD_CREATE_NORMAL(priorityValue) \
    { KeSchedulingNormal, (uint32_t)(priorityValue), 0u, 0ULL, (const char*)0 }

#define KE_THREAD_CREATE_NAMED_NORMAL(priorityValue, nameValue) \
    { KeSchedulingNormal, (uint32_t)(priorityValue), 0u, 0ULL, (nameValue) }

#define KE_THREAD_CREATE_REALTIME(priorityValue) \
    { KeSchedulingRealtime, (uint32_t)(priorityValue), 0u, 0ULL, (const char*)0 }

#define KE_THREAD_CREATE_NAMED_REALTIME(priorityValue, nameValue) \
    { KeSchedulingRealtime, (uint32_t)(priorityValue), 0u, 0ULL, (nameValue) }

// Creates a system-process kernel thread with explicit scheduling parameters.
__declspec(dllexport) KSTATUS KeCreateKernelThread(uintptr_t fn,
                                                   uintptr_t arg,
                                                   const KE_THREAD_CREATE_PARAMETERS* parameters,
                                                   THREAD** out);

// Decrements one thread's suspend count and queues it when the count reaches
// zero. previousSuspendCountOut may be NULL.
__declspec(dllexport) KSTATUS KeResumeThread(THREAD* thread,
                                             uint32_t* previousSuspendCountOut);

// Yields the current processor to another runnable thread.
__declspec(dllexport) void KeYield(void);

// Returns the stable opaque identity of the calling kernel thread.
__declspec(dllexport) uintptr_t KeCurrentThreadIdentity(void);