/* The C half of the raylib binding: one wrapper per `declare` in raylib.flan.
 *
 * The wrappers exist so that no aggregate is ever passed or returned across
 * the Flan/C boundary. raylib takes Color by value and returns Vector2 by
 * value, and a small aggregate is passed differently on x86-64 (<2 x float>,
 * i32), on arm64, and on wasm32. Here, clang classifies each one correctly for
 * whichever target the build is for; in the Flan backend it would be three
 * conventions to reimplement. Everything below therefore trades in scalars and
 * pointers only — see raylib.flan.
 *
 * raylib's own headers are not needed and not used: these prototypes are the
 * declarations, so the build has no dependency on raylib-devel being
 * installed, only on the shared library being linkable.
 */

#include <stdbool.h>
#include <stddef.h>
#include <string.h>

typedef struct { float x, y; } Vector2;
typedef struct { unsigned char r, g, b, a; } Color;

extern void  InitWindow(int width, int height, const char *title);
extern void  CloseWindow(void);
extern bool  WindowShouldClose(void);
extern void  SetTargetFPS(int fps);
extern void  SetTraceLogLevel(int level);
extern bool  IsKeyPressed(int key);
extern bool  IsKeyDown(int key);
extern bool  IsKeyReleased(int key);
extern bool  IsMouseButtonPressed(int button);
extern bool  IsMouseButtonDown(int button);
extern bool  IsMouseButtonReleased(int button);
extern Vector2 GetMousePosition(void);
extern Color GetColor(unsigned int hex);
extern void  BeginDrawing(void);
extern void  EndDrawing(void);
extern void  DrawFPS(int x, int y);
extern void  ClearBackground(Color color);
extern void  DrawRectangle(int x, int y, int width, int height, Color color);

/* A Flan string arrives as ptr+len and is not NUL-terminated, so a C API that
 * wants a C string needs a copy. The window title is the only one, it is short
 * by nature, and truncating is better than reading past the end. */
static const char *cstr(const char *p, long long n, char *buf, size_t cap) {
  size_t k = (size_t)n < cap - 1 ? (size_t)n : cap - 1;
  memcpy(buf, p, k);
  buf[k] = '\0';
  return buf;
}

void flan_rl_init_window(int width, int height, const char *title, long long n) {
  char buf[256];
  InitWindow(width, height, cstr(title, n, buf, sizeof buf));
}

void flan_rl_close_window(void)          { CloseWindow(); }
bool flan_rl_window_should_close(void)   { return WindowShouldClose(); }
void flan_rl_set_target_fps(int fps)     { SetTargetFPS(fps); }
void flan_rl_set_trace_log_level(int l)  { SetTraceLogLevel(l); }

bool flan_rl_is_key_pressed(int key)     { return IsKeyPressed(key); }
bool flan_rl_is_key_down(int key)        { return IsKeyDown(key); }
bool flan_rl_is_key_released(int key)    { return IsKeyReleased(key); }

bool flan_rl_is_mouse_button_pressed(int b)  { return IsMouseButtonPressed(b); }
bool flan_rl_is_mouse_button_down(int b)     { return IsMouseButtonDown(b); }
bool flan_rl_is_mouse_button_released(int b) { return IsMouseButtonReleased(b); }

void flan_rl_get_mouse_position(Vector2 *out) { *out = GetMousePosition(); }

void flan_rl_get_color(unsigned int hex, Color *out) { *out = GetColor(hex); }

void flan_rl_begin_drawing(void)         { BeginDrawing(); }
void flan_rl_end_drawing(void)           { EndDrawing(); }
void flan_rl_draw_fps(int x, int y)      { DrawFPS(x, y); }

void flan_rl_clear_background(const Color *color) { ClearBackground(*color); }

void flan_rl_draw_rectangle(int x, int y, int width, int height,
                            const Color *color) {
  DrawRectangle(x, y, width, height, *color);
}