// JavaScript: No error shown until code runs
let price = 1000;
price = "free"; // Completely valid in JavaScript
console.log(price * 2); // NaN — bug discovered at runtime!

// TypeScript: Error caught immediately
let price: number = 1000;
price = "free"; // ERROR: Type 'string' not assignable to type 'number'

// Variable annotations
let username: string = "Rahul";
let age: number = 25;
let isActive: boolean = true;
let scores: number[] = [85, 92, 78]; // Array of numbers
let coordinates: [number, number] = [28.6, 77.2]; // Tuple

// Function annotations
function greet(name: string): string {
    return "Hello, " + name;
}

function addNumbers(a: number, b: number): number {
    return a + b;
}

// Optional parameters (use ?)
function createUser(name: string, age?: number): void {
    console.log(name, age ?? "age not provided");
}

// Define the interface
interface User {
    id: number;
    name: string;
    email: string;
    age?: number; // Optional property
}

// This object is valid — it satisfies the User interface
const user1: User = {
    id: 1,
    name: "Rahul",
    email: "rahul@email.com"
};

// This object causes an error — missing required 'email'
const user2: User = {
    id: 2,
    name: "Priya"
    // ERROR: Property 'email' is missing
};

interface Animal {
    name: string;
    speak(): string; // Method that returns a string
    move(distance: number): void; // Method that returns nothing
}

class Dog implements Animal {
    name: string;

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

    speak(): string {
        return "Woof!";
    }

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

// TypeScript infers these types automatically
let message = "Hello World"; // TypeScript knows: string
let count = 42; // TypeScript knows: number
let isValid = true; // TypeScript knows: boolean

// TypeScript infers the return type too
function multiply(a: number, b: number) {
    return a * b; // TypeScript infers return type: number
}

// TypeScript infers array types
let fruits = ["apple", "banana", "mango"]; // string[]
fruits.push(123); // ERROR: Argument of type 'number' not assignable to type 'string'

// This variable can be a string OR a number
let id: string | number;
id = "user-123"; // Valid
id = 456; // Also valid
id = true; // ERROR: boolean not in the union

// Function that accepts string or number
function formatId(id: string | number): string {
    if (typeof id === "string") {
        return id.toUpperCase();
    }
    return id.toString();
}

interface Printable {
    print(): void;
}

interface Serializable {
    serialize(): string;
}

// This type must have BOTH print() AND serialize()
type PrintableAndSerializable = Printable & Serializable;

// Only these exact values are allowed
type Direction = "north" | "south" | "east" | "west";
type StatusCode = 200 | 404 | 500;

let move: Direction = "north"; // Valid
move = "diagonal"; // ERROR: not in the union

// Works only for numbers
function getFirstNumber(arr: number[]): number {
    return arr[0];
}

// Works only for strings — duplicate code!
function getFirstString(arr: string[]): string {
    return arr[0];
}

// Works for ANY type — one function to rule them all
function getFirst<T>(arr: T[]): T {
    return arr[0];
}

// TypeScript infers T automatically
getFirst([1, 2, 3]); // Returns number
getFirst(["a", "b", "c"]); // Returns string
getFirst([true, false]); // Returns boolean

interface ApiResponse<T> {
    data: T;
    status: number;
    message: string;
}

// Use it with any data type
const userResponse: ApiResponse<User> = {
    data: { id: 1, name: "Rahul", email: "r@email.com" },
    status: 200,
    message: "Success"
};

const productResponse: ApiResponse<string[]> = {
    data: ["Laptop", "Phone", "Tablet"],
    status: 200,
    message: "Products fetched"
};

// Without enum — magic strings everywhere, easy to typo
function setUserRole(role: string) {
    if (role === "admin") { /* ... */ }
    if (role === "editor") { /* ... */ }
    if (role === "viewer") { /* ... */ }
}

setUserRole("Amdin"); // Typo — no error caught!

// With enum — clear, safe, autocomplete works
enum UserRole {
    Admin = "ADMIN",
    Editor = "EDITOR",
    Viewer = "VIEWER"
}

function setUserRole(role: UserRole) {
    if (role === UserRole.Admin) { /* ... */ }
}

setUserRole(UserRole.Admin); // Clear and type-safe
setUserRole("ADMIN"); // ERROR: string not assignable to UserRole

enum Direction {
    Up = 1,
    Down,    // 2 (auto-increments)
    Left,    // 3
    Right    // 4
}

class BankAccount {
    public owner: string; // Accessible from anywhere
    private balance: number; // Only accessible inside BankAccount
    protected accountType: string; // Accessible in BankAccount and subclasses
    readonly id: string; // Can be set once, never changed

    constructor(owner: string, initialBalance: number) {
        this.owner = owner;
        this.balance = initialBalance;
        this.accountType = "savings";
        this.id = Math.random().toString(36).substr(2, 9);
    }

    public deposit(amount: number): void {
        this.balance += amount;
    }

    public getBalance(): number {
        return this.balance;
    }

    private validateAmount(amount: number): boolean {
        return amount > 0;
    }
}

const account = new BankAccount("Rahul", 10000);
account.deposit(5000);
console.log(account.getBalance()); // 15000
console.log(account.balance); // ERROR: balance is private

abstract class Shape {
    abstract getArea(): number; // Must be implemented by subclasses

    describe(): string {
        return `This shape has an area of ${this.getArea()}`;
    }
}

class Circle extends Shape {
    constructor(private radius: number) { super(); }

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

class Rectangle extends Shape {
    constructor(private width: number, private height: number) { super(); }

    getArea(): number {
        return this.width * this.height;
    }
}

// Simple alias
type UserId = number;
type UserName = string;

// Object type alias
type Product = {
    id: number;
    name: string;
    price: number;
    category: "electronics" | "clothing" | "food";
};

// Function type alias
type MathOperation = (a: number, b: number) => number;

const add: MathOperation = (a, b) => a + b;
const multiply: MathOperation = (a, b) => a * b;

npm install -g typescript
tsc --version  # Verify installation

mkdir my-project
cd my-project
npm init -y
tsc --init  # Creates tsconfig.json

{
  "compilerOptions": {
    "target": "ES2020",       // Output JavaScript version
    "module": "commonjs",     // Module system
    "strict": true,           // Enable all strict type checks
    "outDir": "./dist",       // Output directory for compiled JS
    "rootDir": "./src",       // Source TypeScript files
    "esModuleInterop": true   // Better module compatibility
  }
}

tsc               # Compile all files once
tsc --watch       # Recompile on every file change

# React with TypeScript
npx create-react-app my-app --template typescript

# Next.js with TypeScript
npx create-next-app@latest my-app --typescript

# Node.js with TypeScript
npm install typescript ts-node @types/node --save-dev