accounted/lib/reconciliation/actions.ts

import type { SupabaseClient } from '@supabase/supabase-js'
import { eventBus } from '@/lib/events/bus'
import { createLogger } from '@/lib/logger'
import {
  linkSkattekontoRow,
  setSkattekontoRowIgnored,
  SkattekontoLinkError,
  unlinkSkattekontoRow,
} from '@/lib/skatteverket/skattekonto-link'
import { manualLink, unlinkReconciliation } from './bank-reconciliation'
import { getSkattekontoReconciliationStatus } from './skattekonto-reconciliation'
import { parseAccountKey } from './schemas'

const log = createLogger('reconciliation/actions')

/**
 * Write actions of the account-keyed reconciliation surface. Every door (page
 * route, v1, MCP commit executor) calls these; none of them links on its own.
 *
 * Links never touch the ledger: they pair an outside row with an existing
 * verifikat, so they are allowed in locked periods and reversible by
 * unmatch. Bookings (residual postings) are a separate, later action.
 */

export interface ReconciliationPair {
  /** Outside rows: transaction ids (bank) or skattekonto_transaction ids. */
  external_ids: string[]
  journal_entry_ids: string[]
}

export type PairSkipCode =
  | 'UNSUPPORTED_PAIR_SHAPE'
  | 'ALREADY_LINKED'
  | 'ENTRY_NOT_FOUND'
  | 'ENTRY_REVERSED'
  | 'PAIR_NOT_CLOSED'
  | 'ROW_IGNORED'
  | 'NOT_FOUND'
  | 'LINK_RACE'
  | 'UNKNOWN'

export interface AppliedLink {
  external_id: string
  journal_entry_id: string
  via?: 'line' | 'entry_total'
}

export interface SkippedPair {
  pair: ReconciliationPair
  code: PairSkipCode
  message: string
}

export interface MatchPairsInput {
  pairs?: ReconciliationPair[]
  /** Use the persisted proposals (skattekonto) or potential matches (bank) as pairs. */
  use_proposals?: boolean
  /** Only with use_proposals: skip proposals below this confidence. */
  confidence_threshold?: number
}

export interface MatchPairsResult {
  dry_run: boolean
  applied: AppliedLink[]
  skipped: SkippedPair[]
  considered: number
}

function skipCodeFor(err: unknown): { code: PairSkipCode; message: string } {
  if (err instanceof SkattekontoLinkError) {
    const map: Record<string, PairSkipCode> = {
      TRANSACTION_NOT_FOUND: 'NOT_FOUND',
      ALREADY_BOOKED: 'ALREADY_LINKED',
      ROW_IGNORED: 'ROW_IGNORED',
      ENTRY_NOT_FOUND: 'ENTRY_NOT_FOUND',
      ENTRY_ALREADY_LINKED: 'ALREADY_LINKED',
      INVALID_CANDIDATE: 'PAIR_NOT_CLOSED',
      NOT_LINKED: 'UNKNOWN',
      LINK_RACE: 'LINK_RACE',
    }
    return { code: map[err.code] ?? 'UNKNOWN', message: err.message }
  }
  return { code: 'UNKNOWN', message: err instanceof Error ? err.message : String(err) }
}

async function proposalsAsPairs(
  supabase: SupabaseClient,
  companyId: string,
  accountKey: string,
  threshold: number,
): Promise<ReconciliationPair[]> {
  const parsed = parseAccountKey(accountKey)
  if (!parsed) return []
  if (parsed.kind === 'skattekonto') {
    const status = await getSkattekontoReconciliationStatus(supabase, companyId)
    if (!status) return []
    return status.items.proposed
      .filter((i) => i.proposal && i.proposal.confidence >= threshold)
      .map((i) => ({ external_ids: [i.item_id], journal_entry_ids: [i.proposal!.journal_entry_id] }))
  }
  if (parsed.kind === 'bank') {
    const { data } = await supabase
      .from('transactions')
      .select('id, potential_journal_entry_id, potential_match_confidence')
      .eq('company_id', companyId)
      .eq('cash_account_id', parsed.cashAccountId)
      .is('journal_entry_id', null)
      .eq('is_ignored', false)
      .not('potential_journal_entry_id', 'is', null)
    return ((data ?? []) as Array<{ id: string; potential_journal_entry_id: string; potential_match_confidence: number | string | null }>)
      .filter((r) => Number(r.potential_match_confidence ?? 0) >= threshold)
      .map((r) => ({ external_ids: [r.id], journal_entry_ids: [r.potential_journal_entry_id] }))
  }
  return []
}

/**
 * Link pairs on one account. Today each pair is one outside row and one
 * verifikat (the N:M worksheet selection arrives with the manual-match mode);
 * other shapes are reported as UNSUPPORTED_PAIR_SHAPE, never silently
 * reduced. Dry run validates shapes and resolves proposals without writing.
 * Partial success is first-class: `applied` and `skipped` together cover
 * every considered pair.
 */
export async function matchPairs(
  supabase: SupabaseClient,
  companyId: string,
  userId: string,
  accountKey: string,
  input: MatchPairsInput,
  options: { dryRun?: boolean } = {},
): Promise<MatchPairsResult | null> {
  const parsed = parseAccountKey(accountKey)
  if (!parsed || parsed.kind === 'manual') return null
  const dryRun = options.dryRun ?? false

  const pairs: ReconciliationPair[] = [...(input.pairs ?? [])]
  if (input.use_proposals) {
    pairs.push(
      ...(await proposalsAsPairs(supabase, companyId, accountKey, input.confidence_threshold ?? 0)),
    )
  }

  const applied: AppliedLink[] = []
  const skipped: SkippedPair[] = []

  for (const pair of pairs) {
    if (pair.external_ids.length !== 1 || pair.journal_entry_ids.length !== 1) {
      skipped.push({
        pair,
        code: 'UNSUPPORTED_PAIR_SHAPE',
        message: 'Ett par är en händelse och ett verifikat i den här versionen.',
      })
      continue
    }
    const [externalId] = pair.external_ids
    const [journalEntryId] = pair.journal_entry_ids

    if (dryRun) {
      applied.push({ external_id: externalId, journal_entry_id: journalEntryId })
      continue
    }

    try {
      if (parsed.kind === 'skattekonto') {
        const r = await linkSkattekontoRow(supabase, companyId, externalId, journalEntryId)
        applied.push({ external_id: externalId, journal_entry_id: journalEntryId, via: r.via })
      } else {
        const { data: account } = await supabase
          .from('cash_accounts')
          .select('ledger_account')
          .eq('company_id', companyId)
          .eq('id', parsed.cashAccountId)
          .maybeSingle<{ ledger_account: string }>()
        const r = await manualLink(
          supabase,
          companyId,
          externalId,
          journalEntryId,
          userId,
          account?.ledger_account ?? '1930',
        )
        if (!r.success) {
          skipped.push({ pair, code: 'PAIR_NOT_CLOSED', message: r.error ?? 'Kunde inte koppla' })
          continue
        }
        applied.push({ external_id: externalId, journal_entry_id: journalEntryId })
      }
      await eventBus.emit({
        type: 'reconciliation.matched',
        payload: {
          accountKey,
          externalId,
          journalEntryId,
          method: input.use_proposals ? 'proposal' : 'manual',
          userId,
          companyId,
        },
      })
    } catch (err) {
      const { code, message } = skipCodeFor(err)
      skipped.push({ pair, code, message })
    }
  }

  if (!dryRun && applied.length > 0) {
    log.info('reconciliation pairs linked', { companyId, accountKey, applied: applied.length, skipped: skipped.length })
  }

  return { dry_run: dryRun, applied, skipped, considered: pairs.length }
}

export interface UnmatchResult {
  external_id: string
  previous_journal_entry_id: string | null
}

/**
 * Remove one link. link id = the outside row's id (transaction or
 * skattekonto row), which is the one-link-per-row identity both kinds share.
 */
export async function unmatchLink(
  supabase: SupabaseClient,
  companyId: string,
  userId: string,
  accountKey: string,
  linkId: string,
): Promise<UnmatchResult | null> {
  const parsed = parseAccountKey(accountKey)
  if (!parsed || parsed.kind === 'manual') return null

  let previous: string | null = null
  if (parsed.kind === 'skattekonto') {
    const r = await unlinkSkattekontoRow(supabase, companyId, linkId)
    previous = r.previous_journal_entry_id
  } else {
    const { data: tx } = await supabase
      .from('transactions')
      .select('journal_entry_id')
      .eq('company_id', companyId)
      .eq('id', linkId)
      .maybeSingle<{ journal_entry_id: string | null }>()
    previous = tx?.journal_entry_id ?? null
    const r = await unlinkReconciliation(supabase, companyId, linkId, userId)
    if (!r.success) throw new Error(r.error ?? 'Kunde inte koppla bort')
  }
  await eventBus.emit({
    type: 'reconciliation.unmatched',
    payload: { accountKey, externalId: linkId, previousJournalEntryId: previous, userId, companyId },
  })
  return { external_id: linkId, previous_journal_entry_id: previous }
}

/**
 * Ignore / restore one outside row. Ignored rows leave the unmatched totals
 * and surface on the bridge's exclusion line (bank #1705 precedent).
 */
export async function setItemIgnored(
  supabase: SupabaseClient,
  companyId: string,
  accountKey: string,
  itemId: string,
  ignored: boolean,
): Promise<{ external_id: string; is_ignored: boolean } | null> {
  const parsed = parseAccountKey(accountKey)
  if (!parsed || parsed.kind === 'manual') return null
  if (parsed.kind === 'skattekonto') {
    const r = await setSkattekontoRowIgnored(supabase, companyId, itemId, ignored)
    return { external_id: r.skattekonto_transaction_id, is_ignored: r.is_ignored }
  }
  const { data: tx, error } = await supabase
    .from('transactions')
    .select('id, journal_entry_id, is_ignored')
    .eq('company_id', companyId)
    .eq('id', itemId)
    .maybeSingle<{ id: string; journal_entry_id: string | null; is_ignored: boolean | null }>()
  if (error) throw new Error(`Kunde inte hämta transaktionen: ${error.message}`)
  if (!tx) throw new SkattekontoLinkError('Transaktionen hittades inte.', 'TRANSACTION_NOT_FOUND')
  if (ignored && tx.journal_entry_id) {
    throw new SkattekontoLinkError('En bokförd transaktion kan inte ignoreras.', 'ALREADY_BOOKED')
  }
  if (Boolean(tx.is_ignored) !== ignored) {
    const { error: updateError } = await supabase
      .from('transactions')
      .update({ is_ignored: ignored })
      .eq('company_id', companyId)
      .eq('id', itemId)
    if (updateError) throw new Error(`Kunde inte uppdatera: ${updateError.message}`)
  }
  return { external_id: itemId, is_ignored: ignored }
}