const { test } = require('node:test')
const assert = require('node:assert/strict')
const fs = require('node:fs')
const vm = require('node:vm')
const vue = require('vue')
const ts = require('../../backend/node_modules/typescript')

const deferred = () => {
  let resolve
  const promise = new Promise(done => { resolve = done })
  return { promise, resolve }
}
const settle = () => new Promise(setImmediate)

function setup(api, apiBase = 'https://fedeo.example/backend') {
  const auth = vue.reactive({ activeTenant: '1', user: { is_admin: true } })
  const timers = new Map()
  let timerId = 0
  let mount
  let unmount
  const context = vm.createContext({
    require, exports: {}, URL,
    ref: vue.ref, computed: vue.computed, watch: vue.watch,
    useAuthStore: () => auth,
    useRuntimeConfig: () => ({ public: { apiBase } }),
    useFiles: () => ({}), useToast: () => ({ add() {} }),
    useNuxtApp: () => ({ $api: api }),
    window: { location: { origin: 'https://fedeo.example' } },
    onMounted: handler => { mount = handler },
    onBeforeUnmount: handler => { unmount = handler },
    setTimeout: handler => { timers.set(++timerId, handler); return timerId },
    clearTimeout: id => timers.delete(id),
  })
  const source = fs.readFileSync(`${__dirname}/../pages/organisation/dokumentenablage.vue`, 'utf8').match(/<script setup lang="ts">([\s\S]*?)<\/script>/)[1]
  vm.runInContext(ts.transpileModule(source, { compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2022, esModuleInterop: true } }).outputText, context)
  return { auth, timers, mount, close: () => unmount(), run: code => vm.runInContext(code, context) }
}

test('scanner setup preserves absolute and relative backend prefixes', async t => {
  for (const base of ['https://fedeo.example/backend/', '/backend']) {
    const ui = setup(async () => ({ documents: [], total: 0 }), base)
    t.after(ui.close)
    ui.mount()
    await settle()
    assert.equal(ui.run('scannerUrl.value'), 'https://fedeo.example/backend/scanner-inbox/')
  }
})

test('a slow response from the previous tenant cannot expose its documents', async t => {
  const previous = deferred()
  let calls = 0
  const ui = setup(() => ++calls === 1 ? previous.promise : Promise.resolve({ documents: [{ id: 'tenant-2' }], total: 1 }))
  t.after(ui.close)
  ui.mount()
  ui.auth.activeTenant = '2'
  await settle()
  previous.resolve({ documents: [{ id: 'tenant-1-secret' }], total: 1 })
  await settle()
  assert.equal(ui.run('documents.value[0].id'), 'tenant-2')
})

test('credential responses are discarded on tenant switches and passwords clear on closing', async t => {
  const pending = deferred()
  const ui = setup(url => url.endsWith('/credentials') ? pending.promise : Promise.resolve({ documents: [], total: 0, connection: null, path: '/scanner-inbox/' }))
  t.after(ui.close)
  ui.mount()
  await ui.run('openSetup()')
  const creation = ui.run('createCredentials()')
  ui.auth.activeTenant = '2'
  await settle()
  pending.resolve({ connection: { username: 'previous-tenant', password: 'never-display', active: true }, path: '/scanner-inbox/' })
  await creation
  assert.equal(ui.run('password.value'), '')
  assert.equal(ui.run('connection.value'), null)
  assert.equal(ui.run('setupOpen.value'), false)
  ui.run('setupOpen.value = true')
  await settle()
  ui.run('password.value = "shown-once"; setupOpen.value = false')
  await settle()
  assert.equal(ui.run('password.value'), '')
})

test('unmounting cancels polling and ignores in-flight responses', async () => {
  const pending = deferred()
  const ui = setup(() => pending.promise)
  ui.mount()
  ui.close()
  pending.resolve({ documents: [{ id: 'late' }], total: 1 })
  await settle()
  assert.equal(ui.run('documents.value.length'), 0)
  assert.equal(ui.timers.size, 0)
})

const filingOptions = {
  folders: [
    { id: 'parent', name: 'Buchhaltung', parent: null, standardFiletype: null, standardFiletypeIsOptional: true },
    { id: 'folder', name: 'Rechnungen', parent: 'parent', standardFiletype: 'invoice', standardFiletypeIsOptional: false },
  ],
  types: [{ id: 'invoice', name: 'Rechnung' }, { id: 'other', name: 'Sonstiges' }],
}

test('filing shows folder paths, requires a type and honours mandatory folder defaults', async t => {
  const ui = setup(async () => filingOptions)
  t.after(ui.close)
  await ui.run('openFiling({ id: "scan", name: "scan.pdf" })')
  assert.equal(ui.run('canFile.value'), false)
  assert.equal(ui.run('folderOptions.value.find(folder => folder.id === "folder").name'), 'Buchhaltung / Rechnungen')
  ui.run('filingFolder.value = "folder"')
  await settle()
  assert.equal(ui.run('filingType.value'), 'invoice')
  assert.equal(ui.run('fixedType.value'), true)
  assert.equal(ui.run('canFile.value'), true)
  ui.run('filingType.value = "other"')
  assert.equal(ui.run('canFile.value'), false)
  ui.run('filingFolder.value = "root"')
  await settle()
  assert.equal(ui.run('fixedType.value'), false)
  assert.equal(ui.run('canFile.value'), true)
})

test('successful filing sends folder and type, removes the entry and returns from an empty last page', async t => {
  const pendingSave = deferred()
  const requests = []
  const ui = setup((url, options) => {
    requests.push({ url, options })
    if (url.endsWith('/filing-options')) return Promise.resolve(filingOptions)
    if (url.endsWith('/file')) return pendingSave.promise
    return Promise.resolve({ documents: [{ id: 'remaining' }], total: 50 })
  })
  t.after(ui.close)
  ui.run('documents.value = [{ id: "scan", name: "scan.pdf" }]; total.value = 51; page.value = 2')
  await ui.run('openFiling(documents.value[0])')
  ui.run('filingType.value = "invoice"')
  const saving = ui.run('fileDocument()')
  await ui.run('fileDocument()')
  assert.equal(requests.filter(item => item.url.endsWith('/file')).length, 1)
  assert.equal(ui.run('documents.value.length'), 1, 'keeps the original until saving succeeds')
  pendingSave.resolve({ id: 'scan' })
  await saving
  const post = requests.find(item => item.url.endsWith('/file'))
  assert.equal(post.url, '/api/document-inbox/scan/file')
  assert.equal(post.options.body.folder, null)
  assert.equal(post.options.body.type, 'invoice')
  assert.equal(ui.run('filingOpen.value'), false)
  assert.equal(ui.run('page.value'), 1)
  assert.equal(requests.at(-1).options.query.offset, 0)
  assert.equal(ui.run('documents.value[0].id'), 'remaining')
})

test('filing failure preserves the document and selected values for retry', async t => {
  const ui = setup(async url => {
    if (url.endsWith('/file')) throw { data: { message: 'Ordner nicht verfügbar' } }
    return filingOptions
  })
  t.after(ui.close)
  ui.run('documents.value = [{ id: "scan", name: "scan.pdf" }]; total.value = 1')
  await ui.run('openFiling(documents.value[0])')
  ui.run('filingFolder.value = "folder"')
  await settle()
  await ui.run('fileDocument()')
  assert.equal(ui.run('filingError.value'), 'Ordner nicht verfügbar')
  assert.equal(ui.run('filingOpen.value'), true)
  assert.equal(ui.run('filingType.value'), 'invoice')
  assert.equal(ui.run('documents.value[0].id'), 'scan')
  assert.equal(ui.run('canFile.value'), true)
})

test('tenant switching discards pending folder options and filing responses', async t => {
  for (const stage of ['options', 'save']) {
    const pending = deferred()
    const ui = setup(url => {
      if (url.endsWith('/filing-options')) return stage === 'options' ? pending.promise : Promise.resolve(filingOptions)
      if (url.endsWith('/file')) return pending.promise
      return Promise.resolve({ documents: [{ id: 'tenant-2' }], total: 1 })
    })
    t.after(ui.close)
    let operation = ui.run('openFiling({ id: "scan", name: "scan.pdf" })')
    if (stage === 'save') {
      await operation
      ui.run('filingType.value = "invoice"')
      operation = ui.run('fileDocument()')
    }
    ui.auth.activeTenant = '2'
    await settle()
    pending.resolve(stage === 'options' ? filingOptions : { id: 'scan' })
    await operation
    assert.equal(ui.run('filingOpen.value'), false)
    assert.equal(ui.run('filingFolders.value.length'), 0)
    assert.equal(ui.run('filingTypes.value.length'), 0)
    assert.equal(ui.run('documents.value[0].id'), 'tenant-2')
  }
})