// Plain JavaScript — works in TypeScript with zero changes
function add(a, b) {
  return a + b;
}

// TypeScript — same function, with type annotations added
function add(a: number, b: number): number {
  return a + b;
}

// The type annotations are the only difference.
// Both compile to exactly the same JavaScript.

// src/greet.ts — TypeScript source

interface Person {
  name: string;
  age: number;
}

function greet(person: Person): string {
  return `Hello, ${person.name}! You are ${person.age} years old.`;
}

const alice: Person = { name: 'Alice', age: 30 };
console.log(greet(alice));

// dist/greet.js — emitted by tsc (targeting ES2020)

function greet(person) {
  return `Hello, ${person.name}! You are ${person.age} years old.`;
}

const alice = { name: 'Alice', age: 30 };
console.log(greet(alice));

// Structural typing — compatible because the shapes match

interface Cat {
  name: string;
  meow(): void;
}

interface Animal {
  name: string;
}

function printName(a: Animal) {
  console.log(a.name);
}

const kitty: Cat = { name: 'Whiskers', meow() {} };

// This works — Cat has at least all the properties of Animal
printName(kitty); // ✓

// In a nominal system (Java/C#), Cat would need to explicitly
// implement Animal for this to compile. Not in TypeScript.

interface Point2D {
  x: number;
  y: number;
}

interface Point3D {
  x: number;
  y: number;
  z: number;
}

function distance(a: Point2D, b: Point2D): number {
  const dx = a.x - b.x;
  const dy = a.y - b.y;
  return Math.sqrt(dx * dx + dy * dy);
}

const p2: Point2D = { x: 0, y: 0 };
const p3: Point3D = { x: 3, y: 4, z: 10 };

// Point3D has x and y (and more), so it satisfies Point2D
distance(p2, p3); // ✓ — TypeScript is fine with this

// This would fail in a nominal system because Point3D does not
// explicitly extend Point2D. TypeScript cares about the shape.

// TypeScript infers all of these types without any annotations:

const name = 'Alice';          // inferred: string
const age = 30;                // inferred: number
const active = true;           // inferred: boolean
const scores = [90, 85, 92];  // inferred: number[]

// Inferred from function return:
function double(n: number) {
  return n * 2;                // return type inferred: number
}

// Inferred from array methods:
const doubled = scores.map(n => n * 2);  // inferred: number[]

// Hover over any variable in VS Code to see its inferred type.

// Variable annotations
let count: number = 0;
let message: string;
let flags: boolean[];

// Function parameter and return type annotations
function formatPrice(amount: number, currency: string): string {
  return `${currency}${amount.toFixed(2)}`;
}

// Object type annotation (inline)
function printUser(user: { name: string; email: string }): void {
  console.log(`${user.name} <${user.email}>`);
}

// Arrow function annotations
const multiply = (a: number, b: number): number => a * b;

// Optional parameters (the ? makes the parameter optional)
function greet(name: string, title?: string): string {
  return title ? `Hello, ${title} ${name}` : `Hello, ${name}`;
}

// JavaScript version — no types

function processOrder(order) {
  if (!order || !order.items) {
    throw new Error('Invalid order');
  }

  const total = order.items.reduce((sum, item) => {
    return sum + item.price * item.quantity;
  }, 0);

  return {
    id: order.id,
    total,
    itemCount: order.items.length,
  };
}

// TypeScript version — with types

interface OrderItem {
  name: string;
  price: number;
  quantity: number;
}

interface Order {
  id: string;
  items: OrderItem[];
}

interface OrderSummary {
  id: string;
  total: number;
  itemCount: number;
}

function processOrder(order: Order): OrderSummary {
  const total = order.items.reduce((sum, item) => {
    return sum + item.price * item.quantity;
  }, 0);

  return {
    id: order.id,
    total,
    itemCount: order.items.length,
  };
}

// Example: a simplified .d.ts file for a JavaScript utility library

// math-utils.d.ts
export declare function add(a: number, b: number): number;
export declare function subtract(a: number, b: number): number;
export declare function clamp(value: number, min: number, max: number): number;

export interface Vector2 {
  x: number;
  y: number;
}

export declare function dot(a: Vector2, b: Vector2): number;

interface User {
  id: number;
  name: string;
  email: string;
  createdAt: Date;
}

const user: User = {
  id: 1,
  name: 'Alice',
  email: 'alice@example.com',
  createdAt: new Date(),
};

// In VS Code, after typing "user." you get autocomplete:
// id, name, email, createdAt — and their types
user.name;        // string
user.createdAt;   // Date

// Typo — caught immediately, not at runtime:
user.emial;       // Error: Property 'emial' does not exist on type 'User'. Did you mean 'email'?