Kiến trúc: Serverless (Không máy chủ)

// Đây là một snippet giải thích khái niệm và ví dụ giả mã.

/*
 * KIẾN TRÚC SERVERLESS CHO UNITY GAME
 *
 * Serverless không có nghĩa là không có server, mà là bạn (lập trình viên) không cần phải
 * trực tiếp quản lý, cấu hình hay duy trì một máy chủ ảo (VPS). Thay vào đó, bạn viết các
 * hàm (functions) và triển khai chúng lên một nền tảng đám mây (như Firebase Functions,
 * AWS Lambda, Azure Functions). Nền tảng này sẽ tự động chạy hàm đó khi có yêu cầu.
 *
 * 1. KHI NÀO DÙNG SERVERLESS TRONG UNITY?
 *    - Không dùng cho logic game thời gian thực (real-time gameplay) như Client-Server.
 *    - Rất phù hợp cho các tính năng không yêu cầu phản hồi tức thì và hoạt động theo sự kiện:
 *        + Bảng xếp hạng (Leaderboards): Gửi điểm số của người chơi lên một function để xử lý.
 *        + Dữ liệu người chơi: Lưu/tải tiến trình game.
 *        + Hệ thống tin nhắn, quà tặng.
 *        + Xác thực giao dịch IAP (In-App Purchase) với server.
 *        + Xử lý logic sau khi một trận đấu kết thúc.
 *
 * 2. VÍ DỤ: HỆ THỐNG LEADERBOARD VỚI FIREBASE FUNCTIONS
 *    - Nền tảng sử dụng: Unity (Client) và Firebase (Functions, Firestore).
 *
 *    a. Phía Client (Unity - C#):
 *       - Sau khi người chơi kết thúc màn chơi, Client lấy điểm số.
 *       - Client sử dụng một thư viện HTTP (ví dụ: UnityWebRequest) để gửi một request POST
 *         đến một URL endpoint của Firebase Function.
 */

 using UnityEngine;
 using UnityEngine.Networking;
 using System.Collections;

 public class LeaderboardSubmitter : MonoBehaviour
 {
     private const string submitScoreUrl = "https://your-region-your-project-id.cloudfunctions.net/submitScore";

     public void SubmitScore(string playerName, int score)
     {
         StartCoroutine(PostScore(playerName, score));
     }

     private IEnumerator PostScore(string name, int score)
     {
         WWWForm form = new WWWForm();
         form.AddField("playerName", name);
         form.AddField("score", score.ToString());

         using (UnityWebRequest www = UnityWebRequest.Post(submitScoreUrl, form))
         {
             // Gửi request và chờ phản hồi
             yield return www.SendWebRequest();

             if (www.result == UnityWebRequest.Result.Success)
             {
                 Debug.Log("Score submitted successfully: " + www.downloadHandler.text);
             }
             else
             {
                 Debug.LogError("Error submitting score: " + www.error);
             }
         }
     }
 }

 /*
 *    b. Phía Backend (Firebase Functions - TypeScript/Node.js):
 *       - Bạn viết một function tên là `submitScore`.
 *       - Function này sẽ được kích hoạt khi có một HTTP request đến endpoint của nó.
 *       - Function đọc dữ liệu (playerName, score) từ request, xác thực, và lưu vào
 *         cơ sở dữ liệu Firestore.
 */

 /*
 const functions = require("firebase-functions");
 const admin = require("firebase-admin");
 admin.initializeApp();

 exports.submitScore = functions.https.onRequest(async (req, res) => {
   // Chỉ cho phép phương thức POST
   if (req.method !== "POST") {
     res.status(405).send("Method Not Allowed");
     return;
   }

   const playerName = req.body.playerName;
   const score = parseInt(req.body.score);

   // Xác thực dữ liệu (ví dụ đơn giản)
   if (!playerName || isNaN(score)) {
     res.status(400).send("Invalid data.");
     return;
   }

   // Lưu vào Firestore
   await admin.firestore().collection("scores").add({
     name: playerName,
     score: score,
     timestamp: admin.firestore.FieldValue.serverTimestamp(),
   });

   res.status(200).send({ message: "Score saved!" });
 });
 */

/*
 * 3. ƯU ĐIỂM:
 *    - Tiết kiệm chi phí: Bạn chỉ trả tiền khi function được thực thi.
 *    - Tự động co giãn (Scalability): Nền tảng tự xử lý hàng ngàn request cùng lúc.
 *    - Không cần quản lý server: Không lo về OS, patching, security...
 *
 * 4. NHƯỢC ĐIỂM:
 *    - Cold Starts: Lần đầu tiên một function được gọi sau một thời gian không hoạt động, nó
 *      có thể mất vài giây để khởi động, gây ra độ trễ.
 *    - Giới hạn thời gian thực thi: Các function thường có giới hạn thời gian chạy (ví dụ: vài phút).
 */