/**
 * 俱乐部战斗工具函数
 */

/**
 * 获取最近的周六日期
 * 如果今天是周六，返回今天的日期；否则返回上周六的日期
 * @returns {string} 格式化的日期字符串 YYYY/MM/DD
 */
export function getLastSaturday() {
  const today = new Date()
  const dayOfWeek = today.getDay() // 0=周日, 1=周一, ..., 6=周六

  let daysToSubtract = 0
  if (dayOfWeek === 6) {
    // 今天是周六
    daysToSubtract = 0
  } else if (dayOfWeek === 0) {
    // 今天是周日，返回昨天（周六）
    daysToSubtract = 1
  } else {
    // 周一到周五，计算距离上周六的天数
    daysToSubtract = dayOfWeek + 1
  }

  const targetDate = new Date(today)
  targetDate.setDate(today.getDate() - daysToSubtract)

  const year = targetDate.getFullYear()
  const month = String(targetDate.getMonth() + 1).padStart(2, '0')
  const day = String(targetDate.getDate()).padStart(2, '0')

  return `${year}/${month}/${day}`
}

/**
 * 获取当月所有周六的日期以及最后一周的周日
 * @returns {Array} 包含格式化日期字符串的数组 YYYY/MM/DD
 */
export function getAllSaturdaysOfCurrentMonth() {
  const today = new Date()
  const year = today.getFullYear()
  const month = today.getMonth()
  
  const saturdays = []
  
  // 获取当月第一天
  const firstDay = new Date(year, month, 1)
  // 获取当月最后一天
  const lastDay = new Date(year, month + 1, 0)
  
  // 找到当月第一个周六
  let firstSaturday = new Date(firstDay)
  const firstDayOfWeek = firstDay.getDay() // 0=周日, 1=周一, ..., 6=周六
  
  if (firstDayOfWeek === 6) {
    // 第一天就是周六
    saturdays.push(formatDateToString(firstDay))
  } else {
    // 计算距离下一个周六的天数
    const daysUntilSaturday = 6 - firstDayOfWeek
    firstSaturday.setDate(firstDay.getDate() + daysUntilSaturday)
    
    // 添加所有周六
    let currentDate = new Date(firstSaturday)
    while (currentDate <= lastDay) {
      saturdays.push(formatDateToString(currentDate))
      currentDate.setDate(currentDate.getDate() + 7)
    }
  }
  
  // 添加最后一周的周日
  if (saturdays.length > 0) {
    // 获取最后一个周六的日期
    const lastSaturdayStr = saturdays[saturdays.length - 1]
    const lastSaturdayParts = lastSaturdayStr.split('/')
    const lastSaturday = new Date(
      parseInt(lastSaturdayParts[0]), 
      parseInt(lastSaturdayParts[1]) - 1, 
      parseInt(lastSaturdayParts[2])
    )
    
    // 计算下一个周日
    const nextSunday = new Date(lastSaturday)
    nextSunday.setDate(nextSunday.getDate() + 1)
    
    // 检查这个周日是否在当前月份内
    if (nextSunday.getMonth() === month && nextSunday <= lastDay) {
      saturdays.push(formatDateToString(nextSunday))
    }
  }
  
  return saturdays
}

/**
 * 格式化日期为字符串
 * @param {Date} date - 日期对象
 * @returns {string} 格式化的日期字符串 YYYY/MM/DD
 */
function formatDateToString(date) {
  const year = date.getFullYear()
  const month = String(date.getMonth() + 1).padStart(2, '0')
  const day = String(date.getDate()).padStart(2, '0')
  
  return `${year}/${month}/${day}`
}

/**
 * 格式化时间戳为可读时间
 * @param {number} timestamp - Unix时间戳（秒）
 * @returns {string} 格式化的时间字符串
 */
export function formatTimestamp(timestamp) {
  const date = new Date(timestamp * 1000)
  const month = String(date.getMonth() + 1).padStart(2, '0')
  const day = String(date.getDate()).padStart(2, '0')
  const hours = String(date.getHours()).padStart(2, '0')
  const minutes = String(date.getMinutes()).padStart(2, '0')
  const seconds = String(date.getSeconds()).padStart(2, '0')

  return `${month}-${day} ${hours}:${minutes}:${seconds}`
}

/**
 * 解析战斗结果标志
 * @param {number} newWinFlag - 战斗结果标志 (1=败, 2=胜)
 * @returns {string} "胜利" 或 "失败"
 */
export function parseBattleResult(newWinFlag) {
  return newWinFlag === 2 ? '胜利' : '失败'
}

/**
 * 解析攻击类型
 * @param {number} attackType - 攻击类型 (0=进攻, 1=防守)
 * @returns {string} "进攻" 或 "防守"
 */
export function parseAttackType(attackType) {
  return attackType === 0 ? '进攻' : '防守'
}

/**
 * 格式化成员战绩数据用于导出
 * @param {Array} roleDetailsList - 成员详情列表
 * @param {string} queryDate - 查询日期
 * @returns {string} 格式化的文本
 */
export function formatBattleRecordsForExport(roleDetailsList, queryDate) {
  if (!roleDetailsList || roleDetailsList.length === 0) {
    return '暂无战绩数据'
  }

  const lines = [
    `俱乐部盐场战绩 - ${queryDate}`,
    `参战人数: ${roleDetailsList.length}`,
    '─'.repeat(40),
    ''
  ]

  // 按击杀数排序
  const sortedMembers = [...roleDetailsList].sort((a, b) => (b.winCnt || 0) - (a.winCnt || 0))

  // 计算总计
  let totalKills = 0
  let totalDeaths = 0
  let totalSieges = 0

  sortedMembers.forEach((member, index) => {
    const { name, winCnt, loseCnt, buildingCnt } = member
    totalKills += winCnt || 0
    totalDeaths += loseCnt || 0
    totalSieges += buildingCnt || 0

    lines.push(
      `${index + 1}. ${name}  击杀${winCnt || 0}  死亡${loseCnt || 0}  攻城${buildingCnt || 0}`
    )
  })

  lines.push('')
  lines.push('─'.repeat(40))
  lines.push(`总计  击杀${totalKills}  死亡${totalDeaths}  攻城${totalSieges}`)
  lines.push('')
  lines.push(`导出时间: ${new Date().toLocaleString('zh-CN')}`)

  return lines.join('\n')
}

/**
 * 复制文本到剪贴板
 * @param {string} text - 要复制的文本
 * @returns {Promise<void>}
 */
export async function copyToClipboard(text) {
  if (navigator.clipboard && window.isSecureContext) {
    // 现代浏览器
    await navigator.clipboard.writeText(text)
  } else {
    // 降级方案
    const textArea = document.createElement('textarea')
    textArea.value = text
    textArea.style.position = 'fixed'
    textArea.style.left = '-999999px'
    textArea.style.top = '-999999px'
    document.body.appendChild(textArea)
    textArea.focus()
    textArea.select()

    try {
      document.execCommand('copy')
    } catch (err) {
      throw new Error('复制失败')
    } finally {
      textArea.remove()
    }
  }
}

/**
 * 导出战绩为 Excel 文件（包含总体情况和详细战斗记录两个sheet）
 * @param {Array} roleDetailsList - 成员详情列表
 * @param {string} queryDate - 查询日期（格式：YYYY/MM/DD）
 */
export function exportToExcel(roleDetailsList, queryDate) {
  if (!roleDetailsList || roleDetailsList.length === 0) {
    throw new Error('暂无战绩数据')
  }

  // 动态导入xlsx库
  import('xlsx').then((XLSX) => {
    // 创建工作簿
    const workbook = XLSX.utils.book_new()

    // ========== Sheet 1: 盐场总体情况 ==========
    // 按击杀数排序
    const sortedMembers = [...roleDetailsList].sort((a, b) => (b.winCnt || 0) - (a.winCnt || 0))

    // 计算总计
    let totalKills = 0
    let totalDeaths = 0
    let totalSieges = 0

    // 构建总体情况数据
    const overviewData = []
    
    // 标题行
    overviewData.push([`俱乐部盐场战绩 - ${queryDate}`])
    overviewData.push([`参战人数: ${roleDetailsList.length}`])
    overviewData.push([]) // 空行
    
    // 表头
    overviewData.push(['排名', '昵称', '击杀', '死亡', '攻城', 'KD'])

    // 数据行
    sortedMembers.forEach((member, index) => {
      const { name, winCnt, loseCnt, buildingCnt } = member
      const kills = winCnt || 0
      const deaths = loseCnt || 0
      const sieges = buildingCnt || 0
      const kd = deaths > 0 ? (kills / deaths).toFixed(2) : kills.toFixed(2)

      totalKills += kills
      totalDeaths += deaths
      totalSieges += sieges

      overviewData.push([index + 1, name, kills, deaths, sieges, kd])
    })

    // 空行
    overviewData.push([])
    
    // 总计行
    const totalKD = totalDeaths > 0 ? (totalKills / totalDeaths).toFixed(2) : totalKills.toFixed(2)
    overviewData.push(['总计', '', totalKills, totalDeaths, totalSieges, totalKD])
    
    // 空行和导出时间
    overviewData.push([])
    overviewData.push([`导出时间: ${new Date().toLocaleString('zh-CN')}`])

    // 创建Sheet1
    const worksheet1 = XLSX.utils.aoa_to_sheet(overviewData)
    
    // 设置列宽
    worksheet1['!cols'] = [
      { wch: 8 },  // 排名
      { wch: 20 }, // 昵称
      { wch: 10 }, // 击杀
      { wch: 10 }, // 死亡
      { wch: 10 }, // 攻城
      { wch: 10 }  // KD
    ]

    XLSX.utils.book_append_sheet(workbook, worksheet1, '盐场总体情况')

    // ========== Sheet 2: 盐场战斗情况 ==========
    // 收集所有战斗记录并按时间排序（从晚到早）
    const allBattles = []
    
    roleDetailsList.forEach(member => {
      const memberName = member.name || '未知'
      const targetRoleList = member.targetRoleList || []
      
      targetRoleList.forEach(battle => {
        allBattles.push({
          timestamp: battle.timestamp || 0,
          time: formatTimestamp(battle.timestamp || 0),
          attacker: battle.roleInfo?.name || '未知',
          defender: battle.targetRoleInfo?.name || '未知',
          attackType: parseAttackType(battle.attackType),
          result: parseBattleResult(battle.newWinFlag),
          memberName: memberName
        })
      })
    })

    // 按时间戳排序（从晚到早，即降序）
    allBattles.sort((a, b) => b.timestamp - a.timestamp)

    // 构建战斗情况数据
    const battleData = []
    
    // 标题行
    battleData.push([`盐场战斗详情 - ${queryDate}`])
    battleData.push([`总战斗次数: ${allBattles.length}`])
    battleData.push([]) // 空行
    
    // 表头
    battleData.push(['序号', '时间', '进攻方', '防守方', '战斗类型', '战斗结果'])

    // 数据行
    allBattles.forEach((battle, index) => {
      battleData.push([
        index + 1,
        battle.time,
        battle.attacker,
        battle.defender,
        battle.attackType,
        battle.result
      ])
    })

    // 空行和导出时间
    battleData.push([])
    battleData.push([`导出时间: ${new Date().toLocaleString('zh-CN')}`])

    // 创建Sheet2
    const worksheet2 = XLSX.utils.aoa_to_sheet(battleData)
    
    // 设置列宽
    worksheet2['!cols'] = [
      { wch: 8 },  // 序号
      { wch: 18 }, // 时间
      { wch: 15 }, // 进攻方
      { wch: 15 }, // 防守方
      { wch: 12 }, // 战斗类型
      { wch: 12 }  // 战斗结果
    ]

    XLSX.utils.book_append_sheet(workbook, worksheet2, '盐场战斗情况')

    // ========== 导出文件 ==========
    // 格式化日期为文件名：2025-10-11
    const fileDate = queryDate.replace(/\//g, '-')
    XLSX.writeFile(workbook, `军团战战绩-${fileDate}.xlsx`)
  }).catch((error) => {
    console.error('导出Excel失败:', error)
    throw new Error('导出Excel失败，请确保已安装xlsx库')
  })
}

/**
 * 加载图片（处理跨域）
 * @param {string} url - 图片URL
 * @returns {Promise<HTMLImageElement>}
 */
function loadImage(url) {
  return new Promise((resolve, reject) => {
    if (!url) {
      resolve(null)
      return
    }
    
    const img = new Image()
    img.crossOrigin = 'anonymous'
    
    img.onload = () => resolve(img)
    img.onerror = () => {
      console.warn('头像加载失败:', url)
      resolve(null) // 失败时返回null，而不是reject
    }
    
    // 尝试添加时间戳避免缓存问题
    img.src = url.includes('?') ? `${url}&_=${Date.now()}` : `${url}?_=${Date.now()}`
  })
}

/**
 * 绘制圆形头像
 * @param {CanvasRenderingContext2D} ctx - Canvas上下文
 * @param {HTMLImageElement} img - 图片对象
 * @param {number} x - X坐标（中心点）
 * @param {number} y - Y坐标（中心点）
 * @param {number} radius - 半径
 */
function drawCircleAvatar(ctx, img, x, y, radius) {
  if (!img) {
    // 如果没有图片，绘制默认头像（圆形背景+问号）
    ctx.save()
    ctx.beginPath()
    ctx.arc(x, y, radius, 0, Math.PI * 2)
    ctx.fillStyle = '#95a5a6'
    ctx.fill()
    ctx.fillStyle = '#ffffff'
    ctx.font = `${radius}px Arial`
    ctx.textAlign = 'center'
    ctx.textBaseline = 'middle'
    ctx.fillText('?', x, y)
    ctx.restore()
    return
  }
  
  ctx.save()
  // 创建圆形裁剪路径
  ctx.beginPath()
  ctx.arc(x, y, radius, 0, Math.PI * 2)
  ctx.closePath()
  ctx.clip()
  
  // 绘制图片
  ctx.drawImage(img, x - radius, y - radius, radius * 2, radius * 2)
  
  // 绘制边框
  ctx.restore()
  ctx.beginPath()
  ctx.arc(x, y, radius, 0, Math.PI * 2)
  ctx.strokeStyle = 'rgba(255, 255, 255, 0.3)'
  ctx.lineWidth = 2
  ctx.stroke()
}

/**
 * 导出战绩为图片
 * @param {Array} roleDetailsList - 成员详情列表
 * @param {string} queryDate - 查询日期
 * @param {string} clubName - 俱乐部名称
 * @returns {Promise<void>}
 */
export async function exportToImage(roleDetailsList, queryDate, clubName = '俱乐部') {
  if (!roleDetailsList || roleDetailsList.length === 0) {
    throw new Error('暂无战绩数据')
  }

  // 按击杀数排序
  const sortedMembers = [...roleDetailsList].sort((a, b) => (b.winCnt || 0) - (a.winCnt || 0))
  
  // 预加载所有头像
  console.log('🖼️ 开始加载头像...')
  const avatarPromises = sortedMembers.map(member => loadImage(member.headImg))
  const avatars = await Promise.all(avatarPromises)
  console.log('✅ 头像加载完成:', avatars.filter(Boolean).length, '/', sortedMembers.length)

  // 计算总计和特殊称号
  let totalKills = 0
  let totalDeaths = 0
  let totalSieges = 0
  
  // 击杀王（击杀最多）
  let killKing = null
  let maxKills = 0
  
  // 城墙毁灭者（攻城最多）
  let wallDestroyer = null
  let maxSieges = 0

  sortedMembers.forEach(member => {
    const kills = member.winCnt || 0
    const deaths = member.loseCnt || 0
    const sieges = member.buildingCnt || 0
    
    totalKills += kills
    totalDeaths += deaths
    totalSieges += sieges
    
    // 计算击杀王
    if (kills > maxKills) {
      maxKills = kills
      killKing = member
    }
    
    // 计算城墙毁灭者
    if (sieges > maxSieges) {
      maxSieges = sieges
      wallDestroyer = member
    }
    
    // 计算复活丹：死亡 <= 6 为 0，死亡 > 6 则为 (死亡数 - 6)
    member.revivePills = deaths <= 6 ? 0 : deaths - 6
  })

  // 创建 canvas
  const canvas = document.createElement('canvas')
  const ctx = canvas.getContext('2d')
  
  // 设置画布尺寸（增加顶部荣誉区高度）
  const width = 800
  const honorHeight = 100 // 荣誉称号区域
  const headerHeight = 180
  const rowHeight = 45
  const footerHeight = 100
  const height = honorHeight + headerHeight + (sortedMembers.length * rowHeight) + footerHeight
  
  canvas.width = width
  canvas.height = height

  // 背景渐变
  const gradient = ctx.createLinearGradient(0, 0, 0, height)
  gradient.addColorStop(0, '#2c3e50')
  gradient.addColorStop(1, '#34495e')
  ctx.fillStyle = gradient
  ctx.fillRect(0, 0, width, height)

  // 标题区域（最顶部）
  let currentY = 40
  ctx.fillStyle = '#ffffff'
  ctx.font = 'bold 32px "Microsoft YaHei", sans-serif'
  ctx.textAlign = 'center'
  ctx.fillText('战场周报', width / 2, currentY)

  // 日期
  currentY += 35
  ctx.font = '20px "Microsoft YaHei", sans-serif'
  ctx.fillStyle = '#bdc3c7'
  ctx.fillText(queryDate, width / 2, currentY)

  // 热场荣誉标题
  currentY += 40
  ctx.font = 'bold 24px "Microsoft YaHei", sans-serif'
  ctx.fillStyle = '#f39c12'
  ctx.fillText('热场荣誉', width / 2, currentY)

  // 荣誉称号区域（在标题下方）
  currentY += 20
  ctx.fillStyle = 'rgba(241, 196, 15, 0.15)'
  ctx.fillRect(20, currentY, width - 40, 75)
  
  ctx.font = 'bold 18px "Microsoft YaHei", sans-serif'
  ctx.textAlign = 'left'
  
  // 击杀王
  if (killKing) {
    ctx.fillStyle = '#f1c40f'
    ctx.fillText('🏆 击杀王', 40, currentY + 25)
    ctx.fillStyle = '#ffffff'
    ctx.font = '16px "Microsoft YaHei", sans-serif'
    ctx.fillText(`${killKing.name} (${maxKills}杀)`, 40, currentY + 50)
    ctx.font = 'bold 18px "Microsoft YaHei", sans-serif'
  }
  
  // 城墙毁灭者
  if (wallDestroyer) {
    ctx.fillStyle = '#e67e22'
    ctx.fillText('⚔️ 城墙毁灭者', 400, currentY + 25)
    ctx.fillStyle = '#ffffff'
    ctx.font = '16px "Microsoft YaHei", sans-serif'
    ctx.fillText(`${wallDestroyer.name} (${maxSieges}城)`, 400, currentY + 50)
  }

  // 表头
  const tableTop = honorHeight + headerHeight
  ctx.fillStyle = 'rgba(52, 73, 94, 0.9)'
  ctx.fillRect(0, tableTop, width, rowHeight)
  
  ctx.fillStyle = '#ffffff'
  ctx.font = 'bold 16px "Microsoft YaHei", sans-serif'
  ctx.textAlign = 'center'
  
  ctx.fillText('#', 40, tableTop + 28)
  ctx.fillText('昵称', 170, tableTop + 28) // 稍微右移，为头像留空间
  ctx.fillText('击杀', 300, tableTop + 28)
  ctx.fillText('死亡', 400, tableTop + 28)
  ctx.fillText('攻城', 500, tableTop + 28)
  ctx.fillText('复活丹', 610, tableTop + 28)
  ctx.fillText('KD', 720, tableTop + 28)

  // 数据行
  ctx.font = 'bold 15px "Microsoft YaHei", sans-serif'
  sortedMembers.forEach((member, index) => {
    const y = tableTop + rowHeight + (index * rowHeight)
    
    // 交替行背景
    if (index % 2 === 0) {
      ctx.fillStyle = 'rgba(44, 62, 80, 0.4)'
      ctx.fillRect(0, y, width, rowHeight)
    }

    // 前三名高亮
    if (index < 3) {
      const colors = ['#f1c40f', '#95a5a6', '#cd7f32']
      ctx.fillStyle = colors[index]
      ctx.fillRect(0, y, 8, rowHeight)
    }

    const kills = member.winCnt || 0
    const deaths = member.loseCnt || 0
    const sieges = member.buildingCnt || 0
    const revivePills = member.revivePills || 0
    const kd = deaths > 0 ? (kills / deaths).toFixed(2) : kills.toFixed(2)

    // 文字颜色
    ctx.fillStyle = '#ffffff'
    ctx.textAlign = 'center'
    
    ctx.fillText(String(index + 1), 40, y + 28)
    
    // 绘制头像（圆形，左侧）
    const avatarX = 100 // 头像X坐标（中心点）
    const avatarY = y + 22.5 // 头像Y坐标（行中心）
    const avatarRadius = 14 // 头像半径
    drawCircleAvatar(ctx, avatars[index], avatarX, avatarY, avatarRadius)
    
    // 昵称（限制长度，显示在头像右侧）
    ctx.textAlign = 'left'
    const name = member.name || '未知'
    const displayName = name.length > 7 ? name.substring(0, 7) + '...' : name
    ctx.fillText(displayName, 120, y + 28) // 头像右侧
    
    // 后续数据继续使用居中对齐
    ctx.textAlign = 'center'
    
    // 击杀数（亮绿色）
    ctx.fillStyle = '#2ecc71'
    ctx.fillText(String(kills), 300, y + 28)
    
    // 死亡数（亮红色）
    ctx.fillStyle = '#ff6b6b'
    ctx.fillText(String(deaths), 400, y + 28)
    
    // 攻城数（亮橙色）
    ctx.fillStyle = '#ffa502'
    ctx.fillText(String(sieges), 500, y + 28)
    
    // 复活丹（亮紫色）
    ctx.fillStyle = '#c56cf0'
    ctx.fillText(String(revivePills), 610, y + 28)
    
    // KD（白色）
    ctx.fillStyle = '#ffffff'
    ctx.fillText(kd, 720, y + 28)
  })

  // 总计行
  const totalY = tableTop + rowHeight + (sortedMembers.length * rowHeight)
  ctx.fillStyle = 'rgba(52, 152, 219, 0.6)'
  ctx.fillRect(0, totalY, width, rowHeight)
  
  // 计算总复活丹
  const totalRevivePills = sortedMembers.reduce((sum, m) => sum + (m.revivePills || 0), 0)
  
  ctx.fillStyle = '#ffffff'
  ctx.font = 'bold 17px "Microsoft YaHei", sans-serif'
  ctx.fillText(`总计: ${sortedMembers.length}人`, 110, totalY + 28)
  
  // 击杀总数（亮绿色）
  ctx.fillStyle = '#2ecc71'
  ctx.fillText(String(totalKills), 300, totalY + 28)
  
  // 死亡总数（亮红色）
  ctx.fillStyle = '#ff6b6b'
  ctx.fillText(String(totalDeaths), 400, totalY + 28)
  
  // 攻城总数（亮橙色）
  ctx.fillStyle = '#ffa502'
  ctx.fillText(String(totalSieges), 500, totalY + 28)
  
  // 复活丹总数（亮紫色）
  ctx.fillStyle = '#c56cf0'
  ctx.fillText(String(totalRevivePills), 610, totalY + 28)
  
  // 总KD（白色）
  ctx.fillStyle = '#ffffff'
  const totalKD = totalDeaths > 0 ? (totalKills / totalDeaths).toFixed(2) : totalKills.toFixed(2)
  ctx.fillText(totalKD, 720, totalY + 28)

  // 页脚
  const footerY = totalY + rowHeight + 30
  ctx.fillStyle = '#bdc3c7'
  ctx.font = '14px "Microsoft YaHei", sans-serif'
  ctx.textAlign = 'center'
  ctx.fillText(`导出时间: ${new Date().toLocaleString('zh-CN')}`, width / 2, footerY)

  // 转换为图片并下载
  return new Promise((resolve, reject) => {
    canvas.toBlob((blob) => {
      if (!blob) {
        reject(new Error('生成图片失败'))
        return
      }

      const link = document.createElement('a')
      const url = URL.createObjectURL(blob)
      const fileDate = queryDate.replace(/\//g, '-')
      
      link.href = url
      link.download = `军团战战绩-${fileDate}.png`
      link.style.display = 'none'
      
      document.body.appendChild(link)
      link.click()
      document.body.removeChild(link)
      URL.revokeObjectURL(url)
      
      resolve()
    }, 'image/png')
  })
}
