#include <raylib.h>

struct AnimData 
{
    Rectangle rec;
    Vector2 pos;
    int frame;
    float updateTime;
    float runningTime;
    
};

int main() {

    // Specified width and height
    const int windowWidth{800};
    const int windowHeight{600};
    // Initialize the window
    InitWindow(windowWidth, windowHeight, "ECS Dapper Dasher");
    
    // Acceleration due to gravity (pixels per frame/frame)
    const int gravity{ 1'000 };

    // Scarfy setup
    Texture2D scarfy = LoadTexture("textures/scarfy.png"); // Load the texture
    AnimData scarfyData;
    scarfyData.rec.width = scarfy.width / 6;
    scarfyData.rec.height = scarfy.height;
    scarfyData.rec.x = 0;
    scarfyData.rec.y = 0;

    scarfyData.pos.x = windowWidth / 2 - scarfyData.rec.width / 2;
    scarfyData.pos.y = windowHeight - scarfyData.rec.height;
    scarfyData.frame = 0;
    scarfyData.updateTime = 1.0 / 12.0;
    scarfyData.runningTime = 0.0;

    // Scarfy Rectangle

    Rectangle scarfyRect;
    scarfyRect.width = scarfy.width / 6;
    scarfyRect.height = scarfy.height;
    scarfyRect.x = 0;
    scarfyRect.y = 0;
    Vector2 scarfyPos;
    scarfyPos.x = windowWidth / 2 - scarfyRect.width / 2;
    scarfyPos.y = windowHeight - scarfyRect.height;

    // Nebula setup
    Texture2D nebula = LoadTexture("textures/12_nebula_spritesheet.png"); // Load the texture

    // Nebula anim

    AnimData nebData{ 
        {0.0, 0.0, nebula.width / 8, nebula.height / 8}, // Rectangle rec
        {windowWidth, windowHeight - nebula.height / 8}, // Vector2 pos
        0, // int frame
        1.0 / 12.0, // float updateTime 
        0.0 // float runningTime
    };

    AnimData neb2Data{ 
        {0.0, 0.0, nebula.width / 8, nebula.height / 8}, // Rectangle rec
        {windowWidth + 300, windowHeight - nebula.height / 8}, // Vector2 pos
        0, // int frame
        1.0 / 16.0, // float updateTime 
        0.0 // float runningTime
    };

    Rectangle nebRect{0.0, 0.0, nebula.width / 8, nebula.height / 8};
    Vector2 nebulaPos{windowWidth, windowHeight - nebRect.height};

    Rectangle neb2Rect = nebRect;
    Vector2 neb2Pos{windowWidth + 300, windowHeight - neb2Rect.height};

    int nebFrame{}; // Nebula animation frame
    const float nebUpdateTime{1.0 / 12.0}; // Nebula running time
    float nebRunningTime{}; // Nebula time since last frame change

    int neb2Frame{}; // Nebula animation frame
    const float neb2UpdateTime{1.0 / 16.0}; // Nebula running time
    float neb2RunningTime{}; // Nebula time since last frame change

    int nebVel{-200}; // Nebula x velocity (pixels per second)

    // Animation Frame
    int frame{};

    const float updateTime{1.0 / 12.0}; // Time between frames
    float runningTime{}; // Time since last frame change

    // Is the rectangle in the air
    bool isInAir{};

    int velocity{}; // Current velocity

    // Jump velocity (pixels per second)
    const int jumpVelocity{-600};

    // Main game loop
    SetTargetFPS(60);
    while (!WindowShouldClose())
    {
        // Delta time
        const float dT = GetFrameTime(); // Delta time (time since last frame)
        
        // Start Game Logic
        BeginDrawing();
        ClearBackground(WHITE);

        // perform ground check
        if (scarfyPos.y >= windowHeight - scarfyRect.height) {
            velocity = 0; // Reset velocity when on the ground
            isInAir = false;
        }
        else
        {
            velocity += gravity * dT; // Apply gravity when in the air
            isInAir = true;
        }

        // Jump logic / jump check
        if (IsKeyPressed(KEY_SPACE) && !isInAir) {
            velocity += jumpVelocity; // Jump velocity
        }
        
        // Nebula movement
        nebulaPos.x += nebVel * dT;

        // Nebula 2 movement
        neb2Pos.x += nebVel * dT;

        // Update position
        scarfyPos.y += velocity * dT;

        // Scarfy Animation Logic
        if (!isInAir) 
        {
            // Update running time
            runningTime += dT;
            if (runningTime >= updateTime) 
            {
                runningTime = 0.0;
                
                // Update animation frame
                scarfyRect.x = frame * scarfyRect.width;
                frame++;
                if (frame > 5)
                {
                    frame = 0;
                }
            }
        }

        // Nebula animation frame
        nebRunningTime += dT;
        if (nebRunningTime >= (nebUpdateTime)) 
        {
            nebRunningTime = 0.0;
            nebRect.x = nebFrame * nebRect.width;
            nebFrame++;
            if (nebFrame > 7)
            {
                nebFrame = 0;
            }
        }

        // Nebula animation frame
        neb2RunningTime += dT;
        if (neb2RunningTime >= (neb2UpdateTime)) 
        {
            neb2RunningTime = 0.0;
            neb2Rect.x = neb2Frame * neb2Rect.width;
            neb2Frame++;
            if (neb2Frame > 7)
            {
                neb2Frame = 0;
            }
        }

        // draw Nebula
        DrawTextureRec(nebula, nebRect, nebulaPos, WHITE); // Draw the texture
        // draw second Nebula
        DrawTextureRec(nebula, neb2Rect, neb2Pos, RED); // Draw the texture

        // draw Scarfy
        DrawTextureRec(scarfy, scarfyRect, scarfyPos, WHITE); // Draw the texture
        
        // End Game Logic
        EndDrawing();
    }
    
    // Unload texture
    UnloadTexture(scarfy);
    UnloadTexture(nebula);

    // Close the window properly
    CloseWindow();
}