import type { LastLevelRouteKey } from '@elegant-router/types';
import { SYSTEM_SERVICE_PREFIX } from '@/constants/service';
import { request } from '../request';
import type { ServiceRequestResult } from './shared';

type BackendMenuRoute = Omit<Api.Route.MenuRoute, 'id' | 'children'> & {
  id: string | number;
  children?: BackendMenuRoute[];
};

interface BackendUserRouteDTO {
  routes?: BackendMenuRoute[] | null;
  home?: string | null;
}

let userRoutePromise: Promise<ServiceRequestResult<BackendUserRouteDTO>> | null = null;

export function clearUserRouteCache() {
  userRoutePromise = null;
}

function normalizeMenuRoute(route: BackendMenuRoute): Api.Route.MenuRoute {
  return {
    ...route,
    id: String(route.id),
    children: route.children?.map(child => normalizeMenuRoute(child))
  };
}

function normalizeUserRoute(data: BackendUserRouteDTO): Api.Route.UserRoute {
  return {
    routes: (data.routes ?? []).map(route => normalizeMenuRoute(route)),
    home: (data.home || 'system_user') as LastLevelRouteKey
  };
}

/** 获取常量路由 */
export function fetchGetConstantRoutes() {
  return request<Api.Route.MenuRoute[]>({ url: '/route/getConstantRoutes' });
}

/** 获取用户路由 */
export async function fetchGetUserRoutes(force = false): Promise<ServiceRequestResult<Api.Route.UserRoute>> {
  if (!userRoutePromise || force) {
    userRoutePromise = request<BackendUserRouteDTO>({
      url: `${SYSTEM_SERVICE_PREFIX}/auth/get-user-routes`
    }).then(result => result as ServiceRequestResult<BackendUserRouteDTO>);
  }

  const result = await userRoutePromise;

  if (result.error || !result.data) {
    userRoutePromise = null;
    return result as ServiceRequestResult<Api.Route.UserRoute>;
  }

  return {
    ...result,
    data: normalizeUserRoute(result.data)
  };
}

/**
 * 判断路由是否存在
 *
 * @param routeName 路由名称
 */
export async function fetchIsRouteExist(routeName: string): Promise<ServiceRequestResult<boolean>> {
  const result = await fetchGetUserRoutes();

  if (result.error || !result.data) {
    return {
      ...result,
      data: false
    } as unknown as ServiceRequestResult<boolean>;
  }

  const isExist = result.data.routes.some(route => recursiveIsRouteExist(route, routeName));

  return {
    ...result,
    data: isExist
  };
}

function recursiveIsRouteExist(route: Api.Route.MenuRoute, routeName: string): boolean {
  if (route.name === routeName) {
    return true;
  }

  return route.children?.some(child => recursiveIsRouteExist(child, routeName)) || false;
}