/*
    * statuscodes.h
    * MontaukOS status codes
    * Copyright (c) 2026 Daniel Hammer
*/

#pragma once

// Userspace status codes.
// Analogous to kernel/src/Common/StatusCodes.hpp, but positive numbers are used.
#ifdef __cplusplus
namespace montauk {
#endif

typedef enum {
    Success = 0,
    GenericFailure = 1,
    PermissionDenied = 2,
    CapabilityDenied = 3,
    SystemIntegrityError = 4,
    BadPointer = 5,
    InvalidArgument = 6,
    UnsupportedOp = 7,
    NoDevice = 8,
    IoFailure = 9,
    BadInvocation = 10,
    NoSuchPath = 11,
    Busy = 12,
    BufferTooSmall = 13,
    OutOfMemory = 14,
    TimedOut = 15,
    WouldBlock = 16
} StatusCode;

// Highest defined StatusCode; update when adding a code above.
enum { MaxStatusCode = WouldBlock };

inline const char* GetStatusText(StatusCode statusCode) {
    const char* statusText[] = {
        "Success", // 0
        "Generic failure", // 1
        "Permission denied", // 2
        "Capability denied", // 3
        "System integrity error", // 4
        "Bad pointer", // 5
        "Invalid argument", // 6
        "Unsupported operation", // 7
        "No device", // 8
        "I/O failure", // 9
        "Bad invocation", // 10
        "No such path", // 11
        "Busy", // 12
        "Buffer too small", // 13
        "Out of memory", // 14
        "Timed out", // 15
        "Operation would block", // 16
    };

    if (statusCode > 0 && statusCode <= MaxStatusCode) {
        return statusText[statusCode];
    } else {
        return "Unknown error";
    }
}

// Map a raw syscall result to a StatusCode.
inline StatusCode StatusFromResult(long long rc) {
    if (rc >= 0) return Success;
    if (rc < -(long long)MaxStatusCode) return GenericFailure;
    return (StatusCode)(-rc);
}

// Shared with C (libc.c), so no nullptr.
inline const char* GetStatusExplanationText(StatusCode statusCode) {
    const char* explanationText[] = {
        0, // 0
        0, // 1
        0, // 2
        0, // 3
        "The path is protected by the system and cannot be modified.", // 4
        0, // 5
        0, // 6
        0, // 7
        0, // 8
        0, // 9
        0, // 10
        0, // 11
        0, // 12
        "The buffer supplied by the caller is too small.", // 13
        0, // 14
        0, // 15
        0, // 16
    };

    if (statusCode > 0 && statusCode <= MaxStatusCode) {
        if (explanationText[statusCode] != 0) {
            return explanationText[statusCode];
        }
    }

    return GetStatusText(statusCode);
}

// Process termination codes: what waitpid returns when the kernel ended the
// process (crash, kill, abort) instead of it calling exit. 256 + POSIX
// signal number, so normal exit codes (0..255) can never collide.
// Analogous to kernel/src/Common/TerminationCodes.hpp; same values.
typedef enum {
    TerminationBase = 256,
    TerminatedIllegalInstruction = TerminationBase + 4,     // SIGILL
    TerminatedBreakpoint = TerminationBase + 5,             // SIGTRAP
    TerminatedAborted = TerminationBase + 6,                // SIGABRT
    TerminatedArithmeticError = TerminationBase + 8,        // SIGFPE
    TerminatedKilled = TerminationBase + 9,                 // SIGKILL
    TerminatedAccessViolation = TerminationBase + 11        // SIGSEGV
} TerminationCode;

// Shared with C (libc.c), so no nullptr. Returns 0 for an unknown code.
inline const char* GetTerminationText(int exitCode) {
    switch (exitCode) {
        case TerminatedIllegalInstruction: return "Illegal instruction";
        case TerminatedBreakpoint:         return "Breakpoint";
        case TerminatedAborted:            return "Aborted";
        case TerminatedArithmeticError:    return "Arithmetic error";
        case TerminatedKilled:             return "Killed";
        case TerminatedAccessViolation:    return "Access violation";
        default:                           return 0;
    }
}

#ifdef __cplusplus
}
#endif