import { createRouter, createWebHistory } from "vue-router";
import { setToken, removeToken, getToken } from "@/api/request.js";
import { AUTH_LOGOUT_CHANNEL } from "@/utils/authCrossTabLogout.js";

/** localStorage：跨标签页记录当前前端的 bootId（与 vite define 的 __APP_BOOT_ID__ 对齐） */
const VITE_BOOT_STORAGE_KEY = "app_vite_boot_id";
/** 退出后强制回登录页（跨标签页/刷新生效） */
const FORCE_LOGIN_KEY = "force_login";
// ===== SSO/重定向相关（切线上接口时先注释保留） =====
// /** 强制走统一登录（仅前端控制）：退出登录后置 1，直到 SSO 回跳带 ?token= 再清除 */
// const FORCE_SSO_LOGIN_KEY = "force_sso_login";

function getCurrentViteBootId() {
  try {
    // eslint-disable-next-line no-undef
    return typeof __APP_BOOT_ID__ !== "undefined" ? String(__APP_BOOT_ID__) : "";
  } catch {
    return "";
  }
}

/** 仅同步 bootId（SSO 回跳带 ?token= 时会提前 return，须单独写入，否则下次进入 /ZMOverView 会误判 boot 变更而清 token） */
function persistViteBootIdOnly() {
  if (typeof window === "undefined") return;
  const current = getCurrentViteBootId();
  if (!current) return;
  try {
    window.localStorage.setItem(VITE_BOOT_STORAGE_KEY, current);
  } catch {
    // ignore
  }
}

/**
 * 每次重启 Vite/重新构建后 __APP_BOOT_ID__ 会变；仅当「曾记录过旧 bootId 且与当前不一致」时清空 token。
 * 用 localStorage 而非 sessionStorage，避免新开标签页时误把有效 token 清掉导致请求不带 token、全员 401。
 * 注意：须在处理完 URL ?token= 之后再执行，避免先清 token 再写入的竞态。
 */
function clearTokenIfNewDevBoot() {
  if (typeof window === "undefined") return;
  try {
    const current = getCurrentViteBootId();
    if (!current) return;
    const saved = window.localStorage.getItem(VITE_BOOT_STORAGE_KEY);
    if (saved && saved !== current) {
      removeToken();
    }
    window.localStorage.setItem(VITE_BOOT_STORAGE_KEY, current);
  } catch {
    // ignore
  }
}

// /** 统一认证网关：未登录时整页跳转此处，由后端再跳到登录页；登录成功后回跳到前端并带 ?token= */
// const SSO_GATEWAY_ORIGIN =
//   import.meta.env.VITE_SSO_GATEWAY_ORIGIN || "http://172.19.21.228:28080";
//
// /** 网关注册的回跳地址常为 /callback；保存 token 后应进入业务首页，避免停在无路由的 /callback */
// const SSO_POST_LOGIN_PATH =
//   import.meta.env.VITE_SSO_POST_LOGIN_PATH || "/ZMOverView";

/**
 * 是否与「请求里 getToken()」一致：避免出现仅空白/脏数据时仍认为已登录 → 不走 SSO 且请求头无 token
 */
function hasStoredAuthToken() {
  return Boolean(getToken());
}
const Home = () => import('@/views/home/index.vue')
const DataLibrary = () => import('@/views/dataLibrary/index.vue')

// 自动导入所有模块路由
const modules = import.meta.glob('./modules/*.js', { eager: true })

const fileRoutes = Object.keys(modules).reduce((acc, path) => {
  const module = modules[path].default
  acc.push(...module)
  return acc
}, [])

// 自动导入所有资源库模块路由
const datas = import.meta.glob('./dataLibrary/*.js', { eager: true })

const dataRoutes = Object.keys(datas).reduce((acc, path) => {
  const module = datas[path].default
  acc.push(...module)
  return acc
}, [])

const routes = [
  {
    path: "/login",
    name: "Login",
    component: () => import("@/views/login/index.vue"),
    meta: {
      title: "登录"
    }
  },
  {
    path: "/",
    name: "Home",
    // 访问根路径时默认进入概览页（否则 Home 的 router-view 为空，看起来像白屏）
    redirect: "/ZMOverView",
    component: Home,
    children: [
      ...fileRoutes,
      {
        path: "/dataLibrary",
        name: "DataLibrary",
        redirect: "./dataLibrary/countryBill",
        component: DataLibrary,
        meta: {
          title: '数据资源库',
          isShowHeader: true
        },
        children: [
          ...dataRoutes
        ]
      },
    ]
  },

  // {
  //   path: "/dataLibrary",
  //   name: "DataLibrary",
  //   component: DataLibrary,
  //   meta: {
  //     title: '数据资源库'
  //   },
  //   children: [
  //     ...dataRoutes
  //   ]
  // },


];

console.log('路由', routes)
const router = createRouter({
  history: createWebHistory(),
  routes
});

// 路由守卫：SSO + 设置页面标题
// 1）首次/无本地 token：整页跳到网关 /api/v2 + 当前路径，走后端登录
// 2）登录成功回跳带 ?token=：先 setToken 并同步 bootId，再去掉 URL 中的 token（须先于 clearTokenIfNewDevBoot，避免误清刚写入的登录态）
// 3）已有本地 token：正常走前端路由
router.beforeEach((to, from, next) => {
  // ===== SSO/重定向逻辑（切线上接口时停用，保留注释） =====
  // const queryToken = to.query && to.query.token != null && String(to.query.token).trim() !== ""
  //   ? String(to.query.token).trim()
  //   : "";
  //
  // if (queryToken) {
  //   setToken(queryToken);
  //   // 成功回跳拿到 token，说明统一登录链路已完成，清除强制标记
  //   try {
  //     if (typeof window !== "undefined") {
  //       window.sessionStorage.removeItem(FORCE_SSO_LOGIN_KEY);
  //     }
  //   } catch {
  //     // ignore
  //   }
  //   persistViteBootIdOnly();
  //   const restQuery = { ...to.query };
  //   delete restQuery.token;
  //   const isGatewayCallback =
  //     to.path === "/callback" || to.path.replace(/\/$/, "") === "/callback";
  //   const targetPath = isGatewayCallback ? SSO_POST_LOGIN_PATH : to.path;
  //   next({
  //     path: targetPath,
  //     query: restQuery,
  //     hash: to.hash,
  //     replace: true,
  //   });
  //   return;
  // }
  //
  // // 若用户点了“退出登录”，即使本地还有残留 token/或别处写回，也强制先走统一登录链路
  // try {
  //   if (typeof window !== "undefined" && window.sessionStorage.getItem(FORCE_SSO_LOGIN_KEY) === "1") {
  //     removeToken();
  //     const targetUrl = `${SSO_GATEWAY_ORIGIN}/api/v2${to.fullPath || "/"}`;
  //     window.location.replace(targetUrl);
  //     next(false);
  //     return;
  //   }
  // } catch {
  //   // ignore
  // }

  // 外网/线上版本：不因重启清登录态；仅开发环境需要此逻辑
  // clearTokenIfNewDevBoot();
  if (import.meta.env.DEV) {
    clearTokenIfNewDevBoot();
  }

  // 启用站内登录页：无 token 时统一进入 /login（不做外部重定向）
  // 退出登录后：无论当前 getToken() 返回什么，都强制先去 /login，直到再次登录清除此标记
  let forceLoginActive = false;
  try {
    if (typeof window !== "undefined" && window.localStorage.getItem(FORCE_LOGIN_KEY) === "1") {
      forceLoginActive = true;
      if (to.path !== "/login") {
        next({ path: "/login", replace: true });
        return;
      }
    }
  } catch {
    // ignore
  }

  const isAuthed = hasStoredAuthToken();

  // 已登录：不应停留在 /login（首页应为 /ZMOverView）
  // 说明：force_login=1 时表示用户主动退出，仍允许进入 /login；否则一律跳回业务首页
  if (isAuthed && to.path === "/login" && !forceLoginActive) {
    const redirect = (to.query && to.query.redirect) ? String(to.query.redirect) : "";
    next({ path: redirect || "/ZMOverView", replace: true });
    return;
  }

  if (!isAuthed && to.path !== "/login") {
    // 防止误入 /callback 空白页
    next({ path: "/login", replace: true });
    return;
  }

  if (to.meta.title) {
    if (to.meta.dynamicTitle) {
      console.log('to', to);
      const storageKey = to.meta.titleStorageKey || "curTabName";
      // 新开页签时 sessionStorage 不共享，优先用 query 带过来的 title/name
      const queryTitle = (to.query && (to.query.title || to.query.name)) ? String(to.query.title || to.query.name) : "";
      if (!to.meta.noTitle) {
        document.title = queryTitle || window.sessionStorage.getItem(storageKey) || to.meta.title;
      }
    } else {
      document.title = to.meta.title

    }
  }
  next();
});

/**
 * 在其它标签页/窗口退出登录时，本页立即跳转登录页（不依赖用户再点一次路由）。
 * 1）storage：监听同源其它文档对 `force_login` 的写入
 * 2）BroadcastChannel：与登出时的 `broadcastAuthLogout()` 配对，减少仅依赖 storage 的时序问题
 */
function installCrossTabLogoutRedirect() {
  if (typeof window === "undefined") {
    return;
  }

  const redirectToLoginAfterRemoteLogout = () => {
    try {
      window.localStorage.setItem(FORCE_LOGIN_KEY, "1");
    } catch {
      // ignore
    }
    try {
      removeToken();
      window.localStorage.removeItem("auth_token");
      window.sessionStorage.removeItem("auth_token");
    } catch {
      // ignore
    }
    try {
      if (router.currentRoute.value.path !== "/login") {
        router.replace({ path: "/login", replace: true }).catch(() => {});
      }
    } catch {
      // ignore
    }
  };

  window.addEventListener("storage", (e) => {
    if (e.key !== FORCE_LOGIN_KEY || e.newValue !== "1") {
      return;
    }
    redirectToLoginAfterRemoteLogout();
  });

  try {
    if (typeof BroadcastChannel !== "undefined") {
      const authBroadcast = new BroadcastChannel(AUTH_LOGOUT_CHANNEL);
      authBroadcast.addEventListener("message", (ev) => {
        if (ev?.data?.type === "force_logout") {
          redirectToLoginAfterRemoteLogout();
        }
      });
    }
  } catch {
    // ignore
  }
}

installCrossTabLogoutRedirect();

export default router;
