import { Injectable, NotFoundException } from '@nestjs/common';
import { PrismaService } from '../prisma/prisma.service';
import { CreateMenuDto } from './dto/create-menu.dto';
import { UpdateMenuDto } from './dto/update-menu.dto';
import { AuthService } from '../auth/auth.service';

@Injectable()
export class MenusService {
  constructor(
    private prisma: PrismaService,
    private authService: AuthService,
  ) {}

  async create(createMenuDto: CreateMenuDto) {
    return this.prisma.menu.create({
      data: createMenuDto,
    });
  }

  async findAll() {
    return this.prisma.menu.findMany({
      where: {
        parentId: null,
      },
      include: {
        children: {
          orderBy: {
            sort: 'asc',
          },
        },
      },
      orderBy: {
        sort: 'asc',
      },
    });
  }

  async findOne(id: number) {
    const menu = await this.prisma.menu.findUnique({
      where: { id },
      include: {
        children: true,
        parent: true,
      },
    });

    if (!menu) {
      throw new NotFoundException('菜单不存在');
    }

    return menu;
  }

  async update(id: number, updateMenuDto: UpdateMenuDto) {
    return this.prisma.menu.update({
      where: { id },
      data: updateMenuDto,
    });
  }

  async remove(id: number) {
    return this.prisma.menu.delete({
      where: { id },
    });
  }

  /**
   * 获取当前用户的菜单（根据权限过滤）
   * @param userId 用户ID
   * @param tenantId 租户ID
   * @returns 过滤后的菜单树
   */
  async findUserMenus(userId: number, tenantId: number) {
    // 获取用户角色，检查是否为超级管理员
    const userRoles = await this.authService.getUserRoles(userId);
    const isSuperAdmin = userRoles.includes('super_admin');

    // 获取用户的所有权限
    const userPermissions = await this.authService.getUserPermissions(userId);

    // 获取租户分配的菜单ID
    const tenantMenus = await this.prisma.tenantMenu.findMany({
      where: { tenantId },
    });
    const menuIds = tenantMenus.map((tm) => tm.menuId);

    if (menuIds.length === 0) {
      return [];
    }

    // 获取租户分配的所有菜单（包括父菜单）
    const allMenus = await this.prisma.menu.findMany({
      where: {
        OR: [
          { id: { in: menuIds } },
          { children: { some: { id: { in: menuIds } } } },
        ],
        validState: 1, // 只获取有效的菜单
      },
      orderBy: {
        sort: 'asc',
      },
    });

    // 构建树形结构
    const buildTree = (menus: any[], parentId: number | null = null): any[] => {
      return menus
        .filter((menu) => menu.parentId === parentId)
        .map((menu) => ({
          ...menu,
          children: buildTree(menus, menu.id),
        }));
    };

    // 先构建树
    const menuTree = buildTree(allMenus);

    // 过滤菜单：只有用户拥有菜单对应权限的菜单才会显示
    // 超级管理员跳过权限过滤
    const filterMenus = (menus: any[]): any[] => {
      return menus
        .map((menu) => {
          // 先递归处理子菜单
          let filteredChildren: any[] = [];
          if (menu.children && menu.children.length > 0) {
            filteredChildren = filterMenus(menu.children);
          }

          // 超级管理员：只要有path或有子菜单就显示
          if (isSuperAdmin) {
            const hasPath = menu.path && menu.path.trim() !== '';
            const hasChildren = filteredChildren.length > 0;
            if (!hasPath && !hasChildren) {
              return null;
            }
            const filtered = { ...menu };
            if (hasChildren) {
              filtered.children = filteredChildren;
            }
            return filtered;
          }

          // 检查菜单是否有权限要求
          const hasPermissionField =
            menu.permission && menu.permission.trim() !== '';

          // 如果菜单有权限要求，检查用户是否有该权限
          if (hasPermissionField) {
            if (!userPermissions.includes(menu.permission)) {
              // 用户没有该权限，但如果有可见的子菜单，保留父菜单
              if (filteredChildren.length > 0) {
                return { ...menu, children: filteredChildren };
              }
              return null; // 过滤掉
            }
          }

          // 如果菜单没有设置权限（父级目录），则根据子菜单是否有可见的来决定
          if (!hasPermissionField) {
            // 没有子菜单且没有权限配置，通常是不完整的配置，过滤掉
            if (filteredChildren.length === 0 && (!menu.path || menu.path.trim() === '')) {
              return null;
            }
            // 有子菜单，保留父菜单
            if (filteredChildren.length > 0) {
              return { ...menu, children: filteredChildren };
            }
            // 没有子菜单但有 path，说明是叶子节点，需要权限但没配置，过滤掉
            return null;
          }

          // 用户有权限，返回菜单
          const filtered = { ...menu };
          if (filteredChildren.length > 0) {
            filtered.children = filteredChildren;
          }
          return filtered;
        })
        .filter((menu) => menu !== null);
    };

    // 过滤菜单树
    const filteredTree = filterMenus(menuTree);

    // 移除没有子菜单且没有path的父菜单（空菜单）
    const removeEmptyParents = (menus: any[]): any[] => {
      return menus
        .map((menu) => {
          const hasChildren = menu.children && menu.children.length > 0;
          const hasPath = menu.path && menu.path.trim() !== '';

          // 如果有子菜单，递归处理
          if (hasChildren) {
            const processedChildren = removeEmptyParents(menu.children);
            // 如果处理后还有子菜单，保留此菜单
            if (processedChildren.length > 0) {
              return {
                ...menu,
                children: processedChildren,
              };
            }
            // 如果处理后没有子菜单，但有path，保留此菜单（作为叶子节点）
            if (hasPath) {
              return {
                ...menu,
                children: [],
              };
            }
            // 既没有子菜单也没有path，移除
            return null;
          }

          // 叶子节点，保留
          return menu;
        })
        .filter((menu) => menu !== null);
    };

    return removeEmptyParents(filteredTree);
  }
}
