const assert = require('node:assert/strict')
const fs = require('node:fs')
const path = require('node:path')
const test = require('node:test')
const { parse, compileScript, compileTemplate } = require('@vue/compiler-sfc')
const ts = require('typescript')
const vue = require('vue')

const filename = path.join(__dirname, '../src/views/consumer/prescription/components/PrescriptionOrderTimeDialog.vue')
const source = fs.readFileSync(filename, 'utf8')
const { descriptor, errors } = parse(source, { filename })
assert.deepEqual(errors, [])
const script = compileScript(descriptor, { id: 'order-time-test' })
const template = compileTemplate({
    source: descriptor.template.content,
    filename,
    id: 'order-time-test',
    compilerOptions: { bindingMetadata: script.bindings }
})
assert.deepEqual(template.errors, [])
const compiled = ts.transpileModule(script.content, {
    compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2022 }
}).outputText

function dialog(save = async () => ({})) {
    const calls = []
    const events = []
    const module = { exports: {} }
    const mockRequire = (name) => {
        if (name === 'vue') return vue
        if (name === '@/api/tcm') return {
            prescriptionOrderEditTime: async (payload) => {
                calls.push(payload)
                return save(payload)
            }
        }
        if (name === '@/utils/feedback') return { default: { msgSuccess() {} } }
        throw new Error(`Unexpected dependency: ${name}`)
    }
    new Function('require', 'module', 'exports', compiled)(mockRequire, module, module.exports)
    const state = module.exports.default.setup({}, {
        expose() {},
        emit: (...event) => events.push(event)
    })
    state.formRef.value = { validate: async () => true, clearValidate() {} }
    return { state, calls, events }
}

test('opening and saving preserves creation time seconds and submits only the selected order', async () => {
    const { state, calls, events } = dialog()
    state.open({ id: 42, order_no: 'RX42', create_time: '2026-09-09 11:12:37' })
    assert.equal(state.form.create_time, '2026-09-09 11:12:37')
    state.form.create_time = '2026-08-31 09:08:07'
    await state.submit()
    assert.deepEqual(calls, [{ id: 42, create_time: '2026-08-31 09:08:07' }])
    assert.deepEqual(events, [['saved', 42]])
    assert.equal(state.visible.value, false)
})

test('legacy seconds, milliseconds and strings populate the same local picker time', () => {
    const { state } = dialog()
    const date = new Date(2026, 8, 9, 11, 12, 37)
    for (const value of [date.getTime() / 1000, String(date.getTime() / 1000), date.getTime(), '2026-09-09T11:12:37']) {
        state.open({ id: 1, create_time: value })
        assert.equal(state.form.create_time, '2026-09-09 11:12:37')
    }
    state.open({ id: 1, create_time: '2026-09-09 11:12' })
    assert.equal(state.form.create_time, '2026-09-09 11:12:00')
    state.open({ id: 1, create_time: 0 })
    assert.equal(state.form.create_time, '')
})

test('validation failures do not send requests, and failed saves retain editable input', async () => {
    const { state, calls, events } = dialog(async () => { throw new Error('denied') })
    state.open({ id: 9, create_time: '2026-09-09 11:12:37' })
    state.formRef.value.validate = async () => { throw new Error('required') }
    await state.submit()
    assert.equal(calls.length, 0)
    state.formRef.value.validate = async () => true
    await state.submit()
    assert.equal(state.visible.value, true)
    assert.equal(state.submitting.value, false)
    assert.equal(state.form.create_time, '2026-09-09 11:12:37')
    assert.deepEqual(events, [])
})

test('a pending request cannot submit twice or switch its target order', async () => {
    let finish
    const pending = new Promise((resolve) => { finish = resolve })
    const { state, calls, events } = dialog(() => pending)
    state.open({ id: 7, create_time: '2026-09-09 11:12:37' })
    const saving = state.submit()
    await state.submit()
    await new Promise((resolve) => setImmediate(resolve))
    state.open({ id: 8, create_time: '2026-09-08 00:00:00' })
    await state.submit()
    assert.equal(calls.length, 1)
    assert.equal(state.form.id, 7)
    finish({})
    await saving
    assert.deepEqual(events, [['saved', 7]])
})