import { sys } from "cc";
import { DataManager, DataId } from "../data/DataManager";
import { GirlData } from "../data/GirlData";
import proto from "db://assets/Scripts/proto/proto.pb.js";
import { ChatService } from "../network/services/ChatService";
import { logger } from "db://assets/Scripts/Main/Common/Logger";

export interface ChatMessage {
  role: "user" | "model";
  parts: { text: string }[];
  timestamp?: number;
}

export interface ChatHistory {
  roleId: number;
  messages: ChatMessage[];
  createdAt: number;
  updatedAt: number;
}

/**
 * 聊天历史管理器
 * 负责聊天记录的本地存储、加载和管理
 */
export class ChatHistoryManager {
  private static _instance: ChatHistoryManager;

  public static get Instance(): ChatHistoryManager {
    if (!this._instance) {
      this._instance = new ChatHistoryManager();
    }
    return this._instance;
  }

  private constructor() {}

  /**
   * 保存聊天历史到本地
   * @param roleId 角色ID
   * @param messages 消息列表
   */
  public saveHistory(roleId: number, messages: ChatMessage[]): void {
    const key = `chat_history_${roleId}`;
    try {
      // 检查是否已存在历史记录以保留创建时间
      let createdAt = Date.now();
      const existingData = sys.localStorage.getItem(key);
      if (existingData) {
        try {
          const existingHistory: ChatHistory = JSON.parse(existingData);
          createdAt = existingHistory.createdAt;
        } catch (parseError) {
          logger.warn(`Failed to parse existing history for role ${roleId}, using current time as createdAt`);
        }
      }

      const history: ChatHistory = {
        roleId: roleId,
        messages: messages,
        createdAt: createdAt,
        updatedAt: Date.now(),
      };

      sys.localStorage.setItem(key, JSON.stringify(history));
      logger.log(
        `Saved chat history for role ${roleId}, ${messages.length} messages`
      );
    } catch (error) {
      logger.error(`Failed to save chat history for role ${roleId}:`, error);
    }
  }

  /**
   * 从本地加载聊天历史
   * @param roleId 角色ID
   * @returns 消息列表，如果没有历史记录则返回空数组
   */
  public loadHistory(roleId: number): ChatMessage[] {
    const key = `chat_history_${roleId}`;
    try {
      const data = sys.localStorage.getItem(key);
      if (data) {
        const history: ChatHistory = JSON.parse(data);
        logger.log(
          `Loaded chat history for role ${roleId}: ${history.messages.length} messages`
        );
        return history.messages;
      }
    } catch (error) {
      logger.error(`Failed to load chat history for role ${roleId}:`, error);
      // 如果数据损坏，清除错误的数据
      this.clearHistory(roleId);
    }
    return [];
  }

  /**
   * 清除指定角色的聊天历史
   * @param roleId 角色ID
   */
  public clearHistory(roleId: number): void {
    const key = `chat_history_${roleId}`;
    sys.localStorage.removeItem(key);
    logger.log(`Cleared chat history for role ${roleId}`);
  }

  /**
   * 追加消息到历史记录
   * @param roleId 角色ID
   * @param message 消息对象
   */
  public appendMessage(roleId: number, message: ChatMessage): void {
    const history = this.loadHistory(roleId);

    // 添加时间戳
    message.timestamp = Date.now();
    history.push(message);

    // 限制历史长度，保留最近100条消息
    if (history.length > 100) {
      history.splice(0, history.length - 100);
      logger.log(`Trimmed chat history for role ${roleId} to 100 messages`);
    }

    this.saveHistory(roleId, history);
  }

  /**
   * 获取指定角色的消息数量
   * @param roleId 角色ID
   * @returns 消息数量
   */
  public getMessageCount(roleId: number): number {
    const history = this.loadHistory(roleId);
    return history.length;
  }

  /**
   * 获取最近的N条消息
   * @param roleId 角色ID
   * @param count 消息数量
   * @returns 最近的消息列表
   */
  public getRecentMessages(roleId: number, count: number = 10): ChatMessage[] {
    const history = this.loadHistory(roleId);
    return history.slice(-count);
  }

  /**
   * 清除所有聊天历史
   */
  public clearAllHistory(): void {
    // 查找所有chat_history_开头的key
    const keysToRemove: string[] = [];
    for (let i = 0; i < sys.localStorage.length; i++) {
      const key = sys.localStorage.key(i);
      if (key && key.startsWith("chat_history_")) {
        keysToRemove.push(key);
      }
    }

    // 删除找到的所有聊天历史
    keysToRemove.forEach((key) => {
      sys.localStorage.removeItem(key);
    });

    logger.log(
      `Cleared all chat histories, ${keysToRemove.length} records removed`
    );
  }

  /**
   * 获取所有有历史记录的角色ID列表
   * @returns 角色ID数组
   */
  public getAllHistoryRoleIds(): number[] {
    const roleIds: number[] = [];
    for (let i = 0; i < sys.localStorage.length; i++) {
      const key = sys.localStorage.key(i);
      if (key && key.startsWith("chat_history_")) {
        const roleId = parseInt(key.replace("chat_history_", ""));
        if (!isNaN(roleId)) {
          roleIds.push(roleId);
        }
      }
    }
    return roleIds;
  }

  /**
   * 准备上传到远程服务器（预留接口）
   * @param roleId 角色ID
   */
  public async syncToRemote(roleId: number): Promise<void> {
    const history = this.loadHistory(roleId);
    if (history.length === 0) {
      logger.log(`No history to sync for role ${roleId}`);
      return;
    }

    try {
      // TODO: 调用 HttpUnit.ins.api 上传到服务器
      // await HttpUnit.ins.api("chat/save_history", {
      //     role_id: roleId,
      //     messages: history
      // }, "POST");

      logger.log(
        `Ready to sync ${history.length} messages for role ${roleId} to remote server`
      );
    } catch (error) {
      logger.error(`Failed to sync history for role ${roleId}:`, error);
    }
  }

  /**
   * 获取指定角色的最后聊天时间
   * @param roleId 角色ID
   * @returns 最后聊天时间戳，如果没有历史记录则返回null
   */
  public getLastChatTime(roleId: number): number | null {
    const key = `chat_history_${roleId}`;
    try {
      const data = sys.localStorage.getItem(key);
      if (data) {
        const history: ChatHistory = JSON.parse(data);
        if (history.messages && history.messages.length > 0) {
          // 获取最后一条消息的时间戳
          const lastMessage = history.messages[history.messages.length - 1];
          return lastMessage.timestamp || history.updatedAt;
        }
        // 如果有历史但没有消息，返回创建时间
        return history.createdAt;
      }
    } catch (error) {
      logger.error(`Failed to get last chat time for role ${roleId}:`, error);
    }
    return null;
  }

  /**
   * 从远程服务器下载历史（预留接口）
   * @param roleId 角色ID
   */
  public async syncFromRemote(roleId: number): Promise<void> {
    try {
      // TODO: 调用 HttpUnit.ins.api 从服务器获取历史
      // const response = await HttpUnit.ins.api("chat/get_history", {
      //     role_id: roleId
      // }, "GET");

      // if (response && response.messages) {
      //     this.saveHistory(roleId, response.messages);
      //     logger.log(`Synced ${response.messages.length} messages from remote for role ${roleId}`);
      // }

      logger.log(
        `Ready to sync history from remote server for role ${roleId}`
      );
    } catch (error) {
      logger.error(`Failed to sync from remote for role ${roleId}:`, error);
    }
  }

  /**
   * 转换服务端聊天数据为本地格式
   * @param serverMessages 服务端聊天消息数组
   * @returns 本地格式的聊天消息数组
   */
  private convertServerDataToLocalFormat(
    serverMessages: proto.cs.IChatMsg[]
  ): ChatMessage[] {
    if (!serverMessages || serverMessages.length === 0) {
      return [];
    }

    const messages: ChatMessage[] = [];
    for (const serverMsg of serverMessages) {
      if (serverMsg.msg) {
        const message: ChatMessage = {
          role: serverMsg.isAi ? "model" : "user",
          parts: [{ text: serverMsg.msg }],
          timestamp: Number(serverMsg.msgId) || Date.now(),
        };
        messages.push(message);
      }
    }

    // 按时间戳排序，确保消息顺序正确
    messages.sort((a, b) => (a.timestamp || 0) - (b.timestamp || 0));

    logger.log(
      `Converted ${serverMessages.length} server messages to ${messages.length} local messages`
    );
    return messages;
  }

  /**
   * 从服务端获取聊天记录
   * @param roleId 角色ID
   * @param page 页码
   * @param limit 每页数量
   * @returns 是否成功获取数据
   */
  private async fetchServerChatHistory(
    roleId: number,
    page: number = 1,
    limit: number = 20
  ): Promise<boolean> {
    try {
      const reqData = {
        GirlId: roleId,
        page,
        limit,
      };

      logger.log("获取服务端聊天记录:", reqData);
      const res = await ChatService.I.reqGetChatMsg(reqData);

      if (res && res.code === proto.cs.EnmRetCode.SUCCESS) {
        const resData = res.data;
        // 保存到 GirlData
        const girlData = DataManager.I.getDataById<GirlData>(DataId.Girl);
        const category = girlData.getGrilCategoryById(roleId);
        girlData.setChatRecord(category.toString(), roleId, resData.msgs);
        girlData.setChatTotalCount(
          category.toString(),
          roleId,
          resData.chatTotalCount
        );
        girlData.setChatRemainCount(
          category.toString(),
          roleId,
          resData.chatRemainCount
        );

        logger.log(
          `成功从服务端获取聊天记录，roleId: ${roleId}, 消息数: ${
            resData.msgs?.length || 0
          }`
        );
        return true;
      } else {
        logger.warn(
          `从服务端获取聊天记录失败，roleId: ${roleId}, code: ${res?.code}`
        );
        return false;
      }
    } catch (error) {
      logger.error(`获取服务端聊天记录异常，roleId: ${roleId}:`, error);
      return false;
    }
  }

  /**
   * 合并本地和服务端聊天记录
   * @param localMessages 本地消息
   * @param serverMessages 服务端消息
   * @returns 合并后的消息数组
   */
  private mergeHistories(
    localMessages: ChatMessage[],
    serverMessages: ChatMessage[]
  ): ChatMessage[] {
    if (!localMessages || localMessages.length === 0) {
      return serverMessages || [];
    }

    if (!serverMessages || serverMessages.length === 0) {
      return localMessages;
    }

    // 使用 Map 进行去重，以时间戳为键
    const messageMap = new Map<number, ChatMessage>();

    // 先添加本地消息（优先级更高）
    localMessages.forEach((msg) => {
      if (msg.timestamp) {
        messageMap.set(msg.timestamp, msg);
      }
    });

    // 添加服务端消息（如果时间戳不冲突）
    serverMessages.forEach((msg) => {
      if (msg.timestamp && !messageMap.has(msg.timestamp)) {
        messageMap.set(msg.timestamp, msg);
      }
    });

    // 转换回数组并排序
    const mergedMessages = Array.from(messageMap.values());
    mergedMessages.sort((a, b) => (a.timestamp || 0) - (b.timestamp || 0));

    logger.log(
      `合并聊天记录: 本地 ${localMessages.length} 条, 服务端 ${serverMessages.length} 条, 合并后 ${mergedMessages.length} 条`
    );
    return mergedMessages;
  }

  /**
   * 整合的聊天记录加载方法：优先加载本地数据，如果本地没有再获取服务端数据
   * @param roleId 角色ID
   * @returns 聊天消息数组
   */
  public async loadChatHistory(roleId: number): Promise<ChatMessage[]> {
    // 1. 首先尝试从本地加载
    const localHistory = this.loadHistory(roleId);

    // 2. 如果本地有数据，直接返回
    if (localHistory && localHistory.length > 0) {
      logger.log(
        `使用本地聊天记录，roleId: ${roleId}, 消息数: ${localHistory.length}`
      );
      return localHistory;
    }

    // 3. 本地没有数据，尝试从服务端获取
    logger.log(`本地无聊天记录，尝试从服务端获取，roleId: ${roleId}`);
    const serverSuccess = await this.fetchServerChatHistory(roleId);

    if (!serverSuccess) {
      logger.log(`服务端获取失败，返回空记录，roleId: ${roleId}`);
      return [];
    }

    // 4. 从 GirlData 读取服务端数据并转换格式
    const girlData = DataManager.I.getDataById<GirlData>(DataId.Girl);
    const category = girlData.getGrilCategoryById(roleId);
    const serverMsgIds = girlData.getChatRecordIds(category.toString(), roleId);

    const serverMessages: proto.cs.IChatMsg[] = [];
    for (const id of serverMsgIds) {
      const isAi = girlData.getChatRecordIsAi(category.toString(), roleId, id);
      const msg = girlData.getChatRecordMsg(category.toString(), roleId, id);
      if (msg) {
        serverMessages.push({
          msgId: id.toString(),
          msg: msg,
          isAi: isAi,
        });
      }
    }

    // 5. 转换服务端数据格式
    const convertedMessages =
      this.convertServerDataToLocalFormat(serverMessages);

    // 6. 保存到本地存储
    if (convertedMessages.length > 0) {
      this.saveHistory(roleId, convertedMessages);
      logger.log(
        `从服务端获取并保存聊天记录，roleId: ${roleId}, 消息数: ${convertedMessages.length}`
      );
    }

    return convertedMessages;
  }
}