// Native surface validation test.
// Exercises invalid parameters and clipped dirty rectangles without depending on windowing.

#include <stdint.h>
#include <stddef.h>
#include <string.h>
#include <ntlite/syscall.h>

#define SURFACE_W 32u
#define SURFACE_H 24u

static void print(const char* s) {
    SYS_WRITE_CONSOLE_REQUEST req = { SysSvFromCstr(s) };
    SysWriteConsole(&req);
}

static void print_u64(uint64_t v) {
    char buf[32];
    int i = 0;
    if (v == 0) { print("0"); return; }
    while (v && i < (int)sizeof(buf)) {
        buf[i++] = (char)('0' + (v % 10));
        v /= 10;
    }
    while (i--) {
        char c = buf[i];
        SYS_WRITE_CONSOLE_REQUEST req = { SysSvFromParts(&c, 1) };
        SysWriteConsole(&req);
    }
}

static void exit_now(int code) {
    while (true) SysExitProcess(code);
}

static void fail(const char* msg) {
    print("surface_invalid_rect: ");
    print(msg);
    print("\n");
    exit_now(1);
}

static void fail_status(const char* what, uint32_t status) {
    print("surface_invalid_rect: ");
    print(what);
    print(" failed status=");
    print_u64(status);
    print("\n");
    exit_now(1);
}

static void expect_status(const char* what, uint32_t got, uint32_t expected) {
    if (got == expected) return;
    print("surface_invalid_rect: ");
    print(what);
    print(" returned ");
    print_u64(got);
    print(" expected ");
    print_u64(expected);
    print("\n");
    exit_now(1);
}

int main(void) {
    print("surface_invalid_rect: start\n");

    uint32_t bad = 0;
    SYS_CREATE_SURFACE_REQUEST req;
    memset(&req, 0, sizeof(req));
    req.Size = sizeof(req);
    req.Width = 0;
    req.Height = SURFACE_H;
    req.Format = SYS_SURFACE_FORMAT_XRGB8888;
    req.Flags = SYS_SURFACE_FLAG_NONE;
    req.HandleOut = &bad;
    uint32_t s = SysCreateSurface(&req);
    expect_status("zero width", s, NTLSTATUS_INVALID_PARAMETER);

    req.Width = SURFACE_W;
    req.Format = 0x9999u;
    s = SysCreateSurface(&req);
    expect_status("bad format", s, NTLSTATUS_NOT_SUPPORTED);

    uint32_t surface = 0;
    req.Format = SYS_SURFACE_FORMAT_XRGB8888;
    req.HandleOut = &surface;
    s = SysCreateSurface(&req);
    if (s != NTLSTATUS_SUCCESS) fail_status("create surface", s);

    void* base = 0;
    uint32_t pitch = 0;
    s = SysMapSurface(surface, &base, &pitch);
    if (s != NTLSTATUS_SUCCESS) fail_status("map surface", s);
    if (!base || pitch < SURFACE_W * sizeof(uint32_t)) fail("invalid mapping");

    s = SysPresentSurface(surface, 0, 1);
    expect_status("null rect array with nonzero count", s, NTLSTATUS_INVALID_PARAMETER);

    DISPLAY_RECT rects[SYS_SURFACE_MAX_RECTS + 1];
    memset(rects, 0, sizeof(rects));
    s = SysPresentSurface(surface, rects, SYS_SURFACE_MAX_RECTS + 1);
    expect_status("too many rects", s, NTLSTATUS_INVALID_PARAMETER);

    DISPLAY_RECT clipped = { -8, -8, 24, 24 };
    s = SysPresentSurface(surface, &clipped, 1);
    if (s != NTLSTATUS_SUCCESS) fail_status("present clipped rect", s);

    DISPLAY_RECT empty = { 10000, 10000, 16, 16 };
    s = SysPresentSurface(surface, &empty, 1);
    if (s != NTLSTATUS_SUCCESS) fail_status("present empty clipped rect", s);

    SysCloseHandle(surface);
    print("surface_invalid_rect: PASS\n");
    exit_now(0);
    return 0;
}