import type { Article } from './types'

export type Sequence = {
  parent: Article
  siblings: Article[]
  position: number
  previous: Article | null
  next: Article | null
}

export function sequenceOf(article: Article): Sequence | null {
  const parent = article.parent
  if (!parent?.route.sequence) return null

  const siblings = parent.children
  const position = siblings.indexOf(article)
  if (position === -1 || siblings.length < 2) return null

  return {
    parent,
    siblings,
    position,
    previous: siblings[position - 1] ?? null,
    next: siblings[position + 1] ?? null,
  }
}

export function trailOf(article: Article): Article[] {
  const trail: Article[] = []
  for (let node: Article | null = article; node; node = node.parent) trail.unshift(node)
  return trail
}

export type ContextGroup = {
  heading: Article | null
  entries: Article[]
}

export function contextOf(article: Article | null, roots: Article[]): ContextGroup[] {
  if (!article) return [{ heading: null, entries: roots }]

  const { parent } = article
  const siblings = (parent ? parent.children : roots).filter((entry) => entry !== article)

  const groups: ContextGroup[] = [
    { heading: parent?.parent ?? null, entries: parent?.listed ? [parent] : [] },
    { heading: parent, entries: siblings },
    { heading: article, entries: article.children },
  ]

  return groups.filter((group) => group.entries.length > 0)
}