#include "raylib.h"
#include <stdio.h>
#include <stdlib.h>

// 螢幕寬度常數
const int screenWidth = 800;
// 螢幕高度常數
const int screenHeight = 600;

// 球拍移動方向列舉
typedef enum {
    UP, // 向上
    DOWN, // 向下
} Dir;

// Clamp 函式：限制浮點數值在指定範圍內
float Clamp(float value, float min, float max)
{
    float result = (value < min) ? min : value; // 若 value 小於 min，則結果為 min
    if (result > max) // 若結果大於 max，則結果為 max
        result = max;
    return result;
}

// 球體結構定義
typedef struct Ball {
    float x, y; // 球心 X, Y 座標
    float speedx, speedy; // 球在 X, Y 軸的速度
    float radius; // 球的半徑
    void (*draw)(struct Ball*); // 繪製球的函式指標
    void (*update)(struct Ball*); // 更新球狀態的函式指標
} Ball;

// 球體繪製函式 (畫圓)
static void ball_drawCircle(Ball* b)
{
    DrawCircle((int)b->x, (int)b->y, b->radius, WHITE); // 使用 raylib 繪製白色圓形
}

// 球體更新函式
static void ball_update(Ball* b)
{
    // 更新球的位置
    b->x += b->speedx * GetFrameTime(); // X 軸位置根據速度和幀時間更新
    b->y += b->speedy * GetFrameTime(); // Y 軸位置根據速度和幀時間更新

    /* 邊界碰撞檢測 */
    // 上下邊界反彈
    if (b->y < 0) { // 若球超出上邊界
        b->y = 0; // 將球 Y 座標設為邊界位置
        b->speedy *= -1; // Y 軸速度反向 (反彈)
    }
    if (b->y > screenHeight) { // 若球超出下邊界
        b->y = screenHeight; // 將球 Y 座標設為邊界位置
        b->speedy *= -1; // Y 軸速度反向 (反彈)
    }
    // 左右邊界碰撞在 Update 函式中不處理，輸贏判斷在 Update 函式中處理
}

// 球體建立函式
Ball CreateBall(float x, float y, float speedx, float speedy, float radius)
{
    // 使用複合字面值初始化 Ball 結構體
    return (Ball) {
        .x = x, // 初始化 X 座標
        .y = y, // 初始化 Y 座標
        .speedx = speedx, // 初始化 X 軸速度
        .speedy = speedy, // 初始化 Y 軸速度
        .radius = radius, // 初始化半徑
        .draw = ball_drawCircle, // 設定繪製函式為 ball_drawCircle
        .update = ball_update, // 設定更新函式為 ball_update
    };
}

// 球拍結構定義
typedef struct Paddle {
    float x, y; // 球拍中心 X, Y 座標
    float speed; // 球拍移動速度
    float width, height; // 球拍寬度和高度
    Rectangle (*getRect)(struct Paddle*); // 取得球拍矩形範圍的函式指標
    void (*draw)(struct Paddle*); // 繪製球拍的函式指標
    void (*update)(struct Paddle*, Dir); // 更新球拍狀態的函式指標，Dir 參數表示移動方向
} Paddle;

// 取得球拍矩形範圍函式
Rectangle paddle_GetRect(struct Paddle* p)
{
    // 計算球拍的 Rectangle 結構，用於碰撞檢測和繪製
    return (Rectangle) {
        p->x - p->width / 2, // 左上角 X 座標 (中心 X 減去寬度一半)
        p->y - p->height / 2, // 左上角 Y 座標 (中心 Y 減去高度一半)
        p->width, // 寬度
        p->height // 高度
    };
}

// 球拍繪製函式
void paddle_draw(struct Paddle* p)
{
    DrawRectangleRec(p->getRect(p), WHITE); // 使用 raylib 繪製白色矩形，使用 getRect 取得矩形範圍
}

// 球拍更新函式
void paddle_update(struct Paddle* p, Dir d)
{
    switch (d) {
    case UP: // 向上移動
        p->y -= p->speed * GetFrameTime(); // Y 座標減去速度 (向上移動)
        p->y = Clamp(p->y, p->height / 2, screenHeight - p->height / 2); // 限制球拍 Y 座標在螢幕上下邊界內
        break;
    case DOWN: // 向下移動
        p->y += p->speed * GetFrameTime(); // Y 座標加上速度 (向下移動)
        p->y = Clamp(p->y, p->height / 2, screenHeight - p->height / 2); // 限制球拍 Y 座標在螢幕上下邊界內 (修正：原程式碼 `DOWN` 缺少 Clamp)
        break;
    default:
        break;
    }
}

// 球拍建立函式
Paddle CreatePaddle(float x, float y, float w, float h, float speed)
{
    // 使用複合字面值初始化 Paddle 結構體
    return (Paddle) {
        .x = x, // 初始化 X 座標
        .y = y, // 初始化 Y 座標
        .width = w, // 初始化寬度
        .height = h, // 初始化高度
        .speed = speed, // 初始化速度
        .getRect = paddle_GetRect, // 設定取得矩形範圍函式為 paddle_GetRect
        .draw = paddle_draw, // 設定繪製函式為 paddle_draw
        .update = paddle_update, // 設定更新函式為 paddle_update
    };
}

// 遊戲結構體，包含球和兩個球拍
typedef struct Game {
    Ball ball; // 球
    Paddle Player; // 玩家球拍
    Paddle ai; // AI 球拍
} Game;

Game game = {}; // 宣告一個 Game 型別的變數 game 並初始化 (全域變數)

// 更新遊戲狀態函式
char* Update(Game* game)
{
    game->ball.update(&game->ball); // 更新球的狀態

    /* 玩家控制 */
    // 左球拍控制 (W/S鍵)
    if (IsKeyDown(KEY_W))
        game->Player.update(&game->Player, UP); // 按下 W 鍵，玩家球拍向上移動
    if (IsKeyDown(KEY_S))
        game->Player.update(&game->Player, DOWN); // 按下 S 鍵，玩家球拍向下移動

    /* AI控制 */
    // 只在球向右移動時反應 (speedx > 0)
    if (game->ball.speedx > 0) {
        // 計算球和 AI 球拍的中心 Y 位置
        float ballCenterY = game->ball.y;
        float paddleCenterY = game->ai.y;

        // 根據位置調整 AI 球拍
        if (ballCenterY < paddleCenterY) { // 球在 AI 球拍上方
            game->ai.y -= game->ai.speed * GetFrameTime(); // AI 球拍向上移動
        } else if (ballCenterY > paddleCenterY) { // 球在 AI 球拍下方
            game->ai.y += game->ai.speed * GetFrameTime(); // AI 球拍向下移動
        }
        game->ai.y = Clamp(game->ai.y, game->ai.height / 2, screenHeight - game->ai.height / 2); // 限制 AI 球拍 Y 座標在螢幕上下邊界內 (新增 AI 球拍邊界限制)
    }

    /* 碰撞檢測 */
    // 左球拍 (玩家) 碰撞
    if (CheckCollisionCircleRec((Vector2) { game->ball.x, game->ball.y }, game->ball.radius, game->Player.getRect(&game->Player))) {
        if (game->ball.speedx < 0) { // 只處理球向左移動時與左球拍的碰撞
            game->ball.speedx *= -1.1f; // X 軸速度反向並稍微加速 (1.1 倍)
            // 根據碰撞位置調整 Y 軸速度，模擬旋轉效果
            game->ball.speedy = (game->ball.y - game->Player.y) / (game->Player.height / 2) * game->ball.speedx;
        }
    }

    // 右球拍 (AI) 碰撞
    if (CheckCollisionCircleRec((Vector2) { game->ball.x, game->ball.y }, game->ball.radius, game->ai.getRect(&game->ai))) {
        if (game->ball.speedx > 0) { // 只處理球向右移動時與右球拍的碰撞
            game->ball.speedx *= -1.1f; // X 軸速度反向並稍微加速 (1.1 倍)
            // 根據碰撞位置調整 Y 軸速度，模擬旋轉效果
            game->ball.speedy = (game->ball.y - game->ai.y) / (game->ai.height / 2) * -game->ball.speedx; // 注意 AI 球拍的 Y 軸速度方向相反
        }
    }

    char* winnerText = NULL; // 勝利訊息，預設為 NULL

    /* 勝利條件檢測 */
    if (game->ball.x < 0) // 球超出左邊界，AI 獲勝
        winnerText = "AI Wins!"; // 設定 AI 獲勝訊息
    if (game->ball.x > screenWidth) // 球超出右邊界，玩家獲勝
        winnerText = "Player Wins!"; // 設定玩家獲勝訊息

    /* 遊戲重置 */
    if (winnerText && IsKeyPressed(KEY_SPACE)) { // 若有勝利者且按下空白鍵
        // 重置球的位置和速度
        game->ball = CreateBall(screenWidth / 2, screenHeight / 2, 300, 300, 5); // 將球放回螢幕中心，恢復初始速度
        // 隨機化球的初始 X 軸速度方向 (改進：讓遊戲開始時球的方向更隨機)
        if (GetRandomValue(0, 1)) {
            game->ball.speedx *= -1; // 50% 機率反轉 X 軸速度
        }
        winnerText = NULL; // 清除勝利訊息，準備開始新局
    }

    return winnerText; // 返回勝利訊息 (若有，否則返回 NULL)
}

// 繪製遊戲畫面函式
void Draw(Game* game)
{
    game->ball.draw(&game->ball);    // 繪製球
    game->Player.draw(&game->Player); // 繪製玩家球拍
    game->ai.draw(&game->ai);        // 繪製 AI 球拍
}

// 主函式
int main()
{
    // 初始化視窗
    InitWindow(screenWidth, screenHeight, "Pong-Game -- Ethical Aniruddha"); // 建立視窗，設定寬高和標題
    SetWindowState(FLAG_VSYNC_HINT); // 啟用垂直同步 (建議啟用，減少畫面撕裂)

    // 初始化遊戲物件
    game.ball = CreateBall(
        screenWidth / 2,     // 初始 X 位置 (螢幕中心)
        screenHeight / 2,    // 初始 Y 位置 (螢幕中心)
        300, 300, 5         // 初始 X 軸速度, 初始 Y 軸速度, 半徑
    );
    // 隨機化球的初始 X 軸速度方向 (改進：讓遊戲開始時球的方向更隨機)
    if (GetRandomValue(0, 1)) {
        game.ball.speedx *= -1; // 50% 機率反轉 X 軸速度
    }
    game.Player = CreatePaddle(
        50, screenHeight / 2, // X 位置 (靠近左邊界), Y 位置 (螢幕垂直中心)
        10, 100, 500         // 寬度, 高度, 速度
    );
    game.ai = CreatePaddle(
        screenWidth - 50, screenHeight / 2, // X 位置 (靠近右邊界), Y 位置 (螢幕垂直中心)
        10, 100, 500         // 寬度, 高度, 速度
    );

    const char* winnerText = NULL; // 宣告勝利訊息指標，初始為 NULL

    // 主遊戲迴圈
    while (!WindowShouldClose()) { // 視窗未關閉時持續執行迴圈
        winnerText = Update(&game); // 更新遊戲狀態，並取得勝利訊息 (若有)

        BeginDrawing();           // 開始繪製畫面
        ClearBackground(BLACK);    // 清除背景為黑色

        // 繪製所有遊戲物件
        Draw(&game);

        // 顯示勝利訊息 (若有)
        if (winnerText) {
            int textWidth = MeasureText(winnerText, 60); // 計算勝利訊息文字寬度
            DrawText(winnerText,                               // 繪製文字
                screenWidth / 2 - textWidth / 2,           // X 座標置中
                screenHeight / 2 - 30,                      // Y 座標略為偏上
                60, YELLOW);                                // 字體大小 60，顏色黃色
        }

        DrawFPS(10, 10); // 顯示 FPS (幀率) 在左上角
        EndDrawing();             // 結束繪製，將畫面送出顯示
    }

    CloseWindow(); // 關閉視窗並釋放資源
    return 0;      // 程式結束
}