/**
 * 数据管理器
 * 统一管理所有数据类
 */
import { BaseData } from "./BaseData";
import { LoginData } from "./LoginData";
import { PlayerData } from "./PlayerData";
import { AccountData } from "./AccountData";
import { MetaData } from "./MetaData";
import { NetTimeData } from "./NetTimeData";
import { ThemeData } from "./ThemeData";
import { WalletData } from "./WalletData";
import { ShopData } from "./ShopData";
import { OrderData } from "./OrderData";

/**
 * 集中定义数据ID，避免写错字符串
 */
export enum DataId {
  Login = "login",
  Player = "player",
  Account = "account",
  Meta = "meta",
  NetTime = "netTime",
  Theme = "theme",
  Wallet = "wallet",
  Shop = "shop",
  Order = "order",
}

/** 构造器类型 */
type DataCtor<T extends BaseData = BaseData> = new () => T;

export class DataManager {
  private static _I: DataManager | null = null;
  public static get I(): DataManager {
    if (!DataManager._I) DataManager._I = new DataManager();
    return DataManager._I;
  }

  // 数据实例缓存
  private _dataMap: Map<string, BaseData> = new Map();

  // 数据ID到构造器的映射
  private _config: Map<string, DataCtor> = new Map();

  private constructor() {}

  /**
   * 初始化：注册 数据ID → 构造器
   */
  public init(): void {
    console.log("[DataManager] 数据管理器初始化");
    this.registerAll();
  }

  /**
   * 注册 数据ID → 构造器
   */
  private registerAll(): void {
    this.register(DataId.Login, LoginData);
    this.register(DataId.Player, PlayerData);
    this.register(DataId.Account, AccountData);
    this.register(DataId.Meta, MetaData);
    this.register(DataId.NetTime, NetTimeData);
    this.register(DataId.Theme, ThemeData);
    this.register(DataId.Wallet, WalletData);
    this.register(DataId.Shop, ShopData);
    this.register(DataId.Order, OrderData);
  }

  /**
   * 注册一个数据ID及其对应的构造器
   */
  private register<T extends BaseData>(dataId: string, ctor: DataCtor<T>): void {
    if (this._config.has(dataId)) {
      console.warn(`[DataManager] 重复注册数据ID: ${dataId}，将覆盖旧构造器`);
    }
    this._config.set(dataId, ctor);
  }

  /**
   * 获取数据（已存在则直接返回；否则按配置自动实例化并缓存）
   */
  public getDataById<T extends BaseData = BaseData>(dataId: string): T | null {
    // 先从缓存取
    const cached = this._dataMap.get(dataId) as T | undefined;
    if (cached) return cached;

    // 缓存没有→ 查找构造器
    const Ctor = this._config.get(dataId) as DataCtor<T> | undefined;
    if (!Ctor) {
      console.warn(`[DataManager] 未找到 dataId 的构造器配置: ${dataId}`);
      return null;
    }

    // 动态创建 & init & 缓存
    const instance = new Ctor();
    // 若你的 BaseData.init 接受 dataId，可传入
    instance.init?.(dataId);
    this._dataMap.set(dataId, instance);

    console.log(`[DataManager] 实例化并缓存数据: ${dataId}`);
    return instance;
  }

  /**
   * 移除数据
   */
  public removeData(dataId: string): boolean {
    const data = this._dataMap.get(dataId);
    if (data) {
      data.destroy?.();
      this._dataMap.delete(dataId);
      console.log(`[DataManager] 移除数据: ${dataId}`);
      return true;
    }
    return false;
  }

  /**
   * 重置所有数据
   */
  public resetAllData(): void {
    console.log("[DataManager] 重置所有数据");
    this._dataMap.forEach((data) => data.reset?.());
  }

  /**
   * 清空所有数据
   */
  public clearAllData(): void {
    console.log("[DataManager] 清空所有数据");
    this._dataMap.forEach((data) => data.clear?.());
  }

  /**
   * 销毁所有数据
   */
  public destroyAllData(): void {
    console.log("[DataManager] 销毁所有数据");
    this._dataMap.forEach((data) => data.destroy?.());
    this._dataMap.clear();
  }
}