// TypeScript 5.x

namespace Utils {
  // 导出的成员可以在外部访问
  export function log(message: string): void {
    console.log(`[LOG]: ${message}`)
  }

  export function warn(message: string): void {
    console.warn(`[WARN]: ${message}`)
  }

  // 未导出的成员是私有的
  function formatMessage(msg: string): string {
    return `Formatted: ${msg}`
  }

  export const VERSION = '1.0.0'

  export interface Config {
    debug: boolean
    logLevel: 'info' | 'warn' | 'error'
  }

  export class Logger {
    constructor(private config: Config) {}

    log(message: string) {
      if (this.config.debug) {
        console.log(message)
      }
    }
  }
}

// 使用
Utils.log('Hello')
Utils.warn('Warning')
console.log(Utils.VERSION)

const config: Utils.Config = {
  debug: true,
  logLevel: 'info',
}

const logger = new Utils.Logger(config)

namespace App {
  export namespace Models {
    export interface User {
      id: number
      name: string
    }

    export interface Product {
      id: number
      name: string
      price: number
    }
  }

  export namespace Services {
    export class UserService {
      getUser(id: number): Models.User {
        return { id, name: '张三' }
      }
    }

    export class ProductService {
      getProduct(id: number): Models.Product {
        return { id, name: '商品', price: 100 }
      }
    }
  }

  export namespace Utils {
    export function formatPrice(price: number): string {
      return `¥${price.toFixed(2)}`
    }
  }
}

// 使用
const user: App.Models.User = { id: 1, name: '张三' }
const service = new App.Services.UserService()
const price = App.Utils.formatPrice(99.9)

// 简化访问
import Models = App.Models
import UserService = App.Services.UserService

const user2: Models.User = { id: 2, name: '李四' }
const userService = new UserService()

// 与类合并
class Album {
  label: Album.AlbumLabel

  constructor(label: Album.AlbumLabel) {
    this.label = label
  }
}

namespace Album {
  export interface AlbumLabel {
    name: string
    year: number
  }

  export function create(name: string): Album {
    return new Album({ name, year: new Date().getFullYear() })
  }
}

const album = Album.create('专辑名')
console.log(album.label.name)

// 与函数合并
function buildName(firstName: string, lastName: string) {
  return `${buildName.prefix}${firstName} ${lastName}`
}

namespace buildName {
  export let prefix = 'Mr. '
  export function setPrefix(p: string) {
    prefix = p
  }
}

console.log(buildName('张', '三')) // Mr. 张 三
buildName.setPrefix('Dr. ')
console.log(buildName('李', '四')) // Dr. 李 四

// 与枚举合并
enum Color {
  Red,
  Green,
  Blue,
}

namespace Color {
  export function fromHex(hex: string): Color {
    // 解析十六进制颜色
    return Color.Red
  }

  export function toHex(color: Color): string {
    switch (color) {
      case Color.Red:
        return '#FF0000'
      case Color.Green:
        return '#00FF00'
      case Color.Blue:
        return '#0000FF'
    }
  }
}

const red = Color.fromHex('#FF0000')
const hex = Color.toHex(Color.Red)

// === shapes.ts ===
namespace Shapes {
  export interface Point {
    x: number
    y: number
  }

  export interface Size {
    width: number
    height: number
  }
}

// === rectangle.ts ===
/// <reference path="shapes.ts" />

namespace Shapes {
  export class Rectangle {
    constructor(
      public position: Point,
      public size: Size
    ) {}

    get area(): number {
      return this.size.width * this.size.height
    }
  }
}

// === circle.ts ===
/// <reference path="shapes.ts" />

namespace Shapes {
  export class Circle {
    constructor(
      public center: Point,
      public radius: number
    ) {}

    get area(): number {
      return Math.PI * this.radius ** 2
    }
  }
}

// === main.ts ===
/// <reference path="shapes.ts" />
/// <reference path="rectangle.ts" />
/// <reference path="circle.ts" />

const rect = new Shapes.Rectangle({ x: 0, y: 0 }, { width: 10, height: 20 })

const circle = new Shapes.Circle({ x: 5, y: 5 }, 10)

namespace Company {
  export namespace Departments {
    export namespace Engineering {
      export class Developer {
        constructor(public name: string) {}
      }

      export class Manager {
        constructor(public name: string) {}
      }
    }

    export namespace Marketing {
      export class Designer {
        constructor(public name: string) {}
      }
    }
  }
}

// 创建别名
import Engineering = Company.Departments.Engineering
import Marketing = Company.Departments.Marketing

const dev = new Engineering.Developer('张三')
const designer = new Marketing.Designer('李四')

// 也可以为类创建别名
import Developer = Company.Departments.Engineering.Developer
const dev2 = new Developer('王五')

// 🔶 命名空间（旧方式）
namespace MyApp {
  export interface User {}
  export class UserService {}
}

// ✅ 模块（推荐方式）
// user.ts
export interface User {}
export class UserService {}

// 模块的优势：
// 1. 更好的代码组织
// 2. 更好的工具支持
// 3. 更好的 tree-shaking
// 4. 符合 ES 模块标准

// 扩展全局对象
declare global {
  interface Window {
    myApp: {
      version: string
      config: Record<string, unknown>
    }
  }

  namespace NodeJS {
    interface Global {
      myGlobal: string
    }
  }
}

// 使用
window.myApp = {
  version: '1.0.0',
  config: {},
}

export {} // 使文件成为模块

// 扩展 Express
declare namespace Express {
  interface Request {
    user?: {
      id: string
      role: string
    }
  }

  interface Response {
    success(data: unknown): void
    error(message: string): void
  }
}

// 使用
import express from 'express'

const app = express()

app.use((req, res, next) => {
  req.user = { id: '123', role: 'admin' }
  next()
})

app.get('/', (req, res) => {
  console.log(req.user?.id) // 类型安全
})

// ✅ 适合使用命名空间的场景

// 1. 全局类型声明
declare namespace MyLibrary {
  interface Options {}
}

// 2. 为第三方库添加类型
declare namespace Express {
  interface Request {
    customProp: string
  }
}

// 3. 逐步迁移旧代码

// 🔶 不推荐使用命名空间的场景

// 1. 新项目 - 使用 ES 模块
// 2. Node.js 项目 - 使用 CommonJS 或 ES 模块
// 3. 现代前端项目 - 使用 ES 模块

// 使用命名空间组织相关类型
declare namespace API {
  namespace Users {
    interface User {
      id: number
      name: string
    }

    interface CreateUserRequest {
      name: string
      email: string
    }

    interface UpdateUserRequest {
      name?: string
      email?: string
    }
  }

  namespace Products {
    interface Product {
      id: number
      name: string
      price: number
    }
  }
}

// 使用
function createUser(data: API.Users.CreateUserRequest): API.Users.User {
  // ...
}

// 命名空间编译后会生成 IIFE
var Utils
;(function (Utils) {
  function log(msg) {
    console.log(msg)
  }
  Utils.log = log
})(Utils || (Utils = {}))

// 模块可以更好地进行 tree-shaking
// 现代打包工具推荐使用 ES 模块