import { exportToExcel, readExcel } from '@sa/utils'
import { ref, watch } from 'vue'

export function useGroupManagement(props: any) {
  const groups = ref<Array<{ name: string, id: string, teams: Array<{ name: string }> }>>([])

  // 根据分组数量和队伍数量生成分组数据
  function generateGroups() {
    if (!props.config)
      return

    const { groupCount, teamCount } = props.config
    if (!groupCount || groupCount <= 0)
      return

    const oldGroups = groups.value

    groups.value = Array.from({ length: groupCount }).map((_, index) => {
      const i = index + 1
      const idStr = String(i).padStart(2, '0')
      const existingGroup = oldGroups[index]

      // 复用现有名称或生成默认名称
      const groupName = existingGroup ? existingGroup.name : `第${i}组`

      // 生成或复用队伍数据
      const teams = Array.from({ length: teamCount }).map((__, tIndex) => {
        const existingTeam = existingGroup?.teams?.[tIndex]
        return {
          name: existingTeam ? existingTeam.name : '',
        }
      })

      return {
        name: groupName,
        id: `G${idStr}`,
        teams,
      }
    })
  }

  watch(() => props.config, generateGroups, { deep: true, immediate: true })

  // 提交时候校验表单是否符合要求
  function validate() {
    // 简单校验：是否有分组
    if (groups.value.length === 0) {
      window.$message?.error('暂无参赛分组，请检查基础设置')
      return false
    }

    // 校验每个分组是否有队伍
    for (const group of groups.value) {
      if (group.teams.length === 0) {
        window.$message?.error(`分组 ${group.name} 暂无队伍，请检查`)
        return false
      }
    }

    // 校验每个分组队伍是否有名称
    for (const group of groups.value) {
      for (const team of group.teams) {
        if (!team.name.trim()) {
          window.$message?.error(`分组 ${group.name} 队伍 ${team.name} 暂无名称，请检查`)
          return false
        }
      }
    }

    // 校验分组队伍名称是否重复，并找出是第几组重复
    const nameMap = new Map<string, string[]>()
    let hasDuplicate = false

    groups.value.forEach((group, groupIndex) => {
      group.teams.forEach((team, teamIndex) => {
        const name = team.name.trim()
        if (!name)
          return // 跳过空名字，前面已经校验过空了

        if (nameMap.has(name)) {
          nameMap.get(name)?.push(`第${groupIndex + 1}组-队伍${teamIndex + 1}`)
          hasDuplicate = true
        }
        else {
          nameMap.set(name, [`第${groupIndex + 1}组-队伍${teamIndex + 1}`])
        }
      })
    })

    if (hasDuplicate) {
      const duplicates: string[] = []
      nameMap.forEach((locations, name) => {
        if (locations.length > 1) {
          duplicates.push(`队伍名 "${name}" 重复于: ${locations.join(', ')}`)
        }
      })

      // 显示前3条重复信息，避免弹窗过大
      const msg = duplicates.slice(0, 3).join('; ') + (duplicates.length > 3 ? ' 等...' : '')
      window.$message?.error(`发现重复队伍名称：${msg}`, { duration: 8000 })
      return false
    }

    return true
  }

  // 重置方法
  function reset() {
    // 清空现有数据，触发 generateGroups 重新生成默认数据
    groups.value = []
    generateGroups()
  }

  return {
    groups,
    validate,
    reset,
  }
}

/**
 * 下载 Excel 模板
 */
export function useExcelExport(props: any, groups: any) {
  function downloadTemplate() {
    if (!props.config)
      return

    // 1. 构建数据行（根据当前分组预填充分组名称）
    const data = groups.value.map((g: any) => {
      const row: any = {
        分组名称: g.name,
      }
      // 为队伍预留空位，或者如果已有数据也填充进去（方便用户修改）
      g.teams.forEach((t: any, i: number) => {
        row[`队伍${i + 1}名称`] = t.name
      })
      return row
    })

    exportToExcel(data, '参赛名单导入模板', '参赛名单')
  }

  return {
    downloadTemplate,
  }
}

export function useExcelImport(props: any, groups: any) {
  const fileInputRef = ref<HTMLInputElement | null>(null)

  /**
   * 触发文件选择
   */
  function handleImportClick() {
    fileInputRef.value?.click()
  }

  /**
   * 处理文件上传与解析
   */
  async function handleFileChange(event: Event) {
    const target = event.target as HTMLInputElement
    const file = target.files?.[0]
    if (!file)
      return

    // 重置 input value，允许重复选择同一文件
    target.value = ''

    try {
      const jsonData = await readExcel(file)

      // 校验表头：检查第一行数据是否包含预期的列名
      // 预期列名：分组名称, 队伍1名称, 队伍2名称...
      if (jsonData.length === 0) {
        window.$message?.warning('Excel 文件内容为空')
        return
      }

      const firstRow = jsonData[0] as any
      const expectedKeys = ['分组名称']
      if (props.config?.teamCount) {
        for (let i = 1; i <= props.config.teamCount; i++) {
          expectedKeys.push(`队伍${i}名称`)
        }
      }

      // 检查是否包含所有必要的列
      // 这里我们检查第一行是否有这些 key
      const hasValidHeader = expectedKeys.every(key => Object.prototype.hasOwnProperty.call(firstRow, key))

      if (!hasValidHeader) {
        window.$message?.error('Excel 模板格式错误，请下载最新模板并重新填写')
        return
      }

      const limit = props.config?.groupCount || 0
      let validData = jsonData

      // 校验条数上限
      if (validData.length > limit) {
        window.$message?.warning(`导入数据共 ${validData.length} 条，已截取前 ${limit} 条，超出部分将被忽略`, { duration: 4000 })
        validData = validData.slice(0, limit)
      }
      else {
        window.$message?.success(`成功解析 ${validData.length} 条数据`, { duration: 3000 })
      }

      // 重写校验逻辑，清晰化
      const finalData: any[] = []
      const processedGroupNames = new Set<string>()
      const processedTeamNames = new Set<string>()
      const duplicates: string[] = []

      validData.forEach((row: any, index) => {
        const newRow = { ...row }

        // 1. 校验分组名称
        const groupName = row['分组名称'] ? String(row['分组名称']).trim() : ''
        if (groupName) {
          if (processedGroupNames.has(groupName)) {
            duplicates.push(`第 ${index + 2} 行分组 "${groupName}" 重复，已跳过该行`)
            return // 分组名重复，跳过整行
          }
          processedGroupNames.add(groupName)
        }

        // 2. 校验队伍名称
        if (props.config?.teamCount) {
          for (let i = 1; i <= props.config.teamCount; i++) {
            const key = `队伍${i}名称`
            const teamName = row[key] ? String(row[key]).trim() : ''

            if (teamName) {
              if (processedTeamNames.has(teamName)) {
                duplicates.push(`第 ${index + 2} 行队伍 "${teamName}" 重复，已清空该项`)
                newRow[key] = '' // 剔除重复项
              }
              else {
                processedTeamNames.add(teamName)
              }
            }
          }
        }
        finalData.push(newRow)
      })

      if (duplicates.length > 0) {
        // 提示重复信息，限制显示条数避免弹窗过大
        const msg = `发现重复数据：\n${duplicates.slice(0, 5).join('\n')}${duplicates.length > 5 ? '\n...' : ''}`
        window.$message?.warning(msg, { duration: 5000 })
      }

      // 填充数据
      finalData.forEach((row: any, index) => {
        if (index >= groups.value.length)
          return

        const group = groups.value[index]

        // 分组名称
        if (row['分组名称']) {
          group.name = String(row['分组名称'])
        }

        // 队伍名称
        group.teams.forEach((team: any, tIndex: number) => {
          const key = `队伍${tIndex + 1}名称`
          if (row[key]) {
            team.name = String(row[key])
          }
        })
      })
    }
    catch (error) {
      console.error('Excel 解析失败:', error)
      window.$message?.error('Excel 解析失败，请检查文件格式')
    }
  }

  return {
    fileInputRef,
    handleImportClick,
    handleFileChange,
  }
}
