// 类装饰器：接收构造函数作为参数
function register(constructor: Function) {
  console.log(`Registered class: ${constructor.name}`);
  // 可通过构造函数原型添加元数据
  constructor.prototype.isRegistered = true;
}

@register // 应用装饰器
class User {
  name: string;
  constructor(name: string) {
    this.name = name;
  }
}
// 输出：Registered class: User
console.log(User.prototype.isRegistered); // 输出：true

// 属性装饰器：接收原型对象和属性名
function logProperty(target: any, propertyKey: string) {
  console.log(`Property declared: ${propertyKey} (on ${target.constructor.name})`);
  // 为属性添加元数据（可通过 Reflect API 存储）
  Reflect.defineMetadata('logProperty', true, target, propertyKey);
}

class User {
  @logProperty // 应用属性装饰器
  name: string;
  
  @logProperty
  age: number;
}
// 输出：
// Property declared: name (on User)
// Property declared: age (on User)

function decorator1(constructor: Function) {
  console.log('decorator1 executed');
}

function decorator2(constructor: Function) {
  console.log('decorator2 executed');
}

@decorator1 // 上层装饰器
@decorator2 // 下层装饰器（靠近类）
class A {}
// 输出顺序：decorator2 executed → decorator1 executed

function bound(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  console.log('bound executed');
  return descriptor;
}

function loggedMethod(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  console.log('loggedMethod executed');
  return descriptor;
}

class Greeter {
  @bound      // 下层装饰器（靠近方法）
  @loggedMethod // 上层装饰器
  greet() {}
}
// 输出顺序：bound executed → loggedMethod executed

// 1. 定义服务注册表
const serviceRegistry = new Map<string, any>();

// 2. 类装饰器：注册服务
function Injectable(identifier: string) {
  return (constructor: Function) => {
    serviceRegistry.set(identifier, constructor);
  };
}

// 3. 属性装饰器：注入依赖
function Inject(identifier: string) {
  return (target: any, propertyKey: string) => {
    // 在类实例化时注入依赖
    Object.defineProperty(target, propertyKey, {
      get() {
        const ServiceClass = serviceRegistry.get(identifier);
        return new ServiceClass();
      }
    });
  };
}

// 4. 使用示例
@Injectable('logger') // 注册日志服务
class LoggerService {
  log(message: string) {
    console.log(`[Log]: ${message}`);
  }
}

class UserService {
  @Inject('logger') // 注入日志服务
  private logger!: LoggerService;

  createUser() {
    this.logger.log('User created'); // 调用注入的服务
  }
}

// 测试
const userService = new UserService();
userService.createUser(); // 输出：[Log]: User created

// 类装饰器：添加表名元数据
function Table(tableName: string) {
  return (constructor: Function) => {
    constructor.prototype.tableMetadata = { tableName };
  };
}

// 属性装饰器：添加字段元数据
function Column(type: string) {
  return (target: any, propertyKey: string) => {
    if (!target.columnMetadata) {
      target.columnMetadata = {};
    }
    target.columnMetadata[propertyKey] = { type };
  };
}

// 使用示例
@Table('users')
class User {
  @Column('int')
  id: number;

  @Column('varchar(50)')
  name: string;

  @Column('datetime')
  createdAt: Date;
}

// 验证元数据
const user = new User();
console.log(user.tableMetadata); // { tableName: 'users' }
console.log(user.columnMetadata); 
// { id: { type: 'int' }, name: { type: 'varchar(50)' }, createdAt: { type: 'datetime' } }