// ❌ new Error() เฉย ๆ — โปรแกรมไม่หยุด
console.log("ก่อนสร้าง Error");
const myError = new Error("มีปัญหาเกิดขึ้น");
console.log(myError.message); // "มีปัญหาเกิดขึ้น"
console.log("หลังสร้าง Error — ยังทำงานต่อได้!");
// output:
// "ก่อนสร้าง Error"
// "มีปัญหาเกิดขึ้น"
// "หลังสร้าง Error — ยังทำงานต่อได้!"
// ^ new Error() เป็นแค่การสร้าง object — โค้ดทุกบรรทัดทำงานครบ

// ❌ throw new Error() — หยุดโปรแกรมทันที
console.log("ก่อน throw");
throw new Error("พบข้อผิดพลาดร้ายแรง!");
console.log("บรรทัดนี้จะไม่ทำงาน"); // ❌ ไม่ถูก execute
// output:
// "ก่อน throw"
// Error: พบข้อผิดพลาดร้ายแรง!
// ^ throw หยุดการทำงานที่บรรทัด throw ทันที
//   console.log หลัง throw ไม่ถูก execute เลย

// ❌ throw string — ไม่แนะนำ
throw "เกิดข้อผิดพลาด";
// ^ โยน string ธรรมดา — ไม่มี .name, .message, ไม่มี stack trace
//   console แสดงแค่ string — ไม่รู้ว่า error ประเภทอะไร เกิดที่บรรทัดไหน

// ❌ throw number — ไม่แนะนำ
throw 404;
// ^ โยนตัวเลข — ยิ่งแย่กว่า string เพราะ number ไม่มีทางสื่อสารได้ว่าเกิดอะไรขึ้น

// ✅ throw Error object — แนะนำ
throw new Error("ไม่พบข้อมูลผู้ใช้");
// ^ Error object มี .name = "Error", .message = "ไม่พบข้อมูลผู้ใช้"
//   และมี stack trace บอกว่าเกิดที่บรรทัดไหน ผ่าน function อะไรมาบ้าง

// ✅ throw Error subtype — ระบุประเภท error ได้ชัดเจน
throw new TypeError("price ต้องเป็นตัวเลขเท่านั้น");
// ^ TypeError บอกชัดว่าเป็น error เกี่ยวกับ type — ต่างจาก Error ทั่วไป

function level3() {
  console.log("level3: เริ่มทำงาน");
  throw new Error("เกิดข้อผิดพลาดใน level3!");
  console.log("level3: บรรทัดนี้ไม่ทำงาน"); // ❌ ไม่ถูก execute
}

function level2() {
  console.log("level2: เริ่มทำงาน");
  level3(); // level3() throw error — level2() ก็หยุดด้วย
  console.log("level2: บรรทัดนี้ไม่ทำงาน"); // ❌ ไม่ถูก execute
}

function level1() {
  console.log("level1: เริ่มทำงาน");
  level2(); // level2() รับ error ต่อจาก level3() — level1() ก็หยุดด้วย
  console.log("level1: บรรทัดนี้ไม่ทำงาน"); // ❌ ไม่ถูก execute
}

console.log("เริ่มโปรแกรม");
level1();
console.log("จบโปรแกรม — บรรทัดนี้ไม่ทำงาน"); // ❌ ไม่ถูก execute

// output:
// "เริ่มโปรแกรม"
// "level1: เริ่มทำงาน"
// "level2: เริ่มทำงาน"
// "level3: เริ่มทำงาน"
// Error: เกิดข้อผิดพลาดใน level3!
//   at level3 (...)
//   at level2 (...)
//   at level1 (...)
// ^ error เดินทาง: level3 → level2 → level1 → global
//   ทุก function ใน chain หยุดทำงาน — ไม่มีใครได้ทำงานต่อ

function processOrder(order) {
  console.log("1. เริ่มประมวลผลคำสั่งซื้อ"); // ✅ ทำงาน

  if (!order.items || order.items.length === 0) {
    console.log("2. ตรวจพบว่าไม่มีรายการสินค้า"); // ✅ ทำงาน (ถ้าเงื่อนไขเป็นจริง)
    throw new Error("คำสั่งซื้อต้องมีรายการสินค้าอย่างน้อย 1 รายการ"); // ❌ หยุดตรงนี้
    console.log("3. บรรทัดนี้ไม่ทำงาน"); // ❌ ไม่ถูก execute
  }

  console.log("4. คำนวณราคารวม"); // ✅ ทำงาน (ถ้าไม่ throw)
  return order.items.length;
}

// กรณีมีสินค้า — ไม่ throw
console.log(processOrder({ items: ["A", "B"] }));
// output:
// "1. เริ่มประมวลผลคำสั่งซื้อ"
// "4. คำนวณราคารวม"
// 2

// กรณีไม่มีสินค้า — throw
console.log(processOrder({ items: [] }));
// output:
// "1. เริ่มประมวลผลคำสั่งซื้อ"
// "2. ตรวจพบว่าไม่มีรายการสินค้า"
// Error: คำสั่งซื้อต้องมีรายการสินค้าอย่างน้อย 1 รายการ
// ^ บรรทัดที่ 3 และ 4 ไม่ทำงาน — throw หยุดทุกอย่าง

// ✅ ฟังก์ชันพร้อม guard clause — ตรวจสอบ input ก่อนทำงาน
function calculateDiscount(price, discountPercent) {
  // Guard 1: ตรวจ type ของ argument
  if (typeof price !== "number") {
    throw new TypeError("price ต้องเป็นตัวเลขเท่านั้น");
  }
  if (typeof discountPercent !== "number") {
    throw new TypeError("discountPercent ต้องเป็นตัวเลขเท่านั้น");
  }

  // Guard 2: ตรวจช่วงของค่า
  if (price < 0) {
    throw new RangeError("price ต้องมากกว่าหรือเท่ากับ 0");
  }
  if (discountPercent < 0 || discountPercent > 100) {
    throw new RangeError("discountPercent ต้องอยู่ระหว่าง 0 ถึง 100");
  }

  // ✅ ผ่านทุก guard — input ถูกต้อง คำนวณต่อได้
  const discount = price * (discountPercent / 100);
  return price - discount;
}

// ✅ input ถูกต้อง — ทำงานได้ปกติ
console.log(calculateDiscount(1000, 20)); // 800

// ❌ input ผิด type — TypeError
// console.log(calculateDiscount("1000", 20));
// TypeError: price ต้องเป็นตัวเลขเท่านั้น

// ❌ input อยู่นอกช่วง — RangeError
// console.log(calculateDiscount(1000, 150));
// RangeError: discountPercent ต้องอยู่ระหว่าง 0 ถึง 100

// ✅ guard clause หลายชั้น — อ่านง่าย error message ชัดเจน
function registerUser(username, age, email) {
  // Guard 1: ตรวจ type
  if (typeof username !== "string") {
    throw new TypeError("username ต้องเป็น string");
  }
  if (typeof age !== "number") {
    throw new TypeError("age ต้องเป็นตัวเลข");
  }
  if (typeof email !== "string") {
    throw new TypeError("email ต้องเป็น string");
  }

  // Guard 2: ตรวจค่าว่าง
  if (username.trim() === "") {
    throw new Error("username ห้ามเป็นค่าว่าง");
  }
  if (email.trim() === "") {
    throw new Error("email ห้ามเป็นค่าว่าง");
  }

  // Guard 3: ตรวจช่วงของค่า
  if (age < 0 || age > 150) {
    throw new RangeError("age ต้องอยู่ระหว่าง 0 ถึง 150");
  }

  // Guard 4: ตรวจรูปแบบข้อมูล
  if (!email.includes("@")) {
    throw new Error("email ต้องมี @ — รูปแบบอีเมลไม่ถูกต้อง");
  }

  // ✅ ผ่านทุก guard — ข้อมูลถูกต้อง สร้างผู้ใช้ต่อได้
  console.log("ลงทะเบียนผู้ใช้:", username);
  return { username, age, email };
}

// ✅ ข้อมูลถูกต้อง
console.log(registerUser("สมชาย", 25, "somchai@email.com"));
// output:
// "ลงทะเบียนผู้ใช้: สมชาย"
// { username: "สมชาย", age: 25, email: "somchai@email.com" }

// ❌ ข้อมูลผิด — throw ที่ guard แรกที่เจอ
// console.log(registerUser("", 25, "test@email.com"));
// Error: username ห้ามเป็นค่าว่าง

// ✅ TypeError — เมื่อ type ของค่าผิด
function repeat(text, times) {
  if (typeof text !== "string") {
    throw new TypeError("text ต้องเป็น string — แต่ได้รับ " + typeof text);
  }
  if (typeof times !== "number") {
    throw new TypeError("times ต้องเป็นตัวเลข — แต่ได้รับ " + typeof times);
  }
  return text.repeat(times);
}

// ✅ RangeError — เมื่อค่าอยู่นอกช่วง
function setAge(age) {
  if (age < 0 || age > 150) {
    throw new RangeError("age ต้องอยู่ระหว่าง 0 ถึง 150 — แต่ได้รับ " + age);
  }
  console.log("อายุ:", age);
}

// ✅ Error ทั่วไป — เมื่อเป็นข้อผิดพลาดด้าน logic หรือเงื่อนไขทางธุรกิจ
function withdraw(balance, amount) {
  if (amount <= 0) {
    throw new Error("จำนวนเงินที่ถอนต้องมากกว่า 0 — แต่ได้รับ " + amount);
  }
  if (amount > balance) {
    throw new Error("ยอดเงินคงเหลือไม่พอ — มี " + balance + " แต่ต้องการถอน " + amount);
  }
  return balance - amount;
}

// ตัวอย่างการใช้งาน
console.log(repeat("Hi", 3));    // "HiHiHi"
setAge(25);                      // "อายุ: 25"
console.log(withdraw(1000, 300)); // 700

// ❌ โยน string — ไม่มีข้อมูล error ที่เป็นประโยชน์
function checkAge(age) {
  if (age < 0) {
    throw "อายุต้องมากกว่า 0"; // ❌ string — ไม่มี .name, ไม่มี stack trace
  }
}
// checkAge(-5);
// ^ console แสดงแค่ "อายุต้องมากกว่า 0" — ไม่รู้ว่า error ประเภทอะไร เกิดที่บรรทัดไหน

// ✅ โยน Error object — มีข้อมูลครบ
function checkAge2(age) {
  if (age < 0) {
    throw new RangeError("age ต้องมากกว่าหรือเท่ากับ 0 — แต่ได้รับ " + age);
  }
}
// checkAge2(-5);
// RangeError: age ต้องมากกว่าหรือเท่ากับ 0 — แต่ได้รับ -5
//   at checkAge2 (...)
// ^ มี .name = "RangeError", .message = "age ต้องมากกว่า...", และ stack trace

// ❌ throw ก่อนทำงานที่จำเป็น — ข้อมูลไม่ถูกบันทึก
function saveAndValidate(data) {
  throw new Error("ข้อมูลไม่ถูกต้อง"); // ❌ throw ก่อน
  console.log("บันทึกข้อมูลลง log");  // ❌ ไม่ทำงาน — log ไม่ถูกบันทึก
}

// ✅ ทำงานที่จำเป็นก่อน throw
function saveAndValidate2(data) {
  console.log("บันทึกข้อมูลลง log — ได้รับ data:", data); // ✅ ทำงานก่อน throw
  if (!data.name) {
    throw new Error("ข้อมูลต้องมี name"); // ✅ throw หลังทำงานที่จำเป็น
  }
  return "ผ่าน";
}

console.log(saveAndValidate2({}));
// output:
// "บันทึกข้อมูลลง log — ได้รับ data: {}"
// Error: ข้อมูลต้องมี name
// ^ log ถูกบันทึกก่อน throw — ข้อมูลไม่หาย

// ❌ throw ใน production โดยไม่มี try-catch — ผู้ใช้เห็น error
function getUserData(userId) {
  if (!userId) {
    throw new Error("userId is required"); // ❌ โปรแกรมหยุด — ผู้ใช้เห็น error
  }
  return { id: userId, name: "สมชาย" };
}

// ✅ แสดงข้อความที่เป็นมิตรแทน throw — หรือใช้ try-catch (บทถัดไป)
function getUserData2(userId) {
  if (!userId) {
    console.error("ข้อผิดพลาด: userId is required");
    return null; // ✅ คืน null แทนการ throw — ผู้ใช้ไม่เห็น error dump
  }
  return { id: userId, name: "สมชาย" };
}

console.log(getUserData2(""));  // null — จัดการได้
console.log(getUserData2(123)); // { id: 123, name: "สมชาย" }

// 💡 throw มีไว้สำหรับข้อผิดพลาดที่ "ควรหยุดการทำงาน" — ถ้าแค่ต้องการส่งสัญญาณ
//    ว่าข้อมูลไม่ถูกต้องและให้ caller จัดการ return null หรือ return { error: "..." } ก็พอ
//    บทถัดไป (try-catch) จะสอนวิธีดักจับ error ที่ถูก throw ขึ้นมา