import { test } from 'node:test'
import assert from 'node:assert/strict'
import {
  isJointTeam,
  jointTeamLabel,
  normalizeTeamShares,
  shareText,
  shareWeightOf,
  splitSharePoints,
  teamSharePayload,
} from '../jointTeams'
import type { EntryTeamShare } from '../types'

/**
 * 联队的展示与拆分口径（devdocs/19）。要钉住的是：
 *   1. **普通报名一字不变**：没有 teamShares（老服务端）/ 只有一条时，收口成主单位独占 100%，
 *      拼出来的名字就是主单位名，界面上与升级前完全一样；
 *   2. 份额是**相对权重**：1+1 是 50/50，2+1 是 67/33（不是 200/100）；
 *   3. 积分平均拆、接受 .5：15 分给两家就是 7.5 + 7.5，且 2:1 这种除不尽的权重
 *      两份之和必须**逐位等于**总分（末位取余数，不许出现 9.999999999999998）。
 */

function share(over: Partial<EntryTeamShare> & Pick<EntryTeamShare, 'teamId'>): EntryTeamShare {
  return { weight: 1, ...over }
}

test('没有 teamShares（老服务端）时按主单位独占 100%', () => {
  const shares = normalizeTeamShares(undefined, {
    teamId: 3,
    weight: 1,
    teamCode: 'A',
    teamName: '第一分公司',
  })
  assert.equal(shares.length, 1)
  assert.deepEqual(shares[0], {
    teamId: 3,
    teamCode: 'A',
    teamName: '第一分公司',
    weight: 1,
    percent: 100,
    medal: true,
  })
  assert.equal(isJointTeam(shares), false, '单单位不是联队')
})

test('份额整组为空且没有主单位时返回空数组，不造 0 号单位', () => {
  assert.deepEqual(normalizeTeamShares([], null), [])
  assert.deepEqual(normalizeTeamShares([], { teamId: 0, weight: 1 }), [])
})

test('1+1 均分：各 50%，联队名把两个单位名都写全', () => {
  const shares = normalizeTeamShares([
    share({ teamId: 1, teamCode: 'A', teamName: '第一分公司' }),
    share({ teamId: 2, teamCode: 'B', teamName: '第二分公司' }),
  ])
  assert.equal(isJointTeam(shares), true)
  assert.deepEqual(
    shares.map((item) => item.percent),
    [50, 50],
  )
  assert.equal(jointTeamLabel(shares), '第一分公司+第二分公司联队')
  assert.equal(shareText(shares[0] as (typeof shares)[number]), '第一分公司 50%')
})

test('2+1 是相对权重：67% 与 33%（不是 200% / 100%）', () => {
  const shares = normalizeTeamShares([
    share({ teamId: 1, weight: 2, teamCode: 'A', teamName: '第一分公司' }),
    share({ teamId: 2, weight: 1, teamCode: 'B', teamName: '第二分公司' }),
  ])
  assert.deepEqual(
    shares.map((item) => item.percent),
    [67, 33],
  )
  // 非均分时把权重也写出来，现场一眼看得出「为什么不是一半一半」。
  assert.equal(shareText(shares[0] as (typeof shares)[number]), '第一分公司 67%（权重 2）')
})

test('权重缺省 / 0 / 负数一律按 1（均分），不产生 NaN%', () => {
  assert.equal(shareWeightOf(undefined), 1)
  assert.equal(shareWeightOf(0), 1)
  assert.equal(shareWeightOf(-3), 1)
  assert.equal(shareWeightOf(Number.NaN), 1)
  const shares = normalizeTeamShares([
    { teamId: 1, weight: 0, teamName: '甲' },
    { teamId: 2, weight: Number.NaN, teamName: '乙' },
  ])
  assert.deepEqual(
    shares.map((item) => item.percent),
    [50, 50],
  )
})

test('奖牌缺省 true；只有显式 false 才是「这枚牌不记给它」', () => {
  const shares = normalizeTeamShares([
    share({ teamId: 1, teamName: '甲' }),
    share({ teamId: 2, teamName: '乙', medal: false }),
  ])
  assert.equal(shares[0]?.medal, true)
  assert.equal(shares[1]?.medal, false)
})

test('名字缺失时退回单位编码，再退回「单位 id」，不留空白格', () => {
  const shares = normalizeTeamShares([
    share({ teamId: 1, teamCode: 'A' }),
    share({ teamId: 2 }),
  ])
  assert.equal(jointTeamLabel(shares), 'A+单位 2联队')
})

test('脏数据（非法 teamId / 重复单位）在读取侧丢掉，界面不列两遍', () => {
  const shares = normalizeTeamShares([
    share({ teamId: 1, teamName: '甲' }),
    share({ teamId: 1, teamName: '甲的重复行' }),
    share({ teamId: 0, teamName: '零号' }),
  ])
  assert.equal(shares.length, 1)
  assert.equal(shares[0]?.teamName, '甲')
})

test('积分按份额拆：15 分给两家是 7.5 + 7.5（接受 .5）', () => {
  const split = splitSharePoints(15, [{ weight: 1 }, { weight: 1 }])
  assert.deepEqual(split, [7.5, 7.5])
})

test('除不尽的权重：各份之和逐位等于总分，不出现浮点零头', () => {
  const total = 15
  const split = splitSharePoints(total, [{ weight: 2 }, { weight: 1 }])
  assert.equal(split[0]! + split[1]!, total, '两份之和必须正好等于总分')
  assert.equal(split[1], 15 - split[0]!)
  assert.equal(split[0], 10)
  assert.equal(split[1], 5)
  // 三单位 1:1:1 同样要闭合。
  const three = splitSharePoints(15, [{ weight: 1 }, { weight: 1 }, { weight: 1 }])
  assert.equal(
    three.reduce((sum, part) => sum + part, 0),
    15,
  )
})

test('单条份额（普通报名）拆出来就是原分，与升级前逐位相同', () => {
  assert.deepEqual(splitSharePoints(15, [{ weight: 1 }]), [15])
  assert.deepEqual(splitSharePoints(7.5, [{ weight: 2 }]), [7.5])
})

test('写侧载荷只带 teamId / weight（+ 显式关闭的 medal），不带读侧展示字段', () => {
  const payload = teamSharePayload([
    { teamId: 1, weight: 2, teamCode: 'A', teamName: '第一分公司' },
    { teamId: 2, weight: 1, medal: false, teamCode: 'B', teamName: '第二分公司' },
  ])
  assert.deepEqual(payload, [
    { teamId: 1, weight: 2 },
    { teamId: 2, weight: 1, medal: false },
  ])
})