// ต้องติดตั้ง @types/node ก่อน: npm install @types/node
import * as http from 'node:http'; 
import { IncomingMessage, ServerResponse } from 'node:http'; // Import Types

const hostname: string = '127.0.0.1';
const port: number = 3000;

// กำหนดชนิดข้อมูลให้กับ req และ res เพื่อให้ TypeScript ช่วยตรวจสอบ
const server = http.createServer((req: IncomingMessage, res: ServerResponse) => {
    // 1. การกำหนด HTTP Status Code
    res.statusCode = 200; 

    // 2. การกำหนด Header
    res.setHeader('Content-Type', 'application/json'); 

    // 3. การจัดการ Routing (อย่างง่าย)
    if (req.url === '/hello' && req.method === 'GET') {
        const data = { message: 'Hello from TypeScript Node.js Server!' };
        res.end(JSON.stringify(data)); // ส่ง Response กลับ
    } else {
        res.statusCode = 404;
        res.end(JSON.stringify({ error: 'Not Found' }));
    }
});

// การเริ่มฟัง (Listen)
server.listen(port, hostname, () => {
    console.log(`Server running at http://${hostname}:${port}/`);
});

// 1. JSON String Data ที่ได้รับจาก Server
const jsonString: string = `
    [
        { "score": 40, "overtime": false },
        { "score": 80, "overtime": true }
    ]
`;

// 2. แปลง JSON String ให้เป็น Object (Array of Objects)
const scores = JSON.parse(jsonString);

// scores จะถูกอนุมานชนิดเป็น Array of any (any[])
console.log(scores.length); // 2
console.log(`First score is ${scores[0].score}`); // First score is 40

// Object หรือ Array ที่ต้องการแปลง
const scores = [
    { score: 40 },
    { score: 80, overtime: true, specialGuest: null } // รองรับ null, boolean
];

// แปลง Object ให้เป็น JSON String
const jsonText: string = JSON.stringify(scores);

console.log(typeof jsonText); // string
// Output: [{"score":40},{"score":80,"overtime":true,"specialGuest":null}]

// Interface สำหรับโครงสร้างข้อมูล
interface Address {
    street: string;
    city: string;
}

interface User {
    firstName: string;
    address: Address; // ใช้ Interface ที่ซ้อนกัน
}

const jsonString = '{"firstName":"Ebiwayo","address":{"street":"My Str.","city":"New York"}}';

// ประกาศตัวแปรเป็นชนิด User หลังจาก parse
const user: User = JSON.parse(jsonString); 

console.log(user.address.city); // New York

class User {
    constructor(
        public firstName: string, 
        public address: Address // ใช้ Interface เป็นชนิดข้อมูล
    ) {}

    // Static Factory Method: ใช้รับ Object ที่ถูกแปลงมาแล้ว (JSON Object)
    static fromJson(json: { [key: string]: any }): User {
        // ตรวจสอบและแปลงข้อมูล Address ที่ซ้อนกัน
        const addressData = json['address'];
        const address = new Address(addressData.street, addressData.city);
        
        return new User(json['firstName'], address);
    }
    
    // Method สำหรับแปลงกลับไปเป็น JSON-ready Object (ถ้าต้องการ)
    public toJson(): any {
        return {
            firstName: this.firstName,
            address: this.address
        };
    }
}

const jsonArray = `[
    { "firstName": "Alice", "address": {...} },
    { "firstName": "Bob", "address": {...} }
]`;

// 1. แปลง JSON String เป็น Array of generic objects
const jsonObjects: any[] = JSON.parse(jsonArray);

// 2. ใช้ .map() เพื่อแปลง Array of any เป็น Array of User (User[])
const userList: User[] = jsonObjects.map(obj => User.fromJson(obj));

console.log(userList[0].firstName); // Alice
console.log(userList.length);       // 2

// ฟังก์ชันสร้าง Stream ของข้อความ 5 บรรทัด
async function* generateLines(to: number): AsyncIterable<string> {
    for (let i = 1; i <= to; i++) {
        // yield จะส่งค่าออกมาทีละชุด แล้วหยุดรอการเรียกครั้งถัดไป
        yield `This is Line ${i}`; 
    }
}

async function processStream() {
    const stream = generateLines(3);
    
    // for await...of จะหยุดรอจนกว่า yield จะส่งค่าออกมา
    for await (const line of stream) {
        console.log(line);
    }
    console.log('Stream completed.');
}

processStream();
// Output: 
// This is Line 1
// This is Line 2
// This is Line 3
// Stream completed.

import { Observable, Subject } from 'rxjs'; // ต้องมีการติดตั้ง RxJS

// 1. สร้าง Subject (Hot Observable/Broadcast Stream)
const mySubject = new Subject<number>();

// 2. ส่งข้อมูล (Pushing Events)
mySubject.next(1); // ข้อมูลถูกส่งออกมาทันที

// 3. Subscription (การฟัง)
mySubject.subscribe(value => {
    console.log(`Listener A: ${value}`);
});

mySubject.next(2); // ผู้ฟัง A จะได้รับค่า 2
mySubject.next(3); // ผู้ฟัง A จะได้รับค่า 3

mySubject.subscribe(value => {
    console.log(`Listener B: ${value}`);
});

mySubject.next(4); 
// Listener A: 4
// Listener B: 4

// สมมติ myObservable คือ Observable<string> ที่ถูกสร้างไว้
const subscription = mySubject.subscribe({
    next: (data) => console.log('Data:', data), // เมื่อมีข้อมูลมา
    error: (err) => console.error('Error:', err), // เมื่อเกิดข้อผิดพลาด
    complete: () => console.log('Done.'), // เมื่อ Stream เสร็จสิ้น
});

// การยกเลิก Stream (คล้าย StreamSubscription)
subscription.unsubscribe();

import { of } from 'rxjs';
import { map, filter } from 'rxjs/operators';

of(1, 2, 3, 4, 5) // สร้าง Observable จากค่า [1, 2, 3, 4, 5]
    .pipe(
        // 1. Filter: กรองเฉพาะเลขคู่เท่านั้น
        filter(value => value % 2 === 0), 
        // 2. Map: แปลงค่าเป็นข้อความ
        map(value => `Number is ${value}`) 
    )
    .subscribe(result => console.log(result)); 
// Output:
// Number is 2
// Number is 4

// การ import ไฟล์หรือ Module ภายนอกเท่านั้น
import { MyClass } from './my_module';
import * as MathUtils from 'lodash'; // ตัวอย่าง External Package

let myStr: string = "Hello TS";
let obj: any; // ค่าเริ่มต้นคือ undefined (ไม่ใช้ null เหมือน Dart)

console.log(myStr);          // Hello TS
console.log(typeof myStr);   // string (ใช้ typeof แทน runtimeType สำหรับ primitive)
console.log(typeof obj);     // undefined

let a: string = "37";
let hexValue: string = "42"; // 42 ในเลขฐาน 16

console.log(parseInt(a));          // 37 (ชนิด number)
console.log(parseInt(hexValue, 16)); // 66 (ระบุฐาน 16 ด้วย radix)
console.log(parseFloat("42.1"));   // 42.1

let numA: number = 123.456;
let fixedStr: string = numA.toFixed(2); // String ทศนิยม 2 ตำแหน่ง

console.log(fixedStr); // "123.46" (มีการปัดเศษ)

let title: string = " ภาษา TypeScript เบื้องต้น ";

console.log(title.trim());      // "ภาษา TypeScript เบื้องต้น" (ลบช่องว่างหัวท้าย)
console.log(title.trimStart()); // "ภาษา TypeScript เบื้องต้น "
console.log(title.trimEnd());   // " ภาษา TypeScript เบื้องต้น"

// การแทนที่ข้อความ (ไม่เปลี่ยน String เดิม แต่สร้าง String ใหม่)
let greetingTemplate = 'สวัสดี, NAME!';
let greeting = greetingTemplate.replace(new RegExp('NAME'), 'Ebiwayo');
// หรือใช้ replaceAll สำหรับแทนที่ทั้งหมดที่ตรงกัน (ถ้ามีหลายตัว)

console.log(greeting); // สวัสดี, Ebiwayo!

let ingredients: Set<string> = new Set();
ingredients.add('gold');
ingredients.add('titanium');
ingredients.add('gold'); // ไม่เพิ่มเพราะซ้ำ

console.log(ingredients.size); // 2 (ใช้ .size แทน .length)
console.log(ingredients.has('titanium')); // true (ใช้ .has() แทน .contains())

// การหาค่าที่ซ้ำกัน (Intersection) ต้องทำผ่านการแปลงเป็น Array
let nobleGases = new Set(['xenon', 'argon', 'gold']);
let intersection = [...ingredients].filter(x => nobleGases.has(x));

console.log(intersection); // ['gold']

// Map<Key Type, Value Type>
let searchTerms = new Map<string, number>();

searchTerms.set('Oahu', 1); // กำหนดค่า
searchTerms.set('Kauai', 2);

console.log(searchTerms.get('Kauai'));      // 2
console.log(searchTerms.has('Kauai'));      // true (ใช้ .has() แทน .containsKey())
searchTerms.delete('Kauai');               // ลบข้อมูล
console.log(searchTerms.has('Kauai'));      // false

// การสร้าง Object URL
const url = new URL('https://example.com:8080/path?query=1#hash');

console.log(url.hostname); // example.com
console.log(url.port);     // 8080
console.log(url.pathname); // /path
console.log(url.searchParams.get('query')); // 1

// Custom Error Class
class WithdrawError extends Error {
    constructor(message?: string) {
        super(message); // เรียก constructor ของ Error class
        this.name = 'WithdrawError'; // กำหนดชื่อ Error (สำคัญในการระบุชนิด)
        // Object.setPrototypeOf(this, WithdrawError.prototype); // สำหรับ JS เก่า
    }
}

// การโยนข้อผิดพลาด (Throwing)
function checkWithdraw(deposit: number, withdraw: number): void {
    if (withdraw > deposit) {
        // โยน Custom Error
        throw new WithdrawError('ยอดเงินไม่เพียงพอ'); 
    }
    if (withdraw <= 0) {
        // โยน Base Error
        throw new Error('ยอดเงินที่ต้องการถอนต้องมากกว่า 0'); 
    }
}

function runTransaction() {
    try {
        checkWithdraw(200, 300); // โค้ดที่อาจเกิดข้อผิดพลาด
    } catch (e) {
        // e คือ error object ที่ถูก throw ออกมา
        console.error("Transaction failed:", e.message); 
        // Output: Transaction failed: ยอดเงินไม่เพียงพอ
    }
}

function runSpecificCatch() {
    try {
        checkWithdraw(200, 300); 
    } catch (error) {
        // 1. ตรวจสอบชนิด Custom Error ก่อน
        if (error instanceof WithdrawError) {
            console.warn(`[Withdraw Check] - ${error.message}`);
        } 
        // 2. ตรวจสอบชนิด Base Error
        else if (error instanceof Error) {
            console.error(`[Base Error] - ${error.message}`);
        } 
        // 3. จัดการกรณีที่ throw มาเป็น String หรือค่าอื่น ๆ (ซึ่งไม่แนะนำ)
        else {
            console.error("Unknown Error type:", error);
        }
    }
}

try {
    throw new Error("Detailed failure.");
} catch (error) {
    if (error instanceof Error) {
        console.log(`Error Name: ${error.name}`);
        console.log(`Stack Trace:n ${error.stack}`); // เข้าถึง Stack Trace
    }
}

function handleAndRethrow(deposit: number, withdraw: number) {
    try {
        checkWithdraw(deposit, withdraw);
    } catch (e) {
        if (e instanceof WithdrawError) {
            // ทำการบันทึกข้อผิดพลาดในระดับนี้ (Log)
            console.warn(`[Local Handler] Logged withdrawal error for user.`);
            // แล้วส่งต่อข้อผิดพลาดนี้ไปให้ Handler ภายนอก
            throw e; 
        } 
        // Error อื่น ๆ จะถูกส่งต่อโดยอัตโนมัติหากไม่ถูกจับ
    }
}

try {
    handleAndRethrow(200, 300);
} catch (e) {
    // Handler ภายนอกจะได้รับ WithdrawError ต่อจาก handleAndRethrow
    console.error(`[Global Handler] Transaction failed completely.`);
}

function runWithCleanup() {
    let connectionStatus = 'open';
    try {
        // โค้ดที่อาจเกิด error
        console.log('Attempting operation...'); 
        // throw new Error("Connection lost"); 
        
    } catch (e) {
        console.error("Operation failed.");
    } finally {
        // โค้ดใน finally จะทำงานเสมอ
        connectionStatus = 'closed';
        console.log(`Connection is now: ${connectionStatus}`); 
    }
}

runWithCleanup();

// ฟังก์ชันจำลองการทำงานที่ใช้เวลา 4 วินาที และคืนค่าเป็น Promise
function getUserOrder(): Promise<string> {
    return new Promise((resolve) => {
        // ใช้ setTimeout จำลองการทำงานที่ต้องรอ
        setTimeout(() => {
            resolve('Large Latte');
        }, 4000);
    });
}

// ฟังก์ชันนี้ไม่ได้ถูกกำหนดให้เป็น async
function createOrderMessage() {
    // การเรียกใช้แบบนี้จะไม่ได้รอผลลัพธ์
    const order = getUserOrder(); 
    return 'Your order is: ' + order;
}

console.log(createOrderMessage()); 
// Output: Your order is: [object Promise] หรือ Promise { <pending> } 
// ซึ่งไม่ใช่ผลลัพธ์ "Large Latte" ที่เราต้องการ

// 1. กำหนดให้ฟังก์ชันเป็น async และระบุชนิดข้อมูลที่คืนค่าเป็น Promise<string>
async function createOrderMessage(): Promise<string> {
    // 2. ใช้ await เพื่อรอค่าสุดท้ายจาก Promise ก่อนนำไปใช้งาน
    const order = await getUserOrder(); 
    
    // โค้ดจะหยุดที่บรรทัดบนจนกว่าจะได้ค่า order
    return 'Your order is: ' + order;
}

// เพื่อให้สามารถใช้ await ใน Top-Level (เช่น main/เริ่มต้นโปรแกรม) 
// เราต้องกำหนดให้ฟังก์ชันหลักเป็น async ด้วย
async function main() {
    console.log("Run 1: Starting order...");
    
    // 3. ใช้ await เพื่อรอผลลัพธ์ของ createOrderMessage() ก่อนไปคำสั่งถัดไป
    console.log(await createOrderMessage()); 
    
    console.log("Run 2: Order completed.");
}

main();

async function fetchUser(id: number): Promise<string> {
    if (id !== 1) {
        // หากเกิดข้อผิดพลาด ให้ reject Promise
        return Promise.reject(new Error("User not found")); 
    }
    return "User: Alice"; // resolve Promise
}

async function runFetch() {
    try {
        const user = await fetchUser(99); // จะเกิด error
        console.log(user);
    } catch (error) {
        // ดักจับ error จาก Promise.reject()
        console.error("Error fetching data:", error.message);
    }
}

runFetch(); // Output: Error fetching data: User not found

class Calculator {
    // Static Method: ใช้ในการเปรียบเทียบราคาของ Object สองตัว
    // โดยที่ method นี้ไม่จำเป็นต้องใช้ข้อมูลภายใน instance
    static comparePrice(car1: { price: number }, car2: { price: number }): number {
        return car1.price - car2.price;
    }
}

class Car {
    color: string;
    price: number;

    constructor(color: string, price: number) {
        this.color = color;
        this.price = price;
    }
}

const car1 = new Car('red', 2000);
const car2 = new Car('blue', 1500);

// ต้องเรียกใช้งานผ่านชื่อ Class (Calculator) เท่านั้น
const priceDiff = Calculator.comparePrice(car1, car2);

console.log(`Price difference: ${priceDiff}`); // Output: 500

// const calc = new Calculator(); 
// calc.comparePrice(car1, car2); // Error: Cannot access static method via instance

class Circle {
    radius: number; // Instance Property (แต่ละ Object มีค่าต่างกัน)
    
    // Static Property: ค่า PI เป็นค่าเดียวกันสำหรับทุกวงกลม
    static PI: number = 3.14159; 
    
    // Static Readonly Property: ค่าคงที่ที่แก้ไขไม่ได้
    static readonly MAX_RADIUS = 100;

    constructor(radius: number) {
        this.radius = radius;
        // this.MAX_RADIUS = 50; // Error: ไม่สามารถกำหนดค่าให้ static member ภายใน constructor ได้
    }

    getArea(): number {
        // สามารถเรียกใช้ Static Property ภายใน Instance Method ได้
        return Circle.PI * (this.radius * this.radius); 
    }
}

console.log(`Global PI: ${Circle.PI}`); // Output: 3.14159
// Circle.MAX_RADIUS = 500; // Error: Cannot assign to 'MAX_RADIUS' because it is a read-only property.

class Report {
    // Instance Property
    private instanceCount: number = 0; 

    // Static Property
    static totalReports: number = 0;

    constructor() {
        this.instanceCount++;
        Report.totalReports++; // Instance สามารถเพิ่มค่า Static ได้
    }
    
    // Instance Method
    public getInfo(): string {
        // สามารถเข้าถึง Static ได้
        return `Instance: ${this.instanceCount}, Total: ${Report.totalReports}`;
    }

    // Static Method
    static clearReports(): void {
        // Report.instanceCount = 0; // Error: Static method cannot access instance property
        Report.totalReports = 0; // ทำได้
        console.log("Total reports cleared.");
    }
}

Report.clearReports(); // เรียกใช้ Static Method
const r1 = new Report();
r1.getInfo();

// การกำหนด Interface
interface Shape {
    // ต้องมี property นี้
    width: number;
    height: number;
    // ต้องมี method นี้ โดยมีการกำหนด parameter และ return type
    area(): number;
    perimeter(): number;
}

// Class Rectangle implements สัญญาจาก Shape
class Rectangle implements Shape {
    // ต้องประกาศ Properties ทั้งหมดตามสัญญา
    width: number; 
    height: number;

    constructor(width: number, height: number) {
        this.width = width;
        this.height = height;
    }

    // ต้องกำหนด Body ให้กับ Method area()
    area(): number {
        return this.width * this.height;
    }

    // ต้องกำหนด Body ให้กับ Method perimeter()
    perimeter(): number {
        return (this.width * 2) + (this.height * 2);
    }
}

interface HasVolume {
    volume(): number;
}

// Cylinder implements ทั้ง Shape และ HasVolume
class Cylinder implements Shape, HasVolume {
    // ... ต้องประกาศ property และ method ทั้งหมดของ Shape และ HasVolume
    
    // ... (โค้ดส่วนอื่น ๆ)

    area(): number { /* ... */ return 0; }
    perimeter(): number { /* ... */ return 0; }
    volume(): number { /* ... */ return 0; }
}

// Abstract Class รูปร่าง
abstract class Form {
    // 1. Normal Property (มีค่าได้)
    protected color: string = 'gray'; 

    // 2. Normal Method (มี Body ได้)
    public getColor(): string {
        return this.color;
    }

    // 3. Abstract Method (ต้องไม่มี Body และมี abstract keyword)
    abstract area(): number; // ต้องถูก implements/override ใน Class ลูก
}

// Class ลูกต้อง extends
class Triangle extends Form {
    base: number;
    height: number;

    constructor(base: number, height: number) {
        super();
        this.base = base;
        this.height = height;
    }

    // ต้อง Override และกำหนด Body ให้กับ abstract method 'area()'
    override area(): number {
        return 0.5 * this.base * this.height;
    }
}

// const f = new Form(); // Error: Cannot create an instance of an abstract class.
const t = new Triangle(10, 5);
console.log(t.area()); // 25

// Superclass / Parent Class
class Animal {
    name: string;
    
    constructor(name: string) {
        this.name = name;
    }

    eat(): void {
        console.log(`${this.name} is eating.`);
    }
}

// Subclass / Child Class สืบทอดจาก Animal
class Dog extends Animal {
    breed: string; // คุณสมบัติใหม่

    constructor(name: string, breed: string) {
        // ต้องกำหนด constructor ใหม่
        super(name); // ต้องเรียก constructor ของ Class แม่
        this.breed = breed;
    }
    
    bark(): void { // พฤติกรรมใหม่
        console.log(`${this.name} is barking.`);
    }
}

// การเรียกใช้งาน
const myDog = new Dog("Buddy", "Pug");
myDog.eat();  // เรียกใช้ method ที่สืบทอดมาจาก Animal (Output: Buddy is eating.)
myDog.bark(); // เรียกใช้ method ของ Dog เอง

// (ดูตัวอย่างด้านบน)
class Dog extends Animal {
    // ...
    constructor(name: string, breed: string) {
        // ต้องเรียก super(name) เพื่อให้ Animal constructor กำหนดค่า this.name
        super(name); 
        this.breed = breed;
    }
    // ...
}

class Animal {
    move(distance: number = 0): void {
        console.log(`Animal moved ${distance}m.`);
    }
}

class Horse extends Animal {
    // ใช้ 'override' เพื่อให้ TypeScript ตรวจสอบว่ามี move() ใน Animal จริง
    override move(distance: number = 40): void {
        // 1. super.move() เรียกใช้ method move() ของ Class แม่
        super.move(distance); 
        
        // 2. พฤติกรรมที่แตกต่างของ Class ลูก
        console.log("Horse galloped!");
    }
}

const myHorse = new Horse();
myHorse.move(50);
// Output: Animal moved 50m.
// Output: Horse galloped!

class Vehicle {
    protected speed: number = 0; // Class ลูกเข้าถึงได้

    protected accelerate(amount: number): void {
        this.speed += amount;
    }
}

class Car extends Vehicle {
    public drive(): void {
        super.accelerate(50); // Car เข้าถึง protected accelerate ได้
        console.log(`Car speed: ${this.speed} km/h`); // Car เข้าถึง protected speed ได้
    }
}

const myCar = new Car();
myCar.drive();
// myCar.accelerate(10); // Error: 'accelerate' is protected

class Product {
    // 1. Private Variable: ใช้ _ นำหน้าชื่อเพื่อเป็นธรรมเนียม แต่ 'private' คือคีย์เวิร์ดที่ทำให้มันเป็น Private จริงๆ
    private _price: number; 

    constructor(initialPrice: number) {
        this._price = initialPrice;
    }

    // Method สาธารณะที่เข้าถึงตัวแปรส่วนตัวได้
    public getDetail(): string {
        return `Product price is ${this._price} THB.`;
    }
}

const item = new Product(500);

// item._price; // Error (ใน TypeScript): Property '_price' is private.
item.getDetail(); // ทำงานได้

class Robot {
    private _height: number; // ความสูงเป็นหน่วย cm
    private _calcWeight: number; // น้ำหนักที่ถูกคำนวณ

    constructor(height: number) {
        this._height = height;
        this._calcWeight = 0; // ค่าเริ่มต้น
    }

    // Custom Getter: เข้าถึงผ่าน robot.weight
    public get weight(): number {
        // สามารถเพิ่มตรรกะหรือการตรวจสอบก่อนคืนค่าได้
        return this._calcWeight;
    }
    
    // Default Getter: สำหรับความสูง เข้าถึงผ่าน robot.height (ถ้าไม่มี set/get กำหนดไว้)
    public get height(): number {
        return this._height;
    }
    
    // ... Custom Setter จะอยู่ด้านล่าง
}

const humanoidA = new Robot(200);
// console.log(humanoidA._height); // Error เพราะเป็น private
console.log(`Height (via getter): ${humanoidA.height}`); // Output: 200
console.log(`Weight (via getter): ${humanoidA.weight}`); // Output: 0

// ต่อจาก Class Robot เดิม:

class Robot {
    private _height: number;
    private _calcWeight: number;

    constructor(height: number) {
        this._height = height;
        this._calcWeight = 0;
    }
    
    // Custom Getter (เหมือนเดิม)
    public get weight(): number {
        return this._calcWeight;
    }

    // Custom Setter: เข้าถึงผ่าน robot.weight = value
    // รับค่า percent เพื่อคำนวณน้ำหนักจากเปอร์เซ็นต์ของความสูง
    public set weight(percent: number) {
        // การตรวจสอบความถูกต้อง (Validation)
        if (percent < 0 || percent > 100) {
            console.error("Error: Weight percentage must be between 0 and 100.");
            return;
        }
        // การคำนวณก่อนกำหนดค่า
        this._calcWeight = (this._height * percent) / 100;
        console.log(`Weight set to ${percent}% of height.`);
    }
}

const humanoidB = new Robot(200);

humanoidB.weight = 50; // เรียกใช้ Setter
console.log(`Calculated Weight: ${humanoidB.weight}`); // Output: 100

humanoidB.weight = 120; // เรียกใช้ Setter (จะแสดง Error ใน Console)
console.log(`Calculated Weight: ${humanoidB.weight}`); // Output: 100 (ค่าเดิม)

class User {
    // กำหนดให้ id สามารถอ่านได้ แต่ไม่สามารถแก้ไขได้หลังจากการสร้าง
    public readonly id: number; 
    public name: string;

    constructor(id: number, name: string) {
        this.id = id; // สามารถกำหนดค่าได้ใน constructor
        this.name = name;
    }
}

const userA = new User(101, "Alice");
// userA.id = 102; // Error: Cannot assign to 'id' because it is a read-only property.
userA.name = "Bob"; // ทำได้

class Rectangle {
    // 1. Properties (คุณสมบัติ/ตัวแปรสมาชิก) พร้อมกำหนดชนิดข้อมูล
    width: number;
    height: number;
    
    // 2. Constructor (ตัวสร้าง) - ใช้ในการกำหนดค่าเริ่มต้นเมื่อสร้าง Object
    constructor(w: number, h: number) {
        this.width = w; // กำหนดค่า w ที่รับเข้ามาให้กับ property width ของ Object
        this.height = h;
    }

    // 3. Methods (เมธอด/ฟังก์ชัน) - พฤติกรรมของ Object
    area(): number {
        return this.width * this.height;
    }
}

// การสร้าง Object (Instance)
const myRectangle = new Rectangle(50, 20);

// การเรียกใช้ Properties และ Methods
console.log(`Width: ${myRectangle.width}`); // Output: 50
console.log(`Area: ${myRectangle.area()}`);   // Output: 1000

class BankAccount {
    public owner: string; // เข้าถึงได้จากภายนอก
    private _balance: number; // เข้าถึงได้เฉพาะใน Class เท่านั้น

    constructor(owner: string, initialBalance: number) {
        this.owner = owner;
        this._balance = initialBalance;
    }

    // Public method
    public deposit(amount: number): void {
        this._balance += amount;
    }

    // Public method ที่เข้าถึง private property
    public getBalance(): number {
        return this._balance;
    }
}

class Circle {
    // TypeScript จะประกาศ public radius: number; ให้โดยอัตโนมัติ
    constructor(public radius: number) {
        // ไม่จำเป็นต้องใช้ this.radius = radius; อีกต่อไป
    }

    public circumference(): number {
        return 2 * Math.PI * this.radius;
    }
}

const myCircle = new Circle(7);
console.log(myCircle.circumference());

class Animal {
    name: string;
    
    constructor(name: string) {
        this.name = name;
    }

    move(distance: number = 0): void {
        console.log(`${this.name} moved ${distance}m.`);
    }
}

class Dog extends Animal {
    // Override Constructor ของ Class แม่
    constructor(name: string) {
        super(name); // เรียก constructor ของ Animal (name)
    }

    // Override Method ของ Class แม่
    move(distance: number = 5): void {
        super.move(distance); // เรียก method move() ของ Class แม่
        console.log("...and wagged its tail!");
    }
    
    // New Method
    bark(): void {
        console.log("Woof! Woof!");
    }
}

const puppy = new Dog("Buddy");
puppy.move(10); 
// Output: Buddy moved 10m.
// Output: ...and wagged its tail!

class Configuration {
    // Static Property: เข้าถึงผ่านชื่อ Class
    static version: string = '1.0.0'; 
    
    // Static Method
    static getVersionInfo(): string {
        return `App Version: ${Configuration.version}`;
    }
}

// เรียกใช้โดยตรงจากชื่อ Class
console.log(Configuration.getVersionInfo()); // Output: App Version: 1.0.0

// ไม่สามารถเรียกผ่าน Object ได้
// const config = new Configuration(); 
// config.version; // Error

class Product {
    private _price: number;

    constructor(initialPrice: number) {
        this._price = initialPrice;
    }

    // Getter: ใช้ 'get' เพื่อเข้าถึงค่าแบบ property (product.price)
    public get price(): number {
        return this._price;
    }

    // Setter: ใช้ 'set' เพื่อกำหนดค่าแบบ property (product.price = 150)
    public set price(newPrice: number) {
        if (newPrice < 0) {
            console.error("Price cannot be negative.");
            return;
        }
        this._price = newPrice;
    }
}

const item = new Product(100);
item.price = 150;     // เรียกใช้ Setter
console.log(item.price); // เรียกใช้ Getter (Output: 150)
item.price = -50;     // เรียกใช้ Setter (จะแสดง Error ใน Console)

// ฟังก์ชันที่มีการกำหนดชนิดข้อมูลของพารามิเตอร์และการคืนค่าอย่างชัดเจน
function findArea(width: number, height: number): number {
    return width * height;
}

// ฟังก์ชันที่ไม่มีการคืนค่า (ใช้ void)
function printResult(area: number): void {
    console.log(`Area: ${area}`);
}

// การเรียกใช้งาน
let area: number = findArea(20, 100);
printResult(area); // Area: 2000

// ฟังก์ชันหาพื้นที่วงกลม (Single Expression)
const circleArea = (radius: number): number => {
    // ใน TS ใช้ Math.PI
    return Math.PI * (radius * radius);
};

// ฟังก์ชันหาปริมาตรทรงกระบอกในรูปแบบ Arrow Function
const cylinderVolume = (area: number, height: number): number => area * height;

let volume = cylinderVolume(circleArea(10), 15);
console.log(`Volume of cylinder: ${volume.toFixed(2)}`);
// Output: Volume of cylinder: 4712.39

// ทั้ง width และ height ต้องส่งค่ามาเสมอ
function calculateArea(width: number, height: number): number {
    return width * height;
}

// calculateArea(10); // Error: Expected 2 arguments, but got 1.

// email เป็น optional parameter
function customer(name: string, phone: string, email?: string): void {
    console.log(`Name: ${name}`);
    console.log(`Phone: ${phone}`);
    console.log(`Email: ${email ?? 'N/A'}`); // ใช้ Nullish Coalescing เพื่อแสดงค่าเริ่มต้น
}

customer("Ebiwayo", "0812345678", "ebiwa@google.com");
// Output: Email: ebiwa@google.com

customer("Ebiwayo", "0812345678");
// Output: Email: N/A

// phone มีค่าเริ่มต้นเป็น '000-000-0000'
function customer(name: string, phone: string = '000-000-0000'): void {
    console.log(`Name: ${name}`);
    console.log(`Phone: ${phone}`);
}

customer("Ebiwayo");
// Output: Phone: 000-000-0000

function sumAll(...numbers: number[]): number {
    return numbers.reduce((total, num) => total + num, 0);
}

console.log(sumAll(10, 20, 30, 40)); // Output: 100

// 1. Overload Signatures
function combine(a: number, b: number): number;
function combine(a: string, b: string): string;

// 2. Implementation Signature (ต้องรองรับทุกรูปแบบ)
function combine(a: any, b: any): any {
    if (typeof a === 'number' && typeof b === 'number') {
        return a + b;
    }
    if (typeof a === 'string' && typeof b === 'string') {
        return a + " " + b;
    }
}

let sum = combine(5, 10);      // sum เป็น number
let text = combine("Hello", "TS"); // text เป็น string

console.log(sum);   // 15
console.log(text);  // Hello TS

// ฟังก์ชันที่รับฟังก์ชันอื่นเป็นพารามิเตอร์
function executeOperation(a: number, b: number, callback: (result: number) => void): void {
    const result = a * b;
    callback(result); // เรียกใช้ callback function
}

// ฟังก์ชัน callback ที่ถูกส่งเข้าไป
function logResult(value: number): void {
    console.log(`The result is: ${value}`);
}

executeOperation(10, 5, logResult);
// Output: The result is: 50

let name1: string; // การประกาศแบบไม่กำหนดค่าเริ่มต้น
let name2: string = 'Ebiwayo'; // ประกาศพร้อมกำหนดค่า (Type Annotation)

// ตัวแปรที่ประกาศโดยไม่กำหนดค่าเริ่มต้นจะมีค่าเป็น undefined
let price; // TypeScript จะอนุมาน (Inference) ว่าเป็นชนิด any

if (true) {
    let message = 'Hello'; // ถูกจำกัดขอบเขตในบล็อก if นี้เท่านั้น
}
// console.log(message); // จะเกิด Error: Cannot find name 'message'

let name: string = 'Ebiwayo';
let age: number = 25;
let weight: number = 48.5; // ทั้งจำนวนเต็มและทศนิยมใช้ number

// ถ้าค่าที่กำหนดไม่ตรงตามชนิดที่ประกาศ จะเกิด Error ตั้งแต่ตอน Compile
// name = 123; // Error: Type 'number' is not assignable to type 'string'.

const PI: number = 3.14159;
// PI = 3.14; // Error: Cannot assign to 'PI' because it is a constant.

const list = [1, 2, 3];
// list = [4, 5, 6]; // Error: เปลี่ยนค่าตัวแปรหลักไม่ได้
list.push(4); // แต่ยังสามารถเปลี่ยนแปลงข้อมูลภายใน Array ได้ (Mutability)

class Shape {
    readonly name: string;
    static readonly PI: number = 3.14; // static readonly สำหรับค่าคงที่ใน Class

    constructor(name: string) {
        this.name = name;
    }
}

let circle = new Shape('Circle');
// circle.name = 'Square'; // Error: 'name' is readonly.

// รูปแบบที่แนะนำ: ชนิดข้อมูล[]
let hobby: string[] = ['Reading', 'Jogging', 'Shopping'];

// รูปแบบ Generics (คล้าย Dart): Array<T>
let numbers: Array<number> = [1, 2, 3];

// hobby.push(10); // Error: Argument of type 'number' is not assignable to parameter of type 'string'.

// Literal Object Type
let address: { [key: string]: string | string[] } = {
    'city': ['Bangkok', 'Nonthaburi'], // key เป็น string, value เป็น string[]
    'country': 'Thailand'              // key เป็น string, value เป็น string
};

console.log(address['country']); // การเข้าถึงข้อมูลด้วย Key

// การใช้ Map Class (สำหรับ Key ที่ซับซ้อนกว่า string)
let userAges: Map<string, number> = new Map();
userAges.set('Ebiwayo', 24);
console.log(userAges.get('Ebiwayo')); // 24