// ❌ ทุกอย่างเป็น Error หมด — .name ไม่ช่วยบอกสาเหตุ
function processOrder(quantity, price) {
  if (typeof quantity !== "number") {
    throw new Error("quantity ต้องเป็น number");
    // ^ .name = "Error" — ไม่รู้ว่าเกี่ยวกับ type ถ้าดูแค่ .name
  }
  if (quantity < 1 || quantity > 100) {
    throw new Error("quantity ต้องอยู่ระหว่าง 1 ถึง 100");
    // ^ .name = "Error" — ไม่รู้ว่าเกี่ยวกับ range
  }
  if (price <= 0) {
    throw new Error("price ต้องมากกว่า 0");
    // ^ .name = "Error" — ดู .name อย่างเดียวไม่รู้ว่าเป็นเรื่องอะไร
  }
}

// ✅ เลือก Error type ให้ตรงกับสาเหตุ — .name สื่อปัญหาได้ทันที
function processOrder(quantity, price) {
  if (typeof quantity !== "number") {
    throw new TypeError("quantity ต้องเป็น number");
    // ^ .name = "TypeError" — เห็นปุ๊บรู้เลยว่า type ผิด
  }
  if (quantity < 1 || quantity > 100) {
    throw new RangeError("quantity ต้องอยู่ระหว่าง 1 ถึง 100");
    // ^ .name = "RangeError" — เห็นปุ๊บรู้เลยว่าค่าอยู่นอกช่วง
  }
  if (price <= 0) {
    throw new Error("price ต้องมากกว่า 0");
    // ^ .name = "Error" — ข้อผิดพลาดด้าน logic ทั่วไป
  }
}

function validateOrder(order) {
  // === คำถามที่ 1: ตรวจ type ===
  if (typeof order !== "object" || order === null) {
    throw new TypeError("order ต้องเป็น object");
  }
  if (typeof order.productName !== "string") {
    throw new TypeError("productName ต้องเป็น string");
  }
  if (typeof order.quantity !== "number") {
    throw new TypeError("quantity ต้องเป็น number");
  }

  // === คำถามที่ 2: ตรวจ range ===
  if (order.quantity < 1) {
    throw new RangeError("quantity ต้องมากกว่าหรือเท่ากับ 1 — แต่ได้รับ " + order.quantity);
  }
  if (order.quantity > 100) {
    throw new RangeError("quantity ต้องไม่เกิน 100 — แต่ได้รับ " + order.quantity);
  }

  // === คำถามที่ 3: ข้อผิดพลาดด้าน logic ===
  if (!order.productName || order.productName.trim() === "") {
    throw new Error("productName ห้ามเป็นค่าว่าง");
  }
  if (order.productName.length > 200) {
    throw new Error("productName ยาวเกินไป — ต้องไม่เกิน 200 ตัวอักษร");
  }

  console.log("✅ คำสั่งซื้อผ่านการตรวจสอบ:", order.productName, "x", order.quantity);
  return true;
}

// ผ่านการตรวจสอบ
validateOrder({ productName: "หนังสือ JavaScript", quantity: 3 });
// output: ✅ คำสั่งซื้อผ่านการตรวจสอบ: หนังสือ JavaScript x 3

// ❌ TypeError — type ผิด
// validateOrder("ไม่ใช่ object");
// TypeError: order ต้องเป็น object

// ❌ RangeError — อยู่นอกช่วง
// validateOrder({ productName: "หนังสือ", quantity: 0 });
// RangeError: quantity ต้องมากกว่าหรือเท่ากับ 1 — แต่ได้รับ 0

// ❌ Error — ข้อผิดพลาดด้าน logic
// validateOrder({ productName: "", quantity: 5 });
// Error: productName ห้ามเป็นค่าว่าง

// ❌ message ที่ไม่เป็นประโยชน์ — เห็นแล้วไม่รู้ว่าอะไรผิด
throw new Error("ผิดพลาด");
throw new Error("error");
throw new Error("ข้อมูลไม่ถูกต้อง");
throw new Error("ไม่พบข้อมูล");
// ^ message พวกนี้บอกว่ามี error — แต่ไม่บอกว่าอะไรผิด หรือควรแก้ยังไง
//   เวลาเจอ error จริงต้องเสียเวลาไล่หาเอง

// ✅ message ที่ดี — บอกว่าอะไรผิด + ค่าที่ได้รับ + ควรแก้อย่างไร
throw new Error("ไม่พบข้อมูลผู้ใช้ ID 12345 — อาจถูกลบไปแล้ว");
throw new Error("ยอดเงินคงเหลือไม่พอ — มี 500 บาท แต่ต้องการถอน 1000 บาท");
throw new Error("คำสั่งซื้อต้องมีรายการสินค้าอย่างน้อย 1 รายการ");
throw new Error("ไม่สามารถเชื่อมต่อฐานข้อมูลได้ — ตรวจสอบว่า server ทำงานอยู่หรือไม่");

// 💡 สูตร message ที่ดี:
// "อะไรผิด" + "ค่าที่ได้รับคืออะไร (ถ้ามี)" + "ควรแก้อย่างไร (ถ้าบอกได้)"
// เช่น: "ชื่อผู้ใช้ห้ามว่างเปล่า" + " — แต่ได้รับ """ + " — กรุณากรอกชื่อผู้ใช้"
//       = "ชื่อผู้ใช้ห้ามว่างเปล่า — แต่ได้รับ "" — กรุณากรอกชื่อผู้ใช้"

// ✅ ข้อมูลไม่ครบ — Error
function createUser(name, email) {
  if (!name || name.trim() === "") {
    throw new Error("name ห้ามเป็นค่าว่าง");
  }
  if (!email || email.trim() === "") {
    throw new Error("email ห้ามเป็นค่าว่าง");
  }
  console.log("สร้างผู้ใช้:", name);
}

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

console.log(withdrawMoney(1000, 300)); // 700

// ✅ สถานะที่ไม่ถูกต้อง — Error
let isLoggedIn = false;
function getProfile() {
  if (!isLoggedIn) {
    throw new Error("ยังไม่ได้เข้าสู่ระบบ — กรุณา login ก่อนดูโปรไฟล์");
  }
  return { name: "สมชาย", role: "member" };
}

// getProfile();
// Error: ยังไม่ได้เข้าสู่ระบบ — กรุณา login ก่อนดูโปรไฟล์

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

console.log(repeatText("Hi", 3)); // "HiHiHi"

// ❌ TypeError — type ผิด
// repeatText(123, 3);
// TypeError: text ต้องเป็น string — แต่ได้รับ number

// ✅ TypeError — ตรวจว่าเป็นฟังก์ชันก่อนเรียก
function safeExecute(fn) {
  if (typeof fn !== "function") {
    throw new TypeError("fn ต้องเป็น function — แต่ได้รับ " + typeof fn);
  }
  fn();
}

safeExecute(() => console.log("ทำงาน!")); // "ทำงาน!"
// safeExecute("ไม่ใช่ฟังก์ชัน");
// TypeError: fn ต้องเป็น function — แต่ได้รับ string

// ✅ type ผิด — TypeError (ถูกต้อง)
function setAge(age) {
  if (typeof age !== "number") {
    throw new TypeError("age ต้องเป็น number — แต่ได้รับ " + typeof age);
    // ^ ปัญหาคือ type ไม่ตรง → TypeError คือตัวเลือกที่ถูกต้อง
  }
  // ...
}

// ❌ ใช้ TypeError กับสิ่งที่ไม่เกี่ยวกับ type — ผิด
function setAge(age) {
  if (typeof age !== "number") {
    throw new TypeError("age ต้องเป็น number");
  }
  if (age < 0) {
    throw new TypeError("age ต้องมากกว่า 0"); // ❌ ผิด! — นี่คือ RangeError ไม่ใช่ TypeError
  }
}

// ✅ แก้ไข — แยก type error กับ range error
function setAge(age) {
  if (typeof age !== "number") {
    throw new TypeError("age ต้องเป็น number — แต่ได้รับ " + typeof age);
  }
  if (age < 0) {
    throw new RangeError("age ต้องมากกว่าหรือเท่ากับ 0 — แต่ได้รับ " + age);
    // ^ ปัญหาคือค่าอยู่นอกช่วง → RangeError คือตัวเลือกที่ถูกต้อง
  }
  if (age > 150) {
    throw new RangeError("age ต้องไม่เกิน 150 — แต่ได้รับ " + age);
  }
  console.log("อายุ:", age);
}

setAge(25); // "อายุ: 25"

// ✅ ข้อมูลไม่ครบ — ไม่เกี่ยวกับ type → Error
function register(name, age) {
  if (typeof name !== "string") {
    throw new TypeError("name ต้องเป็น string"); // type → TypeError
  }
  if (typeof age !== "number") {
    throw new TypeError("age ต้องเป็น number"); // type → TypeError
  }
  if (name.trim() === "") {
    throw new Error("name ห้ามเป็นค่าว่าง"); // ข้อมูลไม่ครบ → Error
    // ^ แม้ name จะเป็น string (type ถูกต้อง) — แต่เป็นค่าว่าง
    //   นี่ไม่ใช่ปัญหา type — เป็นปัญหา logic → Error
  }
  console.log("ลงทะเบียน:", name, "อายุ:", age);
}

register("สมชาย", 30); // "ลงทะเบียน: สมชาย อายุ: 30"

// ✅ RangeError — ปริมาณอยู่นอกช่วง
function orderItem(quantity) {
  if (typeof quantity !== "number") {
    throw new TypeError("quantity ต้องเป็น number — แต่ได้รับ " + typeof quantity);
  }
  if (quantity < 1) {
    throw new RangeError("quantity ต้องมากกว่าหรือเท่ากับ 1 — แต่ได้รับ " + quantity);
  }
  if (quantity > 1000) {
    throw new RangeError("quantity ต้องไม่เกิน 1000 — แต่ได้รับ " + quantity);
  }
  console.log("สั่งสินค้าจำนวน:", quantity, "ชิ้น");
}

orderItem(5);    // "สั่งสินค้าจำนวน: 5 ชิ้น"
orderItem(1);    // "สั่งสินค้าจำนวน: 1 ชิ้น"
orderItem(1000); // "สั่งสินค้าจำนวน: 1000 ชิ้น"

// ❌ RangeError — อยู่นอกช่วง
// orderItem(0);
// RangeError: quantity ต้องมากกว่าหรือเท่ากับ 1 — แต่ได้รับ 0

// ✅ RangeError — เปอร์เซ็นต์เกินช่วง
function applyDiscount(percent) {
  if (typeof percent !== "number") {
    throw new TypeError("percent ต้องเป็น number");
  }
  if (percent < 0 || percent > 100) {
    throw new RangeError("percent ต้องอยู่ระหว่าง 0 ถึง 100 — แต่ได้รับ " + percent);
  }
  console.log("ส่วนลด:", percent + "%");
}

applyDiscount(20);  // "ส่วนลด: 20%"
applyDiscount(0);   // "ส่วนลด: 0%"
applyDiscount(100); // "ส่วนลด: 100%"

// ❌ RangeError
// applyDiscount(150);
// RangeError: percent ต้องอยู่ระหว่าง 0 ถึง 100 — แต่ได้รับ 150

// ✅ RangeError — ชื่อผู้ใช้ยาวเกินกำหนด
function setUsername(name) {
  if (typeof name !== "string") {
    throw new TypeError("name ต้องเป็น string");
  }
  if (name.length === 0) {
    throw new Error("name ห้ามเป็นค่าว่าง"); // ข้อมูลไม่ครบ → Error
  }
  if (name.length > 30) {
    throw new RangeError("ชื่อผู้ใช้ต้องไม่เกิน 30 ตัวอักษร — ตอนนี้ " + name.length + " ตัวอักษร");
    // ^ ความยาวเกิน → RangeError — เพราะเป็นเรื่องของ "เกินขอบเขตที่กำหนด"
  }
  console.log("ตั้งชื่อผู้ใช้:", name);
}

setUsername("somchai"); // "ตั้งชื่อผู้ใช้: somchai"

// ❌ RangeError — ยาวเกิน
// setUsername("ชื่อนี้ยาวมากเกินกว่าสามสิบตัวอักษรจึงไม่สามารถใช้ได้");
// RangeError: ชื่อผู้ใช้ต้องไม่เกิน 30 ตัวอักษร — ตอนนี้ 42 ตัวอักษร

// ✅ RangeError — จำนวนรายการใน array เกินลิมิต
function addToList(list, item) {
  if (!Array.isArray(list)) {
    throw new TypeError("list ต้องเป็น array");
  }
  if (list.length >= 100) {
    throw new RangeError("รายการเต็มแล้ว — รับได้สูงสุด 100 รายการ");
  }
  list.push(item);
  console.log("เพิ่มรายการ — ตอนนี้มี", list.length, "รายการ");
}

let todoList = [];
addToList(todoList, "ซื้อข้าว"); // "เพิ่มรายการ — ตอนนี้มี 1 รายการ"

// ❌ อย่า throw SyntaxError เอง!
function parseJson(jsonString) {
  try {
    return JSON.parse(jsonString);
  } catch (err) {
    // ❌ ผิด — อย่า throw SyntaxError เอง
    throw new SyntaxError("JSON ไม่ถูกต้อง: " + err.message);
    // ^ ปัญหา: คนที่เห็น error นี้จะคิดว่าเกิด SyntaxError ตอน parse
    //   แต่จริง ๆ เราเป็นคน throw — ทำให้ debug สับสน
  }
}

// ✅ ใช้ Error แทน — พร้อม message ที่เป็นประโยชน์
function parseJson(jsonString) {
  try {
    return JSON.parse(jsonString);
  } catch (err) {
    // ✅ ถูกต้อง — ใช้ Error พร้อมข้อมูลที่เป็นประโยชน์
    throw new Error("ข้อมูล JSON ไม่ถูกต้อง — " + err.message);
    // ^ .name = "Error" — ชัดเจนว่าเราเป็นคน throw
    //   .message มีทั้งสาเหตุและรายละเอียด
  }
}

// ========================================

// ❌ อย่า throw ReferenceError เอง!
function getUser(userId) {
  if (userId === undefined) {
    // ❌ ผิด — อย่า throw ReferenceError
    throw new ReferenceError("userId is not defined");
    // ^ ปัญหา: ReferenceError ควรเกิดเมื่อ JavaScript engine หาตัวแปรไม่เจอ
    //   การ throw เองทำให้ debug สับสน — คิดว่าตัวแปรไม่มีอยู่จริง
  }
}

// ✅ ใช้ Error หรือ TypeError แทน
function getUser(userId) {
  if (userId === undefined) {
    // ✅ ถูกต้อง — ใช้ Error
    throw new Error("userId is required — ไม่ได้รับค่า userId");
  }
  return { id: userId, name: "สมชาย" };
}

// ✅ หรือถ้าต้องการระบุว่าเป็นปัญหาเกี่ยวกับค่าที่ไม่ถูกส่งมา
function getUser(userId) {
  if (userId === undefined) {
    throw new TypeError("userId is required — expected string or number, but received undefined");
    // ^ TypeError ก็ใช้ได้ — เพราะ undefined เป็น type หนึ่งที่เราไม่คาดหวัง
  }
  return { id: userId, name: "สมชาย" };
}

function processPayment(payment) {
  // ตรวจ type → TypeError
  if (typeof payment !== "object" || payment === null) {
    throw new TypeError("payment ต้องเป็น object");
  }
  if (typeof payment.amount !== "number") {
    throw new TypeError("payment.amount ต้องเป็น number");
  }
  if (typeof payment.method !== "string") {
    throw new TypeError("payment.method ต้องเป็น string");
  }

  // ตรวจ range → RangeError
  if (payment.amount <= 0) {
    throw new RangeError("จำนวนเงินต้องมากกว่า 0 — แต่ได้รับ " + payment.amount);
  }
  if (payment.amount > 100000) {
    throw new RangeError("จำนวนเงินต้องไม่เกิน 100,000 — แต่ได้รับ " + payment.amount);
  }

  // ตรวจ logic และกฎธุรกิจ → Error
  let validMethods = ["credit-card", "bank-transfer", "e-wallet"];
  if (!validMethods.includes(payment.method)) {
    throw new Error(
      "วิธีการชำระเงินไม่ถูกต้อง — ต้องเป็น " + validMethods.join(", ") +
      " — แต่ได้รับ "" + payment.method + """
    );
  }

  console.log("💳 ชำระเงิน " + payment.amount + " บาท ผ่าน " + payment.method);
  return { status: "success", amount: payment.amount };
}

// ฟังก์ชันหลัก — เรียก processPayment และจัดการ error แต่ละประเภท
function handlePayment(paymentData) {
  try {
    let result = processPayment(paymentData);
    console.log("✅ การชำระเงินสำเร็จ:", result);
    return result;
  } catch (err) {
    // แยกการจัดการตามประเภท error
    if (err.name === "TypeError") {
      // ปัญหาเกี่ยวกับ type — ผู้ใช้ส่งข้อมูลผิด format
      console.log("❌ รูปแบบข้อมูลไม่ถูกต้อง:", err.message);
      console.log("   → แสดงข้อความให้ผู้ใช้ตรวจสอบข้อมูลที่กรอก");
      return { status: "error", reason: "invalid_format", detail: err.message };

    } else if (err.name === "RangeError") {
      // ปัญหาเกี่ยวกับ range — ผู้ใช้ส่งจำนวนเงินเกินช่วง
      console.log("❌ จำนวนเงินอยู่นอกช่วงที่รับได้:", err.message);
      console.log("   → แสดงข้อความบอกช่วงที่ถูกต้องให้ผู้ใช้");
      return { status: "error", reason: "out_of_range", detail: err.message };

    } else {
      // Error อื่น ๆ — ข้อผิดพลาดที่ไม่คาดคิด
      console.log("❌ เกิดข้อผิดพลาด:", err.message);
      console.log("   → log ไว้ debug แล้วแจ้งผู้ใช้แบบทั่วไป");
      return { status: "error", reason: "unknown", detail: err.message };
    }
  }
}

// ทดสอบ — ข้อมูลถูกต้อง
console.log(handlePayment({ amount: 500, method: "credit-card" }));
// output:
// 💳 ชำระเงิน 500 บาท ผ่าน credit-card
// ✅ การชำระเงินสำเร็จ: { status: "success", amount: 500 }
// { status: "success", amount: 500 }

console.log("==========");

// ทดสอบ — TypeError: amount ไม่ใช่ number
console.log(handlePayment({ amount: "ห้าร้อย", method: "credit-card" }));
// output:
// ❌ รูปแบบข้อมูลไม่ถูกต้อง: payment.amount ต้องเป็น number
//    → แสดงข้อความให้ผู้ใช้ตรวจสอบข้อมูลที่กรอก
// { status: "error", reason: "invalid_format", detail: "payment.amount ต้องเป็น number" }

console.log("==========");

// ทดสอบ — RangeError: จำนวนเงินเกิน 100,000
console.log(handlePayment({ amount: 500000, method: "bank-transfer" }));
// output:
// ❌ จำนวนเงินอยู่นอกช่วงที่รับได้: จำนวนเงินต้องไม่เกิน 100,000 — แต่ได้รับ 500000
//    → แสดงข้อความบอกช่วงที่ถูกต้องให้ผู้ใช้
// { status: "error", reason: "out_of_range", detail: "จำนวนเงินต้องไม่เกิน 100,000 — แต่ได้รับ 500000" }

console.log("==========");

// ทดสอบ — Error: วิธีการชำระเงินไม่ถูกต้อง
console.log(handlePayment({ amount: 500, method: "cash" }));
// output:
// ❌ เกิดข้อผิดพลาด: วิธีการชำระเงินไม่ถูกต้อง — ต้องเป็น credit-card, bank-transfer, e-wallet — แต่ได้รับ "cash"
//    → log ไว้ debug แล้วแจ้งผู้ใช้แบบทั่วไป
// { status: "error", reason: "unknown", detail: "วิธีการชำระเงินไม่ถูกต้อง — ต้องเป็น credit-card, bank-transfer, e-wallet — แต่ได้รับ "cash"" }

// ❌ ถ้าใช้ Error อย่างเดียว ทุกอย่าง — catch จัดการแยกประเภทไม่ได้
function processPaymentBad(payment) {
  if (typeof payment.amount !== "number") {
    throw new Error("amount ต้องเป็น number"); // .name = "Error"
  }
  if (payment.amount <= 0) {
    throw new Error("amount ต้องมากกว่า 0");   // .name = "Error"
  }
  if (!["credit-card", "bank-transfer"].includes(payment.method)) {
    throw new Error("method ไม่ถูกต้อง");       // .name = "Error"
  }
}

// ใน catch — แยกไม่ได้ว่าเป็นปัญหาอะไร
try {
  processPaymentBad({ amount: -100, method: "cash" });
} catch (err) {
  // err.name === "Error" — เหมือนกันหมดทั้ง 3 กรณี!
  // ต้องพึ่ง err.message เพื่อเดาว่าปัญหาคืออะไร:
  // - "amount ต้องเป็น number" — น่าจะเกี่ยวกับ type
  // - "amount ต้องมากกว่า 0" — น่าจะเกี่ยวกับ range
  // - "method ไม่ถูกต้อง" — น่าจะเกี่ยวกับ logic
  //
  // แต่การเช็ค err.message เป็น string เปราะบาง —
  // ถ้าเราเปลี่ยน message ต้องเปลี่ยน catch ด้วย ❌
  console.log(err.name, "-", err.message);
}

// ========================================
// ✅ ใช้ Error type ที่ถูกต้อง — catch แยกได้ด้วย err.name
function processPaymentGood(payment) {
  if (typeof payment.amount !== "number") {
    throw new TypeError("amount ต้องเป็น number");   // .name = "TypeError"
  }
  if (payment.amount <= 0) {
    throw new RangeError("amount ต้องมากกว่า 0");     // .name = "RangeError"
  }
  if (!["credit-card", "bank-transfer"].includes(payment.method)) {
    throw new Error("method ไม่ถูกต้อง");             // .name = "Error"
  }
}

try {
  processPaymentGood({ amount: -100, method: "cash" });
} catch (err) {
  // ✅ แยกประเภทได้ทันทีด้วย err.name
  if (err.name === "TypeError") {
    console.log("→ จัดการปัญหา type: แจ้งผู้ใช้ให้ตรวจสอบ format");
  } else if (err.name === "RangeError") {
    console.log("→ จัดการปัญหา range: แจ้งผู้ใช้ให้ตรวจสอบจำนวนเงิน");
  } else {
    console.log("→ จัดการปัญหาอื่น: log แล้วแจ้งผู้ใช้ทั่วไป");
  }
  // ^ ต่อให้เราเปลี่ยน message — catch ยังทำงานถูกเพราะอิงกับ err.name
}
// output:
// → จัดการปัญหา range: แจ้งผู้ใช้ให้ตรวจสอบจำนวนเงิน