Kanban/src/utils/today.spec.ts

import { describe, expect, it } from 'vitest'

import type { Task } from '@/types/task'

import { buildTodayBuckets, countTodayTasks, sortByUrgency } from './today'

const TODAY = '2026-10-18'

function makeTask(overrides: Partial<Task> = {}): Task {
  return {
    id: 'task-1',
    title: '任务',
    description: '',
    status: 'todo',
    priority: 2,
    tags: [],
    dueDate: null,
    startDate: null,
    sortOrder: 1024,
    createdAt: '2026-10-01T00:00:00.000Z',
    updatedAt: '2026-10-01T00:00:00.000Z',
    completedAt: null,
    archivedAt: null,
    deletedAt: null,
    ...overrides,
  }
}

function ids(tasks: readonly Task[]): string[] {
  return tasks.map((task) => task.id)
}

describe('buildTodayBuckets 分组', () => {
  it('逾期任务进入 overdue', () => {
    const task = makeTask({ id: 'a', dueDate: '2026-10-17' })
    expect(ids(buildTodayBuckets([task], TODAY).overdue)).toEqual(['a'])
  })

  it('今天到期的进入 dueToday', () => {
    const task = makeTask({ id: 'a', dueDate: TODAY })
    expect(ids(buildTodayBuckets([task], TODAY).dueToday)).toEqual(['a'])
  })

  it('进行中且无更紧急截止日期的进入 inProgress', () => {
    const task = makeTask({ id: 'a', status: 'doing' })
    expect(ids(buildTodayBuckets([task], TODAY).inProgress)).toEqual(['a'])
  })

  it('未开始且没有截止日期的任务进入 pending 组', () => {
    const task = makeTask({ id: 'a', status: 'todo', dueDate: null })
    const buckets = buildTodayBuckets([task], TODAY)

    expect(ids(buckets.pending)).toEqual(['a'])
    expect(countTodayTasks(buckets)).toBe(1)
  })

  it('未来截止但未开始的任务进入 pending 组', () => {
    const task = makeTask({ id: 'a', status: 'todo', dueDate: '2026-12-01' })
    expect(ids(buildTodayBuckets([task], TODAY).pending)).toEqual(['a'])
  })

  it('所有未完成且未归档的任务都会出现在某个分组里', () => {
    const tasks = [
      makeTask({ id: 'overdue', dueDate: '2026-10-01' }),
      makeTask({ id: 'today', dueDate: TODAY }),
      makeTask({ id: 'doing', status: 'doing' }),
      makeTask({ id: 'todo-future', status: 'todo', dueDate: '2026-12-01' }),
      makeTask({ id: 'todo-none', status: 'todo', dueDate: null }),
    ]

    const buckets = buildTodayBuckets(tasks, TODAY)
    const all = [
      ...buckets.overdue,
      ...buckets.dueToday,
      ...buckets.inProgress,
      ...buckets.pending,
    ]

    // 按字典序：today 排在 todo-* 之前
    expect(all.map((task) => task.id).sort()).toEqual([
      'doing',
      'overdue',
      'today',
      'todo-future',
      'todo-none',
    ])
  })

  it('已完成任务不出现', () => {
    const task = makeTask({ id: 'a', status: 'done', dueDate: '2026-10-01', completedAt: null })
    expect(countTodayTasks(buildTodayBuckets([task], TODAY))).toBe(0)
  })

  it('已归档任务不出现', () => {
    const task = makeTask({ id: 'a', dueDate: '2026-10-01', archivedAt: '2026-10-05T00:00:00.000Z' })
    expect(countTodayTasks(buildTodayBuckets([task], TODAY))).toBe(0)
  })

  it('每个任务只归属一组：逾期优先于今天到期，今天到期优先于进行中', () => {
    const overdue = makeTask({ id: 'overdue', status: 'doing', dueDate: '2026-10-01' })
    const dueToday = makeTask({ id: 'dueToday', status: 'doing', dueDate: TODAY })
    const doing = makeTask({ id: 'doing', status: 'doing' })

    const buckets = buildTodayBuckets([overdue, dueToday, doing], TODAY)

    expect(ids(buckets.overdue)).toEqual(['overdue'])
    expect(ids(buckets.dueToday)).toEqual(['dueToday'])
    expect(ids(buckets.inProgress)).toEqual(['doing'])
    expect(countTodayTasks(buckets)).toBe(3)
  })
})

describe('sortByUrgency', () => {
  it('优先级高的排前面', () => {
    const low = makeTask({ id: 'low', priority: 1 })
    const high = makeTask({ id: 'high', priority: 3 })
    const medium = makeTask({ id: 'medium', priority: 2 })

    expect(ids(sortByUrgency([low, high, medium]))).toEqual(['high', 'medium', 'low'])
  })

  it('同优先级下截止日期早的排前面', () => {
    const later = makeTask({ id: 'later', priority: 2, dueDate: '2026-10-20' })
    const earlier = makeTask({ id: 'earlier', priority: 2, dueDate: '2026-10-10' })

    expect(ids(sortByUrgency([later, earlier]))).toEqual(['earlier', 'later'])
  })

  it('没有截止日期的排在有截止日期的后面', () => {
    const none = makeTask({ id: 'none', priority: 2, dueDate: null })
    const dated = makeTask({ id: 'dated', priority: 2, dueDate: '2026-12-31' })

    expect(ids(sortByUrgency([none, dated]))).toEqual(['dated', 'none'])
  })

  it('条件完全相同时按 sortOrder 稳定排序', () => {
    const second = makeTask({ id: 'second', priority: 2, dueDate: TODAY, sortOrder: 2048 })
    const first = makeTask({ id: 'first', priority: 2, dueDate: TODAY, sortOrder: 1024 })

    expect(ids(sortByUrgency([second, first]))).toEqual(['first', 'second'])
  })

  it('不修改入参', () => {
    const tasks = [makeTask({ id: 'a', priority: 1 }), makeTask({ id: 'b', priority: 3 })]
    sortByUrgency(tasks)
    expect(ids(tasks)).toEqual(['a', 'b'])
  })
})

describe('buildTodayBuckets 排序', () => {
  it('各组内部按紧急度排序', () => {
    const low = makeTask({ id: 'low', dueDate: '2026-10-01', priority: 1 })
    const high = makeTask({ id: 'high', dueDate: '2026-10-02', priority: 3 })

    expect(ids(buildTodayBuckets([low, high], TODAY).overdue)).toEqual(['high', 'low'])
  })
})

describe('countTodayTasks', () => {
  it('统计三组之和', () => {
    const tasks = [
      makeTask({ id: 'a', dueDate: '2026-10-01' }),
      makeTask({ id: 'b', dueDate: TODAY }),
      makeTask({ id: 'c', status: 'doing' }),
    ]
    expect(countTodayTasks(buildTodayBuckets(tasks, TODAY))).toBe(3)
  })

  it('空列表为 0', () => {
    expect(countTodayTasks(buildTodayBuckets([], TODAY))).toBe(0)
  })
})