import type { ColumnCondition, RowCondition } from '../types'

export interface ConditionEntry<TCondition> {
  condition: TCondition
  indexInGroup: number
}

export type ColumnConditionSpan =
  | { condition: ColumnCondition; colspan: number }
  | { gap: true; colspan: number }

export type RowConditionSpan =
  | { condition: RowCondition; rowspan: number; startRow: number }
  | { gap: true; rowspan: number; startRow: number }

export function createColumnConditionMap(
  conditions: ColumnCondition[],
): Map<number, ConditionEntry<ColumnCondition>> {
  const map = new Map<number, ConditionEntry<ColumnCondition>>()
  for (const condition of conditions) {
    condition.cols.forEach((col, indexInGroup) => {
      map.set(col, { condition, indexInGroup })
    })
  }
  return map
}

export function createRowConditionMap(
  conditions: RowCondition[],
): Map<string, ConditionEntry<RowCondition>> {
  const map = new Map<string, ConditionEntry<RowCondition>>()
  for (const condition of conditions) {
    condition.rows.forEach((row, indexInGroup) => {
      map.set(row, { condition, indexInGroup })
    })
  }
  return map
}

export function createColumnConditionSpans(
  cols: number[],
  conditionMap: ReadonlyMap<number, ConditionEntry<ColumnCondition>>,
): ColumnConditionSpan[] {
  const spans: ColumnConditionSpan[] = []
  let index = 0

  while (index < cols.length) {
    const entry = conditionMap.get(cols[index])
    if (entry?.indexInGroup === 0) {
      spans.push({ condition: entry.condition, colspan: entry.condition.cols.length })
      index += entry.condition.cols.length
      continue
    }

    let gapCount = 0
    while (index + gapCount < cols.length && !conditionMap.has(cols[index + gapCount])) {
      gapCount++
    }
    spans.push({ gap: true, colspan: gapCount || 1 })
    index += gapCount || 1
  }

  return spans
}

export function createRowConditionSpans(
  rows: string[],
  conditionMap: ReadonlyMap<string, ConditionEntry<RowCondition>>,
): RowConditionSpan[] {
  const spans: RowConditionSpan[] = []
  let index = 0

  while (index < rows.length) {
    const entry = conditionMap.get(rows[index])
    if (entry?.indexInGroup === 0) {
      spans.push({ condition: entry.condition, rowspan: entry.condition.rows.length, startRow: index })
      index += entry.condition.rows.length
      continue
    }

    let gapCount = 0
    while (index + gapCount < rows.length && !conditionMap.has(rows[index + gapCount])) {
      gapCount++
    }
    spans.push({ gap: true, rowspan: gapCount || 1, startRow: index })
    index += gapCount || 1
  }

  return spans
}

export function createRowConditionSpanByRow(
  spans: RowConditionSpan[],
): Map<number, RowConditionSpan> {
  const map = new Map<number, RowConditionSpan>()
  for (const span of spans) {
    map.set(span.startRow, span)
  }
  return map
}