import { describe, expect, it } from 'vitest'
import { compareBySortOrder, groupSessionsInDisplayOrder } from '../../src/utils/sessionGroups'
import type { Session } from '../../src/stores/sessionStore'

function session(id: string, sortOrder?: number, group?: string): Session {
  return {
    id,
    name: id,
    host: `${id}.example.com`,
    port: 22,
    username: 'root',
    authType: 'key',
    ...(sortOrder !== undefined ? { sortOrder } : {}),
    ...(group !== undefined ? { group } : {}),
  }
}

describe('compareBySortOrder', () => {
  it('sorts explicit sortOrder ascending', () => {
    const rows = [{ sortOrder: 2 }, { sortOrder: 0 }, { sortOrder: 1 }]
    expect([...rows].sort(compareBySortOrder).map((r) => r.sortOrder)).toEqual([0, 1, 2])
  })

  it('keeps rows without sortOrder after ordered rows', () => {
    const rows = [{ sortOrder: undefined }, { sortOrder: 0 }, {}, { sortOrder: 1 }]
    const sorted = [...rows].sort(compareBySortOrder)
    expect(sorted.map((r) => r.sortOrder ?? null)).toEqual([0, 1, null, null])
  })
})

describe('groupSessionsInDisplayOrder', () => {
  it('filters one group and orders by manual order with legacy rows last', () => {
    const sessions = [
      session('legacy-a'),
      session('ordered-b', 1, 'prod'),
      session('ordered-a', 0, 'prod'),
      session('legacy-b'),
      session('other', 0, 'staging'),
    ]
    expect(groupSessionsInDisplayOrder(sessions, 'prod').map((s) => s.id)).toEqual(['ordered-a', 'ordered-b'])
    expect(groupSessionsInDisplayOrder(sessions, 'default').map((s) => s.id)).toEqual(['legacy-a', 'legacy-b'])
  })

  it('preserves storage order among legacy rows (stable sort)', () => {
    const sessions = [session('first'), session('second'), session('third')]
    expect(groupSessionsInDisplayOrder(sessions, 'default').map((s) => s.id)).toEqual(['first', 'second', 'third'])
  })

  it('rewriting 0..n-1 makes the manual order authoritative', () => {
    const sessions = [session('a'), session('b'), session('c')]
    const reordered = ['c', 'a', 'b']
    const rewritten = reordered.map((id, index) => ({
      ...sessions.find((s) => s.id === id)!,
      sortOrder: index,
    }))
    expect(rewritten.sort(compareBySortOrder).map((s) => s.id)).toEqual(['c', 'a', 'b'])
  })
})