/**
 * turtle.h - Libreria di Grafica della Tartaruga per C (basata su Raylib)
 * 
 * Istruzioni d'uso:
 * 1. Includi questo file nel tuo main.c: #include "turtle.h"
 * 2. Chiama `turtle_init()` all'inizio del main.
 * 3. Usa i comandi della tartaruga (es. forward, turn_right, pen_up, pen_down).
 * 4. Chiama `turtle_wait()` alla fine per tenere aperta la finestra.
 */

#ifndef TURTLE_H
#define TURTLE_H

#include "raylib.h"
#include <math.h>
#include <stdbool.h>

// Struttura globale nascosta per gestire lo stato della tartaruga e dello schermo
static struct {
    Vector2 pos;
    float angle;
    bool is_pen_down;
    Color color;
    RenderTexture2D canvas;
    int width;
    int height;
    bool initialized;
} _t;

// Inizializza la finestra e la tartaruga al centro dello schermo
static inline void turtle_init(int width, int height, const char* title) {
    if (_t.initialized) return;
    
    _t.width = width;
    _t.height = height;
    
    // Inizializza Raylib
    InitWindow(width, height, title);
    SetTargetFPS(60);
    
    // Crea la tela virtuale
    _t.canvas = LoadRenderTexture(width, height);
    
    // Pulisce la tela con sfondo nero
    BeginTextureMode(_t.canvas);
        ClearBackground(BLACK);
    EndTextureMode();
    
    // Stato iniziale della tartaruga (centro schermo, rivolta a destra)
    _t.pos = (Vector2){ (float)width / 2.0f, (float)height / 2.0f };
    _t.angle = 0.0f;
    _t.is_pen_down = true;
    _t.color = GREEN;
    _t.initialized = true;
}

// Muove la tartaruga in avanti di 'distance' pixel
static inline void forward(float distance) {
    if (!_t.initialized) return;
    
    float radians = _t.angle * DEG2RAD;
    Vector2 new_pos = {
        _t.pos.x + cosf(radians) * distance,
        _t.pos.y + sinf(radians) * distance
    };
    
    if (_t.is_pen_down) {
        BeginTextureMode(_t.canvas);
            DrawLineV(_t.pos, new_pos, _t.color);
        EndTextureMode();
    }
    
    _t.pos = new_pos;
}

// Muove la tartaruga all'indietro di 'distance' pixel
static inline void backward(float distance) {
    forward(-distance);
}

// Gira a destra (orario) di 'degrees' gradi
static inline void turn_right(float degrees) {
    _t.angle += degrees;
}

// Gira a sinistra (antiorario) di 'degrees' gradi
static inline void turn_left(float degrees) {
    _t.angle -= degrees;
}

// Abbassa la penna (lascia la scia quando si muove)
static inline void pen_down(void) {
    _t.is_pen_down = true;
}

// Alza la penna (si muove senza lasciare la scia)
static inline void pen_up(void) {
    _t.is_pen_down = false;
}

// Cambia il colore della penna (es. RED, GREEN, BLUE, WHITE, ecc.)
static inline void set_color(Color color) {
    _t.color = color;
}

// Sposta istantaneamente la tartaruga alle coordinate (x, y)
static inline void go_to(float x, float y) {
    _t.pos = (Vector2){ x, y };
}

// Imposta l'orientamento assoluto in gradi (0 = destra, 90 = giù, 180 = sinistra, 270 = su)
static inline void set_heading(float degrees) {
    _t.angle = degrees;
}

// Ripulisce il disegno cancellando tutto sulla tela
static inline void clear_screen(Color background_color) {
    if (!_t.initialized) return;
    BeginTextureMode(_t.canvas);
        ClearBackground(background_color);
    EndTextureMode();
}

// Gestisce il ciclo di rendering grafico principale e mantiene aperta la finestra finché non viene chiusa
static inline void turtle_wait(void) {
    if (!_t.initialized) return;
    
    while (!WindowShouldClose()) {
        BeginDrawing();
            ClearBackground(DARKGRAY);
            
            // Disegna la tela virtuale (corregge l'inversione dell'asse Y tipica di OpenGL)
            DrawTextureRec(
                _t.canvas.texture, 
                (Rectangle){ 0, 0, (float)_t.canvas.texture.width, (float)-_t.canvas.texture.height }, 
                (Vector2){ 0, 0 }, 
                WHITE
            );
            
            // Disegna la tartaruga (un piccolo cerchio rosso) nella posizione attuale
            DrawCircleV(_t.pos, 5, RED);
        EndDrawing();
    }
    
    // Chiude e libera la memoria
    UnloadRenderTexture(_t.canvas);
    CloseWindow();
    _t.initialized = false;
}

#endif // TURTLE_H