import request from '@/utils/request'

export interface DemandType {
  id: number
  name: string
  unitScore: number
  estimatedHours: number
  description?: string
  sortOrder?: number
  isEnabled?: number
  allowedDeptIds?: string  // 可接单部门ID列表（逗号分隔）
  departmentIds?: number[]  // 前端使用的部门ID数组
}

export interface Brand {
  id: number
  name: string
  brandCode?: string
  logoUrl?: string
  description?: string
  sortOrder?: number
  isEnabled?: number
}

export interface Platform {
  id: number
  name: string
  platformCode?: string
  iconUrl?: string
  description?: string
  sortOrder?: number
  isEnabled?: number
}

export interface Category {
  id: number
  parentId?: number
  name: string
  categoryCode?: string
  level?: number
  isLeaf?: number
  path?: string
  description?: string
  sortOrder?: number
  isEnabled?: number
}

export interface TeamScorePool {
  id: number
  deptId: number
  deptName: string
  balance: number
  totalRecharge?: number
  totalConsume?: number
  totalEarn?: number
  limitEnabled?: number
  limitPeriod?: string
  periodLimit?: number
  periodUsed?: number
  periodStartTime?: string
  alertThreshold?: number
}

export interface TaskSubType {
  id: number
  parentId?: number | null    // 父级ID，null表示顶级分类
  name: string
  code: string
  description?: string
  unitPrice?: number          // 单价分值
  sortOrder?: number
  isEnabled?: number
  checkInventory?: number     // 是否检查库存
  allowedDeptIds?: string     // 可接单部门ID（逗号分隔），只在父级分类设置
  departmentIds?: number[]    // 前端使用的部门ID数组
  createTime?: string
  updateTime?: string
  children?: TaskSubType[]    // 子分类列表
}

/**
 * 获取所有需求类型（包括禁用的，用于管理页面）
 */
export const getAllDemandTypes = () => {
  return request.get<any>('/config/demand-types')
}

/**
 * 获取所有启用的需求类型（用于下拉选择）
 */
export const getEnabledDemandTypes = () => {
  return request.get<any>('/config/demand-types/enabled')
}

/**
 * 获取所有品牌（包括禁用的，用于管理页面）
 */
export const getAllBrands = () => {
  return request.get<any>('/config/brands')
}

/**
 * 获取所有启用的品牌（用于下拉选择）
 */
export const getEnabledBrands = () => {
  return request.get<any>('/config/brands/enabled')
}

/**
 * 获取所有平台（包括禁用的，用于管理页面）
 */
export const getAllPlatforms = () => {
  return request.get<any>('/config/platforms')
}

/**
 * 获取所有启用的平台（用于下拉选择）
 */
export const getEnabledPlatforms = () => {
  return request.get<any>('/config/platforms/enabled')
}

/**
 * 获取所有叶子类目（包括禁用的，用于管理页面）
 */
export const getAllLeafCategories = () => {
  return request.get<any>('/config/categories/leaf')
}

/**
 * 获取所有启用的叶子类目（用于下拉选择）
 */
export const getEnabledLeafCategories = () => {
  return request.get<any>('/config/categories/leaf/enabled')
}

/**
 * 根据部门ID获取积分池
 */
export const getScorePoolByDeptId = (deptId: number) => {
  return request.get<any>(`/config/score-pool/dept/${deptId}`)
}

/**
 * 检查积分余额是否足够
 */
export const checkBalance = (deptId: number, score: number) => {
  return request.get<any>('/config/score-pool/check-balance', {
    params: { deptId, score }
  })
}

/**
 * 检查是否超过周期限制
 */
export const checkPeriodLimit = (deptId: number, score: number) => {
  return request.get<any>('/config/score-pool/check-limit', {
    params: { deptId, score }
  })
}

// ========== 需求类型 CRUD ==========

/**
 * 获取所有需求类型（别名）
 */
export const getDemandTypes = getAllDemandTypes

/**
 * 创建需求类型
 */
export const createDemandType = (data: Partial<DemandType>) => {
  return request.post<any>('/config/demand-types', data)
}

/**
 * 更新需求类型
 */
export const updateDemandType = (id: number, data: Partial<DemandType>) => {
  return request.put<any>(`/config/demand-types/${id}`, data)
}

/**
 * 删除需求类型
 */
export const deleteDemandType = (id: number) => {
  return request.delete<any>(`/config/demand-types/${id}`)
}

// ========== 品牌 CRUD ==========

/**
 * 获取所有品牌（别名）
 */
export const getBrands = getAllBrands

/**
 * 创建品牌
 */
export const createBrand = (data: Partial<Brand>) => {
  return request.post<any>('/config/brands', data)
}

/**
 * 更新品牌
 */
export const updateBrand = (id: number, data: Partial<Brand>) => {
  return request.put<any>(`/config/brands/${id}`, data)
}

/**
 * 删除品牌
 */
export const deleteBrand = (id: number) => {
  return request.delete<any>(`/config/brands/${id}`)
}

// ========== 平台 CRUD ==========

/**
 * 获取所有平台（别名）
 */
export const getPlatforms = getAllPlatforms

/**
 * 创建平台
 */
export const createPlatform = (data: Partial<Platform>) => {
  return request.post<any>('/config/platforms', data)
}

/**
 * 更新平台
 */
export const updatePlatform = (id: number, data: Partial<Platform>) => {
  return request.put<any>(`/config/platforms/${id}`, data)
}

/**
 * 删除平台
 */
export const deletePlatform = (id: number) => {
  return request.delete<any>(`/config/platforms/${id}`)
}

// ========== 类目 CRUD ==========

/**
 * 获取所有类目（包括非叶子节点）
 */
export const getCategories = () => {
  return request.get<any>('/config/categories')
}

/**
 * 创建类目
 */
export const createCategory = (data: Partial<Category>) => {
  return request.post<any>('/config/categories', data)
}

/**
 * 更新类目
 */
export const updateCategory = (id: number, data: Partial<Category>) => {
  return request.put<any>(`/config/categories/${id}`, data)
}

/**
 * 删除类目
 */
export const deleteCategory = (id: number) => {
  return request.delete<any>(`/config/categories/${id}`)
}

// ========== 任务子类型 CRUD ==========

/**
 * 获取所有任务子类型
 */
export const getAllTaskSubTypes = () => {
  return request.get<any>('/task-sub-types')
}

/**
 * 获取启用的任务子类型
 */
export const getEnabledTaskSubTypes = () => {
  return request.get<any>('/task-sub-types/enabled')
}

/**
 * 创建任务子类型
 */
export const createTaskSubType = (data: Partial<TaskSubType>) => {
  return request.post<any>('/task-sub-types', data)
}

/**
 * 更新任务子类型
 */
export const updateTaskSubType = (id: number, data: Partial<TaskSubType>) => {
  return request.put<any>(`/task-sub-types/${id}`, data)
}

/**
 * 删除任务子类型
 */
export const deleteTaskSubType = (id: number) => {
  return request.delete<any>(`/task-sub-types/${id}`)
}

/**
 * 切换任务子类型启用状态
 */
export const toggleTaskSubTypeEnabled = (id: number) => {
  return request.post<any>(`/task-sub-types/${id}/toggle-enabled`)
}

/**
 * 获取树形结构的任务子类型（父子层级）
 */
export const getTaskSubTypeTree = () => {
  return request.get<any>('/task-sub-types/tree')
}

/**
 * 获取启用的树形结构
 */
export const getEnabledTaskSubTypeTree = () => {
  return request.get<any>('/task-sub-types/tree/enabled')
}

/**
 * 获取父级分类列表（需求类型大分类）
 */
export const getTaskSubTypeParents = () => {
  return request.get<any>('/task-sub-types/parents')
}

/**
 * 获取指定父级下的子分类
 */
export const getTaskSubTypeChildren = (parentId: number) => {
  return request.get<any>(`/task-sub-types/children/${parentId}`)
}