/**
 * 模块 API 接口
 *
 * @module api/modules
 * @author czj
 * @date 2026-07-09
 */

import request from '@/utils/request'
import type { Module, ModuleListResponse, CreateModuleRequest, UpdateModuleRequest } from '@/types/module'

/**
 * 模块 API 服务
 */
export const moduleApi = {
  /**
   * 获取模块列表
   * @param module_type 模块类型筛选 standard/custom
   */
  async list(skip = 0, limit = 100, module_type?: string): Promise<ModuleListResponse> {
    const response = await request.get('/api/modules', {
      params: { skip, limit, module_type }
    })
    return response.data
  },

  /**
   * 获取单个模块详情
   */
  async get(id: string): Promise<Module> {
    const response = await request.get(`/api/modules/${id}`)
    return response.data
  },

  /**
   * 创建模块
   */
  async create(data: CreateModuleRequest): Promise<Module> {
    const response = await request.post('/api/modules', data)
    return response.data
  },

  /**
   * 更新模块
   */
  async update(id: string, data: UpdateModuleRequest): Promise<Module> {
    const response = await request.put(`/api/modules/${id}`, data)
    return response.data
  },

  /**
   * 删除模块
   */
  async delete(id: string): Promise<void> {
    await request.delete(`/api/modules/${id}`)
  },

  /**
   * 获取模块统计
   */
  async getStats(id: string): Promise<any> {
    const response = await request.get(`/api/modules/${id}/stats`)
    return response.data
  }
}

/**
 * 将扁平模块列表构建为树形结构
 *
 * 用于 el-tree-select 组件的数据源，将后端返回的扁平模块列表
 * 根据 parentId 字段构建为父子层级结构。
 *
 * @param items 扁平模块列表
 * @returns 树形结构数据
 *
 * @example
 * const tree = buildModuleTree(modules)
 * // tree: [{ id: '1', name: '预定2.0', children: [{ id: '2', name: '会议管理', children: [] }] }]
 */
export function buildModuleTree(items: Module[]): Module[] {
  const map = new Map<string, Module>()
  const roots: Module[] = []

  // 建立映射：先复制并初始化 children
  items.forEach(item => {
    map.set(item.id, { ...item, children: [] })
  })

  // 构建树：根据 parentId 归类到父模块的 children 中
  items.forEach(item => {
    const node = map.get(item.id)!
    if (item.parentId && map.has(item.parentId)) {
      const parent = map.get(item.parentId)!
      if (!parent.children) {
        parent.children = []
      }
      parent.children.push(node)
    } else {
      // 无父模块或父模块不存在，作为根节点
      roots.push(node)
    }
  })

  return roots
}