/**
 * SIE File Parser
 *
 * Parses SIE (Standard Import Export) files, the Swedish standard format
 * for accounting data exchange. Supports SIE1-SIE4 formats.
 *
 * SIE4 is the most complete format with full transaction history.
 * SIE1 contains only year-end balances.
 *
 * Reference: https://sie.se/format/
 */

import type {
  SIEType,
  SIEEncoding,
  SIEHeader,
  SIEAccount,
  SIEBalance,
  SIEVoucher,
  SIETransactionLine,
  ParsedSIEFile,
  ParseIssue,
  ParseIssueSeverity,
  ValidationResult,
} from './types'

// CP437 to UTF-8 mapping for Swedish characters
// CP437 was the standard encoding for DOS/early Windows
const CP437_MAP: Record<number, string> = {
  0x8e: 'Ä',  // Ä
  0x8f: 'Å',  // Å
  0x99: 'Ö',  // Ö
  0x84: 'ä',  // ä
  0x86: 'å',  // å
  0x94: 'ö',  // ö
  0x81: 'ü',  // ü
  0x9a: 'Ü',  // Ü
  0x92: 'Æ',  // Æ (not common but in CP437)
  0x91: 'æ',  // æ
  0x9d: 'Ø',  // Ø (Norwegian)
  0x9b: 'ø',  // ø
}

/**
 * Detect the encoding of a SIE file by looking for Swedish characters
 */
export function detectEncoding(buffer: ArrayBuffer): SIEEncoding {
  const bytes = new Uint8Array(buffer)

  // Check for UTF-8 BOM
  if (bytes[0] === 0xef && bytes[1] === 0xbb && bytes[2] === 0xbf) {
    return 'utf8'
  }

  // Look for CP437 Swedish characters in first 1000 bytes
  const sampleSize = Math.min(bytes.length, 1000)
  let cp437Count = 0
  let utf8Count = 0

  for (let i = 0; i < sampleSize; i++) {
    const byte = bytes[i]

    // Check for CP437 Swedish characters
    if (CP437_MAP[byte]) {
      cp437Count++
    }

    // Check for UTF-8 multi-byte sequences for Swedish chars
    // Ä = C3 84, Å = C3 85, Ö = C3 96, ä = C3 A4, å = C3 A5, ö = C3 B6
    if (byte === 0xc3 && i + 1 < sampleSize) {
      const nextByte = bytes[i + 1]
      if ([0x84, 0x85, 0x96, 0xa4, 0xa5, 0xb6].includes(nextByte)) {
        utf8Count++
      }
    }
  }

  return utf8Count > cp437Count ? 'utf8' : 'cp437'
}

/**
 * Decode a buffer to string using the specified encoding
 */
export function decodeBuffer(buffer: ArrayBuffer, encoding: SIEEncoding): string {
  if (encoding === 'utf8') {
    const decoder = new TextDecoder('utf-8')
    return decoder.decode(buffer)
  }

  // CP437 decoding
  const bytes = new Uint8Array(buffer)
  let result = ''

  for (let i = 0; i < bytes.length; i++) {
    const byte = bytes[i]

    if (CP437_MAP[byte]) {
      result += CP437_MAP[byte]
    } else if (byte < 128) {
      result += String.fromCharCode(byte)
    } else {
      // For other high bytes, try to preserve as-is
      result += String.fromCharCode(byte)
    }
  }

  return result
}

/**
 * Parse a date from SIE format (YYYYMMDD)
 */
function parseSIEDate(dateStr: string): Date | null {
  if (!dateStr || dateStr.length !== 8) {
    return null
  }

  const year = parseInt(dateStr.substring(0, 4), 10)
  const month = parseInt(dateStr.substring(4, 6), 10) - 1
  const day = parseInt(dateStr.substring(6, 8), 10)

  if (isNaN(year) || isNaN(month) || isNaN(day)) {
    return null
  }

  return new Date(year, month, day)
}

/**
 * Parse a quoted string field from SIE
 * Handles: "value" or value
 */
function parseStringField(field: string): string {
  if (!field) return ''

  // Remove surrounding quotes if present
  if (field.startsWith('"') && field.endsWith('"')) {
    return field.slice(1, -1).replace(/\\"/g, '"')
  }

  return field
}

/**
 * Parse a numeric field from SIE
 */
function parseNumberField(field: string): number {
  if (!field) return 0
  // SIE uses dot as decimal separator
  return parseFloat(field.replace(',', '.')) || 0
}

/**
 * Split a SIE line into fields, respecting quoted strings and braced object lists
 */
function splitSIELine(line: string): string[] {
  const fields: string[] = []
  let current = ''
  let inQuotes = false
  let braceDepth = 0
  let escaped = false

  for (let i = 0; i < line.length; i++) {
    const char = line[i]

    if (escaped) {
      current += char
      escaped = false
      continue
    }

    if (char === '\\') {
      escaped = true
      current += char
      continue
    }

    if (char === '"' && braceDepth === 0) {
      inQuotes = !inQuotes
      current += char
      continue
    }

    // Track brace depth for object lists like {1 "ProjectA"}
    if (char === '{' && !inQuotes) {
      braceDepth++
      current += char
      continue
    }

    if (char === '}' && !inQuotes) {
      braceDepth = Math.max(0, braceDepth - 1)
      current += char
      continue
    }

    if (char === ' ' && !inQuotes && braceDepth === 0) {
      if (current) {
        fields.push(current)
        current = ''
      }
      continue
    }

    current += char
  }

  if (current) {
    fields.push(current)
  }

  return fields
}

/**
 * Add an issue to the issues list
 */
function addIssue(
  issues: ParseIssue[],
  severity: ParseIssueSeverity,
  line: number,
  message: string,
  tag?: string
): void {
  issues.push({ severity, line, message, tag })
}

/**
 * Parse a SIE file content string
 */
export function parseSIEFile(content: string): ParsedSIEFile {
  const lines = content.split(/\r?\n/)
  const issues: ParseIssue[] = []

  // Initialize header with defaults
  const header: SIEHeader = {
    sieType: 4,
    program: null,
    programVersion: null,
    generatedDate: null,
    format: null,
    companyName: null,
    orgNumber: null,
    address: null,
    fiscalYears: [],
    currency: 'SEK',
  }

  const accounts: SIEAccount[] = []
  const openingBalances: SIEBalance[] = []
  const closingBalances: SIEBalance[] = []
  const resultBalances: SIEBalance[] = []
  const vouchers: SIEVoucher[] = []

  // Track current voucher being parsed (inside #VER { ... })
  let currentVoucher: SIEVoucher | null = null

  for (let i = 0; i < lines.length; i++) {
    const lineNum = i + 1
    const line = lines[i].trim()

    // Skip empty lines
    if (!line) continue

    // Handle voucher block end
    if (line === '}') {
      if (currentVoucher) {
        // Validate voucher balance
        const total = currentVoucher.lines.reduce((sum, l) => sum + l.amount, 0)
        if (Math.abs(total) > 0.01) {
          addIssue(
            issues,
            'error',
            lineNum,
            `Voucher ${currentVoucher.series}${currentVoucher.number} is not balanced (diff: ${total.toFixed(2)})`,
            'VER'
          )
        }
        vouchers.push(currentVoucher)
        currentVoucher = null
      }
      continue
    }

    // Handle voucher block start
    if (line === '{') {
      continue
    }

    // Skip lines that don't start with #
    if (!line.startsWith('#')) {
      continue
    }

    // Parse the tag and fields
    const fields = splitSIELine(line)
    const tag = fields[0].substring(1).toUpperCase()

    try {
      switch (tag) {
        case 'FLAGGA':
          // Flag for file handling - ignore
          break

        case 'FORMAT':
          header.format = parseStringField(fields[1])
          break

        case 'SIETYP':
          header.sieType = parseInt(fields[1], 10) as SIEType
          if (![1, 2, 3, 4].includes(header.sieType)) {
            addIssue(issues, 'warning', lineNum, `Unknown SIE type: ${fields[1]}`, tag)
            header.sieType = 4
          }
          break

        case 'PROGRAM':
          header.program = parseStringField(fields[1])
          header.programVersion = parseStringField(fields[2])
          break

        case 'GEN':
          if (fields[1]) {
            header.generatedDate = parseSIEDate(fields[1])
          }
          break

        case 'ORGNR':
          header.orgNumber = parseStringField(fields[1])
          break

        case 'FNAMN':
          header.companyName = parseStringField(fields[1])
          break

        case 'ADRESS':
          header.address = [fields[1], fields[2], fields[3], fields[4]]
            .filter(Boolean)
            .map(parseStringField)
            .join(', ')
          break

        case 'VALUTA':
          header.currency = parseStringField(fields[1]) || 'SEK'
          break

        case 'RAR': {
          // #RAR yearIndex start end
          const yearIndex = parseInt(fields[1], 10)
          const start = parseSIEDate(fields[2])
          const end = parseSIEDate(fields[3])

          if (start && end) {
            header.fiscalYears.push({ yearIndex, start, end })
          } else {
            addIssue(issues, 'warning', lineNum, 'Invalid fiscal year dates', tag)
          }
          break
        }

        case 'KONTO': {
          // #KONTO number "name"
          const number = fields[1]
          const name = parseStringField(fields[2])

          if (number && name) {
            accounts.push({ number, name })
          } else {
            addIssue(issues, 'warning', lineNum, 'Invalid account definition', tag)
          }
          break
        }

        case 'SRU': {
          // #SRU accountNumber sruCode
          const accountNum = fields[1]
          const sruCode = fields[2]
          const account = accounts.find((a) => a.number === accountNum)
          if (account) {
            account.sruCode = sruCode
          }
          break
        }

        case 'KTYP': {
          // #KTYP accountNumber type
          const accountNum = fields[1]
          const accountType = fields[2]
          const account = accounts.find((a) => a.number === accountNum)
          if (account) {
            account.accountType = accountType
          }
          break
        }

        case 'IB': {
          // #IB yearIndex accountNumber amount [quantity]
          const yearIndex = parseInt(fields[1], 10)
          const account = fields[2]
          const amount = parseNumberField(fields[3])
          const quantity = fields[4] ? parseNumberField(fields[4]) : undefined

          if (account) {
            openingBalances.push({ yearIndex, account, amount, quantity })
          }
          break
        }

        case 'UB': {
          // #UB yearIndex accountNumber amount [quantity]
          const yearIndex = parseInt(fields[1], 10)
          const account = fields[2]
          const amount = parseNumberField(fields[3])
          const quantity = fields[4] ? parseNumberField(fields[4]) : undefined

          if (account) {
            closingBalances.push({ yearIndex, account, amount, quantity })
          }
          break
        }

        case 'RES': {
          // #RES yearIndex accountNumber amount [quantity]
          const yearIndex = parseInt(fields[1], 10)
          const account = fields[2]
          const amount = parseNumberField(fields[3])
          const quantity = fields[4] ? parseNumberField(fields[4]) : undefined

          if (account) {
            resultBalances.push({ yearIndex, account, amount, quantity })
          }
          break
        }

        case 'VER': {
          // #VER series number date "description" [regdate] [signature]
          const series = parseStringField(fields[1])
          const number = parseInt(fields[2], 10)
          const date = parseSIEDate(fields[3])
          const description = parseStringField(fields[4])

          if (series && !isNaN(number) && date) {
            currentVoucher = {
              series,
              number,
              date,
              description: description || '',
              lines: [],
            }

            // Optional registration date and signature
            if (fields[5]) {
              currentVoucher.registrationDate = parseSIEDate(fields[5]) || undefined
            }
            if (fields[6]) {
              currentVoucher.signature = parseStringField(fields[6])
            }
          } else {
            addIssue(issues, 'error', lineNum, 'Invalid voucher definition', tag)
          }
          break
        }

        case 'TRANS': {
          // #TRANS accountNumber {objectList} amount [date] [description] [quantity] [signature]
          if (!currentVoucher) {
            addIssue(issues, 'error', lineNum, 'TRANS outside of VER block', tag)
            break
          }

          // Parse account and skip object list (in braces)
          let fieldIndex = 1
          const account = fields[fieldIndex++]

          // Skip object list if present (now a single field thanks to brace-aware splitting)
          if (fields[fieldIndex]?.startsWith('{')) {
            fieldIndex++
          }

          const amount = parseNumberField(fields[fieldIndex++])

          const transLine: SIETransactionLine = {
            account,
            amount,
          }

          // Optional fields
          if (fields[fieldIndex]) {
            transLine.date = parseSIEDate(fields[fieldIndex++]) || undefined
          }
          if (fields[fieldIndex]) {
            transLine.description = parseStringField(fields[fieldIndex++])
          }
          if (fields[fieldIndex]) {
            transLine.quantity = parseNumberField(fields[fieldIndex++])
          }
          if (fields[fieldIndex]) {
            transLine.signature = parseStringField(fields[fieldIndex++])
          }

          currentVoucher.lines.push(transLine)
          break
        }

        case 'RTRANS':
        case 'BTRANS':
          // BTRANS = Balance transactions (preliminary/carried-forward balances)
          // RTRANS = Reversed/corrected transactions
          // These are supplementary lines and should NOT be included in balance validation
          // or imported as regular transaction lines. Skip them.
          break

        default:
          // Unknown tag - add info issue for notable ones
          if (!['KSUMMA', 'BKOD', 'TAXAR', 'OMFATTN', 'KPTYP', 'DIM', 'OBJEKT', 'OIB', 'OUB', 'PBUDGET', 'PSALDO'].includes(tag)) {
            addIssue(issues, 'info', lineNum, `Unknown tag: #${tag}`, tag)
          }
      }
    } catch (error) {
      addIssue(
        issues,
        'error',
        lineNum,
        `Error parsing ${tag}: ${error instanceof Error ? error.message : 'Unknown error'}`,
        tag
      )
    }
  }

  // Calculate statistics
  const currentFiscalYear = header.fiscalYears.find((fy) => fy.yearIndex === 0)
  const totalTransactionLines = vouchers.reduce((sum, v) => sum + v.lines.length, 0)

  return {
    header,
    accounts,
    openingBalances,
    closingBalances,
    resultBalances,
    vouchers,
    issues,
    stats: {
      totalAccounts: accounts.length,
      totalVouchers: vouchers.length,
      totalTransactionLines,
      fiscalYearStart: currentFiscalYear?.start || null,
      fiscalYearEnd: currentFiscalYear?.end || null,
    },
  }
}

/**
 * Validate a parsed SIE file
 */
export function validateSIEFile(parsed: ParsedSIEFile): ValidationResult {
  const errors: string[] = []
  const warnings: string[] = []

  // Check for SIE type
  if (!parsed.header.sieType) {
    errors.push('Missing SIE type (#SIETYP)')
  }

  // Check for company info
  if (!parsed.header.companyName) {
    warnings.push('No company name found (#FNAMN)')
  }

  // Check for fiscal year
  if (parsed.header.fiscalYears.length === 0) {
    errors.push('No fiscal year defined (#RAR)')
  }

  // Check for accounts
  if (parsed.accounts.length === 0) {
    warnings.push('No accounts found (#KONTO)')
  }

  // Check for unbalanced vouchers
  for (const voucher of parsed.vouchers) {
    const total = voucher.lines.reduce((sum, l) => sum + l.amount, 0)
    if (Math.abs(total) > 0.01) {
      errors.push(
        `Voucher ${voucher.series}${voucher.number} on ${voucher.date.toISOString().split('T')[0]} is not balanced (diff: ${total.toFixed(2)})`
      )
    }
  }

  // Check for accounts referenced but not defined
  const definedAccounts = new Set(parsed.accounts.map((a) => a.number))
  const referencedAccounts = new Set<string>()

  for (const balance of [...parsed.openingBalances, ...parsed.closingBalances, ...parsed.resultBalances]) {
    referencedAccounts.add(balance.account)
  }

  for (const voucher of parsed.vouchers) {
    for (const line of voucher.lines) {
      referencedAccounts.add(line.account)
    }
  }

  for (const account of referencedAccounts) {
    if (!definedAccounts.has(account)) {
      warnings.push(`Account ${account} referenced but not defined in #KONTO`)
    }
  }

  // Check opening balance is balanced (for balance sheet accounts)
  const ibTotal = parsed.openingBalances
    .filter((b) => b.yearIndex === 0)
    .reduce((sum, b) => sum + b.amount, 0)

  if (Math.abs(ibTotal) > 0.01) {
    warnings.push(`Opening balances not balanced (diff: ${ibTotal.toFixed(2)})`)
  }

  // Add parse issues as errors/warnings
  for (const issue of parsed.issues) {
    if (issue.severity === 'error') {
      errors.push(`Line ${issue.line}: ${issue.message}`)
    } else if (issue.severity === 'warning') {
      warnings.push(`Line ${issue.line}: ${issue.message}`)
    }
  }

  return {
    valid: errors.length === 0,
    errors,
    warnings,
  }
}

/**
 * Calculate a hash of the file content for duplicate detection
 */
export async function calculateFileHash(content: string): Promise<string> {
  const encoder = new TextEncoder()
  const data = encoder.encode(content)
  const hashBuffer = await crypto.subtle.digest('SHA-256', data)
  const hashArray = Array.from(new Uint8Array(hashBuffer))
  return hashArray.map((b) => b.toString(16).padStart(2, '0')).join('')
}