interface User {
    id: number
    username: string
    isActive: boolean
}

const admin: User = {
    id: 1,
    username: 'admin',
    isActive: true,
}

// Файл 1 (або бібліотека)
interface Settings {
    theme: 'dark' | 'light'
}

// Файл 2 (ваше розширення)
interface Settings {
    fontSize: number
}

// Результат: Settings тепер має ОБИДВА поля
const config: Settings = {
    theme: 'dark',
    fontSize: 14,
}

// 1. Примітив
type ID = string

// 2. Union (Об'єднання)
type Status = 'loading' | 'success' | 'error'

// 3. Функція
type Handler = (event: Event) => void

// 4. Об'єкт (схоже на Interface)
type UserType = {
    id: ID
    status: Status
}

interface Product {
    name: string
    description?: string // string | undefined
}

// ✅ Обидва варіанти валідні
const p1: Product = { name: 'iPhone' }
const p2: Product = { name: 'Samsung', description: 'Android phone' }

// ⚠️ Доступ до optional поля
// console.log(p1.description.toUpperCase()); // Error: Object is possibly 'undefined'.
console.log(p1.description?.toUpperCase()) // Optional Chaining to the rescue!

interface UserProfile {
    readonly id: number // Не можна змінити після створення
    name: string
}

const user: UserProfile = { id: 101, name: 'Alice' }
user.name = 'Bob' // ✅ ОК
// user.id = 102; // 🛑 Error: Cannot assign to 'id' because it is a read-only property.

interface Address {
    city: string
    street: string
}

interface UserProfile {
    readonly id: number
    readonly address: Address // Весь об'єкт address "readonly"
    name: string
}

const user: UserProfile = {
    id: 1,
    name: 'Alice',
    address: {
        city: 'Kyiv',
        street: 'Khreschatyk',
    },
}

// 🛑 Помилка: id тільки для читання
// user.id = 2;

// 🛑 Помилка: ми не можемо ПЕРЕЗАПИСАТИ весь об'єкт address
// user.address = { city: 'Lviv', street: 'Rynok' };

// ✅ ОК: Але ми МОЖЕМО змінити поле всередині об'єкта address!
user.address.city = 'Lviv'

interface Cache {
    [key: string]: any // Ключ - рядок, значення - будь-що
}

const memory: Cache = {}
memory['user_1'] = 'Alice'
memory['config'] = { theme: 'dark' }

// Але це небезпечно! TS не перевіряє доступ.
// const item = memory["non_existent"]; // Typs: any. Runtime: undefined.

type ID = string | number

function printId(id: ID) {
    console.log(`Your ID is: ${id}`)

    // 🛑 Error: Property 'toUpperCase' does not exist on type 'string | number'.
    // id.toUpperCase();

    // ✅ Type Narrowing (Звуження типу)
    if (typeof id === 'string') {
        console.log(id.toUpperCase()) // Тут id - це точно string
    } else {
        console.log(id.toFixed(2)) // Тут id - це точно number
    }
}

interface Bird {
    fly(): void
    layEggs(): void
}
interface Fish {
    swim(): void
    layEggs(): void
}

function getSmallPet(): Bird | Fish {
    /* ... */
}

const pet = getSmallPet()
pet.layEggs() // ✅ Є у обох
// pet.fly(); // 🛑 Error: Fish does not fly!

interface HasName {
    name: string
}
interface HasAge {
    age: number
}

type Person = HasName & HasAge

const bob: Person = {
    name: 'Bob',
    age: 30,
    // Якщо забути хоч одне поле - буде помилка
}

type APIResponse = {
    data: User[]
    page: number
}

type ErrorResponse = {
    error: string
    code: number
}

// Це навряд чи має сенс (відповідь не може бути одночасно успішною І поламаною)
type Wtf = APIResponse & ErrorResponse

interface Shape {
    kind: string
    radius?: number // Тільки для кола
    sideLength?: number // Тільки для квадрата
}

interface Circle {
    kind: 'circle' // Дискримінант
    radius: number
}

interface Square {
    kind: 'square' // Дискримінант
    sideLength: number
}

interface Rectangle {
    kind: 'rectangle'
    width: number
    height: number
}

type Shape = Circle | Square | Rectangle

function getArea(shape: Shape) {
    switch (shape.kind) {
        case 'circle':
            // Тут shape — це точно Circle. Радіус доступний!
            return Math.PI * shape.radius ** 2
        case 'square':
            // Тут shape — це точно Square. sideLength доступний!
            return shape.sideLength ** 2
        case 'rectangle':
            return shape.width * shape.height
    }
}

function getArea(shape: Shape) {
    switch (shape.kind) {
        case 'circle':
            return Math.PI * shape.radius ** 2
        case 'square':
            return shape.sideLength ** 2
        case 'rectangle':
            return shape.width * shape.height
        default:
            // Якщо ми обробили всі типи, то сюди ми ніколи не потрапимо.
            // Отже, тип shape тут має бути 'never'.
            const _exhaustiveCheck: never = shape
            return _exhaustiveCheck
    }
}

type ApiResponse<T> =
    | { status: 'loading' }
    | { status: 'success'; data: T; timestamp: number }
    | { status: 'error'; error: Error; code: number }

function handleResponse(res: ApiResponse<string[]>) {
    if (res.status === 'success') {
        console.log('Дані отримано:', res.data) // OK
        // console.log(res.error); // Error: Поля error не існує в успішній відповіді
    }
}

// 1. Описуємо кожен стан окремо для чистоти
interface LoadingState {
    status: 'loading'
}

interface SuccessState {
    status: 'success'
    data: string[]
}

interface ErrorState {
    status: 'error'
    message: string
}

// 2. Створюємо Union
type UIState = LoadingState | SuccessState | ErrorState

// 3. Функція рендерингу, яка ніколи не помилиться
function renderPage(state: UIState) {
    if (state.status === 'loading') {
        return 'Завантаження... 🔄'
    }

    if (state.status === 'error') {
        // Тут TypeScript знає, що є message, але НЕМАЄ data
        return `Помилка: ${state.message} ❌`
    }

    if (state.status === 'success') {
        // Тут TypeScript знає, що є data, але НЕМАЄ message
        return `Дані: ${state.data.join(', ')} ✅`
    }
}

// String Literal
type Direction = 'North' | 'South' | 'East' | 'West'
function move(dir: Direction) {}
move('North') // ✅
// move("Up"); // 🛑 Error

// Numeric Literal
type DiceRoll = 1 | 2 | 3 | 4 | 5 | 6

// Boolean Literal
type IsEnabled = true // Змінна може бути ТІЛЬКИ true

type Color = 'red' | 'blue'
type Variant = 'light' | 'dark'

// Автоматична генерація всіх комбінацій:
// "red-light" | "red-dark" | "blue-light" | "blue-dark"
type ThemeClass = `${Color}-${Variant}`

interface ButtonProps {
    size: 'sm' | 'md' | 'lg'
    variant: 'primary' | 'secondary' | 'danger'
}
// 9 можливих комбінацій

enum UserRole {
    Admin, // 0
    Editor, // 1
    User, // 2
}

const myRole: UserRole = UserRole.Admin // 0

const role: UserRole = 123 // ⚠️ Жодних помилок від компілятора!

enum OrderStatus {
    Pending = 'PENDING',
    Shipped = 'SHIPPED',
    Delivered = 'DELIVERED',
}

enum Color {
    Red = 'red',
}

var Color
;(function (Color) {
    Color['Red'] = 'red'
})(Color || (Color = {}))

const UserRole = {
    Admin: 'admin',
    Editor: 'editor',
    User: 'user',
} as const // 👈 Магія тут!

type UserRole = (typeof UserRole)[keyof typeof UserRole]

const API_ENDPOINTS = {
    GET_USERS: '/api/v1/users',
    GET_POSTS: '/api/v1/posts',
    LOGIN: '/api/auth/login',
} as const

type ApiEndpoint = (typeof API_ENDPOINTS)[keyof typeof API_ENDPOINTS]

function fetchData(url: ApiEndpoint) {
    /* ... */
}

fetchData(API_ENDPOINTS.LOGIN) // ✅
fetchData('/api/hack') // 🛑 Помилка!

const HttpStatus = {
    Ok: 200,
    NotFound: 404,
    ServerError: 500,
} as const

type HttpStatus = (typeof HttpStatus)[keyof typeof HttpStatus] // 200 | 404 | 500

interface Fish {
    swim: () => void
}
interface Bird {
    fly: () => void
}

// Функція-предикат
function isFish(pet: Fish | Bird): pet is Fish {
    // Перевіряємо наявність унікального методу
    return (pet as Fish).swim !== undefined
}

const myPet = getPet()

if (isFish(myPet)) {
    myPet.swim() // ✅ Тут TS знає: це Fish
} else {
    myPet.fly() // ✅ Тут TS знає: це точно Bird (бо не Fish)
}

function assertIsString(val: any): asserts val is string {
    if (typeof val !== 'string') {
        throw new AssertionError('Not a string!')
    }
}

const inputValue: unkown = 'hello'
assertIsString(inputValue)
// Після цього рядка inputValue вважається string
console.log(inputValue.toUpperCase())

type JSONValue =
    | string
    | number
    | boolean
    | null
    | JSONValue[] // Рекурсія: масив JSONValue
    | { [key: string]: JSONValue } // Рекурсія: об'єкт з JSONValue

const user = { name: 'Alice', age: 25 }
// JS: Перетворити всі значення на рядки
const stringifiedUser = Object.keys(user).reduce((acc, key) => {
    acc[key] = String(user[key])
    return acc
}, {})

interface User {
    id: number
    name: string
}

type MappedUser = {
    [K in keyof User]: User[K]
}

type PartialUser = {
    [K in keyof User]?: User[K] // Додає ? до кожного ключа
}
// Результат: { id?: number; name?: string; }

type ReadonlyUser = {
    readonly [K in keyof User]: User[K]
}

interface PartialSettings {
    theme?: string
    fontSize?: number
}

// Перетворюємо всі опціональні поля на обов'язкові
type RequiredSettings = {
    [K in keyof PartialSettings]-?: PartialSettings[K]
}
// Результат: { theme: string; fontSize: number; }

interface Features {
    darkMode: boolean
    betaNav: { items: string[] }
    experimentalEditor: boolean
}

type FeatureToggles = {
    [K in keyof Features]: () => void
}

const toggles: FeatureToggles = {
    darkMode: () => console.log('Dark Mode toggled'),
    betaNav: () => console.log('Beta Nav toggled'),
    experimentalEditor: () => console.log('Editor toggled'),
}

interface User {
    id: number
    name: string
}

// "id" | "name"
type UserKeys = keyof User

const config = {
    apiKey: '123',
    timeout: 5000,
}

type Config = typeof config
// { apiKey: string; timeout: number; }

const ThemeColors = {
    primary: '#0070f3',
    secondary: '#1e1e1e',
    success: '#0070f3',
} as const

type ColorName = keyof typeof ThemeColors

const AppConfig = {
    apiUrl: 'https://api.example.com',
    retryCount: 3,
    debugMode: true,
} as const

// 1. Створюємо тип ключів
type ConfigKey = keyof typeof AppConfig

// 2. Використовуємо його у функції
function getConfigValue(key: ConfigKey) {
    return AppConfig[key]
}

getConfigValue('apiUrl') // ✅ Працює, повертає рядок
getConfigValue('retryCount') // ✅ Працює, повертає 3
// getConfigValue("port"); // 🛑 Помилка! Ключа "port" не існує в AppConfig