18xchat/assets/Scripts/chat18x/manager/NavigationManager.ts

import { ViewManager } from "db://assets/Scripts/Main/Manager/ViewManager";
import { UITransitionHelper } from "../utils/UITransitionHelper";
import GameRootUI from "../../Main/Common/GameRootUI";
import { Node, sys } from "cc";
import li_EventManager from "../../Main/Common/li_EventManager";
import { InnerMsgCode } from "../../Main/Config/InnerMsgCode";
import { ThemePanel } from "../ui/panels/ThemePanel";
import { GirlListPanel } from "../ui/panels/GirlListPanel";
import li_BaseView from "../../Main/Common/li_BaseView";
import { logger } from "db://assets/Scripts/Main/Common/Logger";

/**
 * 页面过渡动画类型枚举
 */
export enum PageTransitionType {
  NONE = "none",
  SLIDE_LEFT = "slide_left",
  SLIDE_RIGHT = "slide_right",
  SLIDE_UP = "slide_up",
  SLIDE_DOWN = "slide_down",
  FADE = "fade",
  SCALE = "scale",
}

/**
 * NavigationPanel面板类型枚举
 */
export enum PanelType {
  THEME = "ThemePanel",
  GIRL_DETAIL = "GirlDetailPanel",
  PAST_GIRL_LIST = "PastGirlListPanel",
  PERSONAL = "PersonalPanel",
}

/**
 * 页面过渡动画配置接口
 */
export interface PageTransitionConfig {
  incomingTransition: PageTransitionType;
  outgoingTransition: PageTransitionType;
  duration?: number;
  simultaneous?: boolean;
}

/**
 * 子面板动画配置接口
 */
export interface SubPanelAnimationConfig {
  openAnimation: PageTransitionType;
  closeAnimation: PageTransitionType;
  duration?: number;
}

/**
 * 导航管理器
 *
 * 负责管理游戏中的页面导航和路由，将导航逻辑从业务逻辑中分离出来
 * 统一管理NavigationPanel和其他面板的切换
 *
 * @author AI Chat System
 * @version 1.0.0
 */
export class NavigationManager {
  private static _instance: NavigationManager;

  // NavigationPanel相关属性
  private navigationPanel: any = null; // NavigationPanel实例引用
  private currentActivePanelType: PanelType = PanelType.PAST_GIRL_LIST;
  private currentActivePanel: Node = null; // 初始化为null
  private panelCache: Map<PanelType, Node> = new Map(); // 面板缓存

  // 选中的角色相关信息
  private selectedGirlId: number = 10002; // 当前选中的角色ID
  private selectedCategoryId: number = -1; // 当前选中的主题ID

  private static LastSelectGirlID = "LastSelectGirlID";

  /**
   * 获取NavigationManager的单例实例
   *
   * @returns {NavigationManager} 导航管理器实例
   * @static
   */
  public static get Instance(): NavigationManager {
    if (!this._instance) {
      this._instance = new NavigationManager();

      //初始化默认选的girl
      let cacheGirlId = sys.localStorage.getItem(this.LastSelectGirlID);
      if (!cacheGirlId) {
        cacheGirlId = 10016;
        sys.localStorage.setItem(this.LastSelectGirlID, cacheGirlId);
      }
      this._instance.selectedGirlId = Number(cacheGirlId);

      let cacheCategoryId = sys.localStorage.getItem("LastSelectCategoryId");
      if (!cacheCategoryId) {
        cacheCategoryId = 0;
        sys.localStorage.setItem("LastSelectCategoryId", cacheCategoryId);
      }
      this._instance.selectedCategoryId = cacheCategoryId;
    }
    return this._instance;
  }

  private constructor() {
    // 初始化事件监听
    this.initEventListeners();
  }

  /**
   * 初始化事件监听
   */
  private initEventListeners(): void {
    //
  }

  /**
   * 注册NavigationPanel实例
   * @param panel NavigationPanel实例
   */
  public registerNavigationPanel(panel: any): void {
    this.navigationPanel = panel;
    logger.log("[NavigationManager] NavigationPanel registered");
  }

  /**
   * 统一的面板切换方法
   * @param panelType 目标面板类型
   */
  public switchToPanel(
    panelType: PanelType,
    force: boolean = false,
    callback: Function = null
  ): Node {
    if (!panelType) {
      logger.error("[NavigationManager] switchToPanel: panelType is invalid");
      return null;
    }

    if (this.currentActivePanelType === panelType && !force) {
      logger.log(
        `[NavigationManager] Already on ${panelType}, skipping switch`
      );
      return this.currentActivePanel;
    }

    if (!this.navigationPanel) {
      logger.warn(
        "[NavigationManager] NavigationPanel not registered, fallback to direct ViewManager call"
      );
      //this.fallbackSwitchPanel(panelType);
      return null;
    }

    // 切换面板前先关闭所有弹窗
    this.closeAllPopups();

    // 通知NavigationPanel显示加载状态
    this.navigationPanel.showLoading?.();

    // 计算动画方向
    const currentIndex = this.getPanelIndex(this.currentActivePanelType);
    const targetIndex = this.getPanelIndex(panelType);
    const isMovingRight = currentIndex < targetIndex;

    const hideDirection = isMovingRight ? "left" : "right";
    const showDirection = isMovingRight ? "right" : "left";

    // 隐藏当前面板（包括子页面）
    if (this.currentActivePanel && this.currentActivePanel.isValid) {
      this.hidePanelWithAnimation(this.currentActivePanel, hideDirection);
    }

    // 加载并显示目标面板
    this.loadOrGetPanel(panelType, (panel: Node) => {
      // 清理当前面板的subPanel（在hidePanelWithAnimation中已经清理，这里不需要重复）

      this.currentActivePanelType = panelType;

      // 更新NavigationPanel按钮状态
      this.navigationPanel.updateButtonStates?.(panelType);

      // 显示面板
      this.showPanelWithAnimation(panel, showDirection, () => {
        this.currentActivePanel = panel;
        this.navigationPanel.hideLoading?.();
        if (callback instanceof Function) callback(panel);
      });
    });
  }

  private subPanelDic: Map<Node, Node[]> = new Map();
  private subPanelMapping: Map<Node, PanelType> = new Map();
  private subPanelAnimationConfigs: Map<Node, SubPanelAnimationConfig> =
    new Map();

  // 弹窗管理相关属性
  private popupPanels: Set<Node> = new Set(); // 管理所有打开的弹窗

  // 动画锁，防止动画中重复操作
  private isAnimating: boolean = false;

  /**
   * 带动画的子面板清理方法
   * @param basePanel 主面板节点
   * @param callback 所有动画完成后的回调
   */
  private clearSubPanelsWithAnimation(
    basePanel: Node,
    callback?: Function
  ): void {
    if (!basePanel || !basePanel.isValid) {
      callback && callback();
      return;
    }

    const subPanels = this.subPanelDic.get(basePanel);
    if (!subPanels || subPanels.length === 0) {
      callback && callback();
      return;
    }

    let completedCount = 0;
    const totalCount = subPanels.length;

    // 完成动画的回调
    const onAnimationComplete = () => {
      completedCount++;
      if (completedCount >= totalCount) {
        // 清理subPanelDic
        this.subPanelDic.delete(basePanel);
        callback && callback();
      }
    };

    // 同时播放所有子面板的关闭动画
    for (let i = subPanels.length - 1; i >= 0; i--) {
      const subPanel = subPanels[i];
      if (subPanel && subPanel.isValid) {
        // 获取动画配置
        let config = this.subPanelAnimationConfigs.get(subPanel);
        if (!config) {
          config = {
            openAnimation: PageTransitionType.SCALE,
            closeAnimation: PageTransitionType.SCALE,
            duration: 0.2,
          };
        }

        // 播放关闭动画
        this.playSubPanelCloseAnimation(subPanel, config, () => {
          // 清理映射
          this.subPanelMapping.delete(subPanel);
          this.subPanelAnimationConfigs.delete(subPanel);

          // 销毁节点
          const baseView = subPanel.getComponent(li_BaseView);
          if (baseView) {
            baseView.close();
          } else {
            subPanel.destroy();
          }

          onAnimationComplete();
        });
      } else {
        onAnimationComplete();
      }
    }
  }

  /**
   * 统一的subPanel清理方法
   * @param basePanel 主面板节点
   * @param destroyPanels 是否销毁面板，默认为true
   */
  private clearSubPanels(basePanel: Node, destroyPanels: boolean = true): void {
    if (!basePanel || !basePanel.isValid) {
      return;
    }

    const subPanels = this.subPanelDic.get(basePanel);
    if (!subPanels || subPanels.length === 0) {
      return;
    }

    // 清理所有子面板
    for (let i = subPanels.length - 1; i >= 0; i--) {
      const subPanel = subPanels[i];
      if (subPanel && subPanel.isValid) {
        // 清理subPanelMapping
        this.subPanelMapping.delete(subPanel);

        // 清理动画配置
        this.subPanelAnimationConfigs.delete(subPanel);

        if (destroyPanels) {
          const baseView = subPanel.getComponent(li_BaseView);
          if (baseView) {
            baseView.close();
          } else {
            subPanel.destroy();
          }
        }
      }
    }

    // 清理subPanelDic
    this.subPanelDic.delete(basePanel);
  }
  public openSubPanel(
    panelName: string,
    basePanel: Node,
    data: any = null,
    animationConfig?: SubPanelAnimationConfig
  ) {
    if (!panelName) {
      logger.error("[NavigationManager] openSubPanel: panelName is empty");
      return;
    }

    if (!basePanel || !basePanel.isValid) {
      logger.error("[NavigationManager] openSubPanel: basePanel is invalid");
      return;
    }

    // 使用默认动画配置
    const defaultConfig: SubPanelAnimationConfig = {
      openAnimation: PageTransitionType.SCALE,
      closeAnimation: PageTransitionType.SCALE,
      duration: 0.3,
    };
    const config = animationConfig || defaultConfig;

    const callback = (n: Node) => {
      if (!n || !n.isValid) {
        logger.error(
          "[NavigationManager] openSubPanel: created panel is invalid"
        );
        return;
      }

      if (!this.subPanelDic.has(basePanel)) {
        this.subPanelDic.set(basePanel, []);
      }

      const subPanels = this.subPanelDic.get(basePanel);
      subPanels.push(n);

      const basePanelType = this.getPanelType(basePanel);
      if (basePanelType) {
        this.subPanelMapping.set(n, basePanelType);
      } else {
        logger.warn(
          `[NavigationManager] 无法确定basePanel类型: ${basePanel.name}`
        );
      }
      // 存储动画配置
      this.subPanelAnimationConfigs.set(n, config);

      // 执行打开动画
      this.playSubPanelOpenAnimation(n, config);
    };

    ViewManager.I.openBundlesView(panelName, data, callback);
  }

  /**
   * 将过渡类型转换为方向字符串
   */
  private getDirectionFromTransitionType(
    transitionType: PageTransitionType
  ): "left" | "right" | "up" | "down" {
    switch (transitionType) {
      case PageTransitionType.SLIDE_LEFT:
        return "left";
      case PageTransitionType.SLIDE_RIGHT:
        return "right";
      case PageTransitionType.SLIDE_UP:
        return "up";
      case PageTransitionType.SLIDE_DOWN:
        return "down";
      default:
        return "left"; // 默认向左
    }
  }

  /**
   * 执行子面板打开动画
   */
  private playSubPanelOpenAnimation(
    panel: Node,
    config: SubPanelAnimationConfig
  ): void {
    if (!panel || !panel.isValid) {
      return;
    }

    const duration = config.duration || 0.3;
    //panel.active = false;

    switch (config.openAnimation) {
      case PageTransitionType.SCALE:
        UITransitionHelper.scaleIn(panel, duration);
        break;
      case PageTransitionType.FADE:
        UITransitionHelper.fadeIn(panel, duration);
        break;
      case PageTransitionType.SLIDE_UP:
        UITransitionHelper.slideInFromBottom(panel, duration);
        break;
      case PageTransitionType.SLIDE_DOWN:
        UITransitionHelper.slideInFromTop(panel, duration);
        break;
      case PageTransitionType.SLIDE_LEFT:
        UITransitionHelper.slideInFromRight(panel, duration);
        break;
      case PageTransitionType.SLIDE_RIGHT:
        UITransitionHelper.slideInFromLeft(panel, duration);
        break;
      default:
        // 无动画，直接显示
        break;
    }
  }

  /**
   * 执行子面板关闭动画
   */
  private playSubPanelCloseAnimation(
    panel: Node,
    config: SubPanelAnimationConfig,
    callback?: Function
  ): void {
    if (!panel || !panel.isValid) {
      callback && callback();
      return;
    }

    const duration = config.duration || 0.3;

    switch (config.closeAnimation) {
      case PageTransitionType.SCALE:
        UITransitionHelper.scaleOut(panel, duration, callback);
        break;
      case PageTransitionType.FADE:
        UITransitionHelper.fadeOut(panel, duration, callback);
        break;
      case PageTransitionType.SLIDE_UP:
        UITransitionHelper.slideOutToTop(panel, duration, callback);
        break;
      case PageTransitionType.SLIDE_DOWN:
        UITransitionHelper.slideOutToBottom(panel, duration, callback);
        break;
      case PageTransitionType.SLIDE_LEFT:
        UITransitionHelper.slideOutToLeft(panel, duration, callback);
        break;
      case PageTransitionType.SLIDE_RIGHT:
        UITransitionHelper.slideOutToRight(panel, duration, callback);
        break;
      default:
        // 无动画，直接执行回调
        callback && callback();
        break;
    }
  }

  /**
   * 打开弹窗面板
   * @param panelName 弹窗面板名称
   * @param data 传递的数据
   * @param callback 可选的回调函数
   */
  public openPopupPanel(
    panelName: string,
    data: any = null,
    callback?: Function
  ): void {
    if (!panelName) {
      logger.error("[NavigationManager] openPopupPanel: panelName is empty");
      return;
    }

    const popupCallback = (panel: Node) => {
      if (!panel || !panel.isValid) {
        logger.error(
          "[NavigationManager] openPopupPanel: created panel is invalid"
        );
        return;
      }

      // 将弹窗添加到管理集合中
      this.popupPanels.add(panel);
      logger.log(
        `[NavigationManager] Popup panel opened: ${panelName}, total popups: ${this.popupPanels.size}`
      );

      if (callback) {
        callback(panel);
      }
    };

    ViewManager.I.openBundlesPopupView(panelName, data, popupCallback);
  }

  /**
   * 关闭弹窗面板
   * @param panel 要关闭的弹窗节点
   */
  public closePopupPanel(panel: Node): void {
    if (!panel || !panel.isValid) {
      logger.warn("[NavigationManager] closePopupPanel: panel is invalid");
      return;
    }

    // 从弹窗管理集合中移除
    if (this.popupPanels.has(panel)) {
      this.popupPanels.delete(panel);
      logger.log(
        `[NavigationManager] Popup panel closed: ${panel.name}, total popups: ${this.popupPanels.size}`
      );
    }

    // 关闭面板
    try {
      const baseView = panel.getComponent(li_BaseView);
      if (baseView) {
        baseView.close();
      } else {
        panel.destroy();
      }
    } catch (error) {
      logger.error("[NavigationManager] closePopupPanel error:", error);
    }
  }

  /**
   * 关闭所有弹窗
   */
  private closeAllPopups(): void {
    if (this.popupPanels.size === 0) {
      return;
    }

    logger.log(
      `[NavigationManager] Closing all popups, count: ${this.popupPanels.size}`
    );

    // 复制Set以避免在迭代过程中修改
    const popupPanelsToClose = Array.from(this.popupPanels);

    for (const panel of popupPanelsToClose) {
      if (panel && panel.isValid) {
        this.closePopupPanel(panel);
      }
    }

    // 确保清空集合
    this.popupPanels.clear();
  }
  public closeSubPanel(
    panel: Node | li_BaseView,
    animationConfig?: SubPanelAnimationConfig
  ) {
    if (!panel) {
      logger.warn(
        "[NavigationManager] closeSubPanel: panel is null or undefined"
      );
      return;
    }

    let panelNode: Node;
    if (panel instanceof Node) {
      panelNode = panel;
    } else {
      panelNode = panel.node;
    }

    if (!panelNode || !panelNode.isValid) {
      logger.warn("[NavigationManager] closeSubPanel: panelNode is invalid");
      return;
    }

    // 获取动画配置（优先使用传入的配置，然后使用存储的配置，最后使用默认配置）
    let config = animationConfig;
    if (!config && this.subPanelAnimationConfigs.has(panelNode)) {
      config = this.subPanelAnimationConfigs.get(panelNode);
    }
    if (!config) {
      config = {
        openAnimation: PageTransitionType.SCALE,
        closeAnimation: PageTransitionType.SCALE,
        duration: 0.3,
      };
    }

    // 执行关闭动画
    this.playSubPanelCloseAnimation(panelNode, config, () => {
      // 从管理映射中移除
      this.removeSubPanelFromMappings(panelNode);

      // 销毁或关闭panel
      try {
        if (panel instanceof Node) {
          panel.destroy();
        } else {
          panel.close();
        }
      } catch (error) {
        logger.error("[NavigationManager] closeSubPanel error:", error);
      }
    });
  }

  /**
   * 从管理映射中移除子面板
   */
  private removeSubPanelFromMappings(panelNode: Node): void {
    // 从subPanelMapping和subPanelDic中移除
    if (this.subPanelMapping.has(panelNode)) {
      const baseType = this.subPanelMapping.get(panelNode);
      const baseNode = this.panelCache.get(baseType);

      if (baseNode && this.subPanelDic.has(baseNode)) {
        const subPanels = this.subPanelDic.get(baseNode);
        const index = subPanels.indexOf(panelNode);
        if (index !== -1) {
          subPanels.splice(index, 1);
          // 如果subPanels为空，删除整个条目
          if (subPanels.length === 0) {
            this.subPanelDic.delete(baseNode);
          }
        } else {
          logger.warn(
            `[NavigationManager] ${panelNode.name} 不在子页面列表中`
          );
        }
      }

      this.subPanelMapping.delete(panelNode);
    }

    // 移除动画配置
    if (this.subPanelAnimationConfigs.has(panelNode)) {
      this.subPanelAnimationConfigs.delete(panelNode);
    }
  }

  /**
   * 获取面板索引（用于动画方向计算）
   */
  private getPanelIndex(panelType: PanelType): number {
    switch (panelType) {
      case PanelType.THEME:
        return 0;
      case PanelType.GIRL_DETAIL:
        return 1;
      case PanelType.PAST_GIRL_LIST:
        return 2;
      case PanelType.PERSONAL:
        return 3;
      default:
        return 0;
    }
  }
  private getPanelType(node: Node): PanelType {
    if (!node || !node.isValid) {
      logger.warn("[NavigationManager] getPanelType: node is invalid");
      return null;
    }

    switch (node.name) {
      case "ThemePanel":
        return PanelType.THEME;
      case "GirlDetailPanel":
        return PanelType.GIRL_DETAIL;
      case "PastGirlListPanel":
        return PanelType.PAST_GIRL_LIST;
      case "PersonalPanel":
        return PanelType.PERSONAL;
      default:
        logger.warn(
          `[NavigationManager] Unknown panel type for node: ${node.name}`
        );
        return null;
    }
  }

  /**
   * 获取面板名称
   */
  private getPanelName(panelType: PanelType): string {
    return panelType as string;
  }

  /**
   * 获取面板数据
   */
  private getPanelData(panelType: PanelType): any {
    switch (panelType) {
      case PanelType.GIRL_DETAIL:
        return this.selectedGirlId; // 使用当前选中的角色ID
      default:
        return null;
    }
  }

  /**
   * 加载或获取面板
   */
  private loadOrGetPanel(
    panelType: PanelType,
    callback: (panel: Node) => void
  ) {
    // 检查缓存
    if (this.panelCache.has(panelType)) {
      const cachedPanel = this.panelCache.get(panelType);
      if (cachedPanel && cachedPanel.isValid) {
        // 确保缓存panel的subPanel状态正确，清理可能残留的subPanel引用
        this.clearSubPanels(cachedPanel, false); // 不销毁panel，只清理引用

        // 特殊处理：主题面板刷新（避免重复调用Show）
        if (panelType === PanelType.THEME) {
          const themePanel = cachedPanel.getComponent(ThemePanel);
          if (themePanel) {
            // 不在这里调用Show()，因为ThemePanel已经有加载状态保护
            // 只在必要时调用onHide()确保子页面状态正确
            if (typeof themePanel.onHide === "function") {
              logger.log("[NavigationManager] 确保主题面板子页面状态正确");
              themePanel.onHide();
            }
          }
        }
        callback(cachedPanel);
        return;
      } else {
        this.panelCache.delete(panelType);
      }
    }

    // 加载新面板
    const panelName = this.getPanelName(panelType);
    const openData = this.getPanelData(panelType);

    ViewManager.I.openBundlesView(panelName, openData, (panel: Node) => {
      if (panel && panel.isValid) {
        this.panelCache.set(panelType, panel);
        callback(panel);
      }
    });
  }

  /**
   * 隐藏面板动画
   */
  private hidePanelWithAnimation(
    panel: Node,
    direction: "left" | "right" | "up" | "down",
    callback?: Function
  ) {
    if (!panel || !panel.isValid) {
      callback && callback();
      return;
    }

    // 同时开始子面板的关闭动画
    this.clearSubPanelsWithAnimation(panel);

    if (!panel.active) panel.active = true;

    const animationCallback = () => {
      panel.active = false;
      callback && callback();
    };

    // 主面板动画
    switch (direction) {
      case "left":
        UITransitionHelper.slideOutToLeft(panel, 0.3, animationCallback);
        break;
      case "right":
        UITransitionHelper.slideOutToRight(panel, 0.3, animationCallback);
        break;
      case "up":
        UITransitionHelper.slideOutToTop(panel, 0.3, animationCallback);
        break;
      case "down":
        UITransitionHelper.slideOutToBottom(panel, 0.3, animationCallback);
        break;
      default:
        // 默认左侧滑出
        UITransitionHelper.slideOutToLeft(panel, 0.3, animationCallback);
        break;
    }
  }

  /**
   * 显示面板动画
   */
  private showPanelWithAnimation(
    panel: Node,
    direction: "left" | "right" | "up" | "down",
    callback?: Function
  ) {
    if (!panel || !panel.isValid) {
      callback && callback();
      return;
    }

    panel.active = true;
    panel.getComponent(li_BaseView)

    switch (direction) {
      case "left":
        UITransitionHelper.slideInFromLeft(panel, 0.3, callback);
        break;
      case "right":
        UITransitionHelper.slideInFromRight(panel, 0.3, callback);
        break;
      case "up":
        UITransitionHelper.slideInFromTop(panel, 0.3, callback);
        break;
      case "down":
        UITransitionHelper.slideInFromBottom(panel, 0.3, callback);
        break;
      default:
        // 默认从右侧滑入
        UITransitionHelper.slideInFromRight(panel, 0.3, callback);
        break;
    }
  }

  /**
   * 获取当前激活的面板类型
   */
  public getCurrentActivePanel(): PanelType {
    return this.currentActivePanelType;
  }

  /**
   * 获取当前激活的面板节点
   */
  public getCurrentActivePanelNode(): Node {
    return this.currentActivePanel;
  }

  /**
   * 设置选中的角色ID
   * @param girlId 角色ID
   */
  public setSelectedGirlId(girlId: number): void {
    this.selectedGirlId = girlId;
    sys.localStorage.setItem(NavigationManager.LastSelectGirlID, girlId);
    logger.log("[NavigationManager] Selected girl ID set to:", girlId);
  }

  /**
   * 获取当前选中的角色ID
   * @returns 当前选中的角色ID
   */
  public getSelectedGirlId(): number {
    return this.selectedGirlId;
  }

  /**
   * 设置选中的主题ID
   * @param themeId 主题ID
   */
  public setSelectedCategoryId(themeId: number): void {
    this.selectedCategoryId = themeId;
    logger.log("[NavigationManager] Selected theme ID set to:", themeId);
  }

  /**
   * 获取当前选中的主题ID
   * @returns 当前选中的主题ID
   */
  public getSelectedCategoryId(): number {
    return this.selectedCategoryId;
  }
}