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, compileStyle } = require('@vue/compiler-sfc')
const ts = require('typescript')
const vue = require('vue')

const filename = path.join(__dirname, '../src/views/first_visit/wecom_promotion/index.vue')
const { descriptor, errors } = parse(fs.readFileSync(filename, 'utf8'), { filename })
assert.deepEqual(errors, [])
const script = compileScript(descriptor, { id: 'member-sync-test' })
const template = compileTemplate({ source: descriptor.template.content, filename, id: 'member-sync-test', compilerOptions: { bindingMetadata: script.bindings } })
assert.deepEqual(template.errors, [])
assert.deepEqual(compileStyle({ source: descriptor.styles[0].content, filename, id: 'member-sync-test', scoped: true, preprocessLang: 'scss' }).errors, [])

function loadModule(source, mockRequire) {
    const compiled = ts.transpileModule(source, { compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2022 } }).outputText
    const module = { exports: {} }
    new Function('require', 'module', 'exports', compiled)(mockRequire, module, module.exports)
    return module.exports
}

const automation = loadModule(fs.readFileSync(path.join(path.dirname(filename), 'components/promotion-automation.ts'), 'utf8'), require)
const member = (id, enabled = 1) => ({ id, admin_id: id, userid: `member-${id}`, name: `医助 ${id}`, enabled, reception_available: enabled === 1, is_in_remote_range: true })
const pool = (id = 1) => ({ id, name: `方案 ${id}`, status: 1, can_operate: true, can_manage_access: true, member_admin_ids: [1, 2], member_rules: [member(1), member(2, 0)], official_link: { range_userids: ['member-1', 'member-2'] }, dispatch_sync: { status: 1 } })

function page(api = {}, pools = [pool()]) {
    const messages = []
    const emitMessage = (type, value) => messages.push({ type, message: typeof value === 'string' ? value : value.message })
    const ElMessage = (value) => emitMessage(value.type, value)
    for (const type of ['success', 'warning', 'error']) ElMessage[type] = (value) => emitMessage(type, value)
    const instance = loadModule(script.content, (name) => {
        if (name === 'vue') return { ...vue, onMounted() {} }
        if (name === 'element-plus') return { ElMessage, ElMessageBox: {} }
        if (name === '@element-plus/icons-vue') return {}
        if (name === '@/api/first_visit') return { wecomPromotionOverview: async () => ({ pools }), ...api }
        if (name.endsWith('.vue')) return {}
        if (name === './components/promotion-automation') return automation
        throw new Error(`Unexpected dependency: ${name}`)
    }).default.setup({}, { expose() {} })
    Object.assign(instance.overview, { pools })
    instance.selectedPoolId.value = pools[0]?.id
    return { state: instance, messages }
}

test('disabled local member still in remote snapshot is explicitly pending removal', () => {
    const { state } = page()
    assert.equal(state.routeStatus(member(2, 0)).label, '待移出（仍在企微）')
    assert.equal(state.routeStatus({ ...member(1), is_in_remote_range: '0' }).label, '待加入企微')
    assert.match(state.selectedSyncState.value.description, /当前计划：医助 1；上次企微确认：医助 1、医助 2/)
    state.overview.pools[0].dispatch_sync = { status: 3, last_error: '可信 IP 校验失败' }
    assert.match(state.selectedSyncState.value.description, /可信 IP 校验失败/)
})

test('single toggles never infer remote success from an empty error or planned dispatch', async () => {
    const calls = []
    const { state, messages } = page({ wecomPromotionToggleMember: async (payload) => { calls.push(payload); return { sync_error: '', dispatch: { queued: true } } } })
    await state.handleMemberToggle(member(2), false)
    assert.deepEqual(calls, [{ id: 2, status: 0 }])
    assert.equal(messages.at(-1).type, 'warning')
    assert.match(messages.at(-1).message, /尚未确认同步/)
    assert.doesNotMatch(messages.at(-1).message, /已确认同步|已重新计算/)
    assert.match(state.operationResultText(state.operationResults.value[0]), /尚未确认同步/)
})

test('single rule save reports explicit remote confirmation and preserves precise failures', async () => {
    const { state, messages } = page({ wecomPromotionSaveMember: async () => ({ sync_status: 'failed', sync_error: '企微成员范围不一致' }) })
    Object.assign(state.memberForm, { id: 2, active_range: [] })
    await state.saveMemberRule()
    assert.equal(messages.at(-1).type, 'warning')
    assert.match(messages.at(-1).message, /企微成员范围不一致/)
    state.notifySavedResult('本地已保存', { sync_status: 'synced' })
    assert.equal(messages.at(-1).type, 'success')
    assert.match(messages.at(-1).message, /企微成员范围已确认同步/)
})

test('pool saves with queued work retain a warning instead of implying official link completion', async () => {
    const { state, messages } = page({ wecomPromotionSavePool: async () => ({ id: 1, sync_status: 'pending', sync_queued: true, sync_error: '' }) })
    Object.assign(state.poolForm, { id: 1, name: '方案 1', member_admin_ids: [1] })
    await state.savePool()
    assert.equal(state.poolDialogVisible.value, false)
    assert.equal(messages.at(-1).type, 'warning')
    assert.match(messages.at(-1).message, /尚未确认同步/)
    assert.equal(state.operationResults.value[0].sync_queued, true)
})

test('manual retry targets only its pool and does not import remote links', async () => {
    const calls = []
    const { state, messages } = page({ wecomPromotionSyncMemberRange: async (payload) => { calls.push(payload); return { pool_id: 1, sync_status: 'synced', sync_error: '', sync_queued: false } } })
    await state.syncMemberRange(1)
    assert.deepEqual(calls, [{ pool_id: 1 }])
    assert.equal(state.operationResults.value[0].sync_status, 'synced')
    assert.equal(state.syncingPoolId.value, 0)
    assert.equal(messages.at(-1).type, 'success')
    state.overview.pools[0].can_operate = false
    await state.syncMemberRange(1)
    assert.equal(calls.length, 1)
})

test('batch sync awaits all queued successful pools with at most two concurrent requests', async () => {
    const pending = []
    let active = 0
    let maximum = 0
    const { state } = page({ wecomPromotionSyncMemberRange: ({ pool_id }) => new Promise((resolve) => {
        active++
        maximum = Math.max(maximum, active)
        pending.push({ id: pool_id, finish: (result) => { active--; resolve({ pool_id, ...result }) } })
    }) })
    const results = [1, 2, 3].map((id) => ({ id, name: `方案 ${id}`, success: true, sync_queued: true }))
    results.push({ id: 4, name: '保存失败方案', success: false, sync_queued: true, error: '无权限' })
    const saving = state.syncBatchResults(results)
    assert.deepEqual(pending.map((item) => item.id), [1, 2])
    pending[0].finish({ sync_status: 'synced', sync_error: '' })
    await new Promise((resolve) => setImmediate(resolve))
    assert.deepEqual(pending.map((item) => item.id), [1, 2, 3])
    assert.equal(state.batchSyncProgress.completed, 1)
    pending[1].finish({ sync_status: 'failed', sync_error: '范围校验失败' })
    pending[2].finish({ sync_status: 'pending', sync_error: '' })
    await saving
    assert.equal(maximum, 2)
    assert.equal(state.batchSyncProgress.completed, 3)
    assert.deepEqual(state.operationResults.value.map((item) => item.sync_status), ['synced', 'failed', 'pending', undefined])
    assert.match(state.operationResultText(state.operationResults.value[1]), /范围校验失败/)
    assert.match(state.operationResultText(state.operationResults.value[3]), /本地保存失败：无权限/)
})

test('batch save retains partial failures and never reports queued work as remote success', async () => {
    const pools = [pool(1), pool(2), pool(3)]
    const syncedIds = []
    const { state, messages } = page({
        wecomPromotionBatchUpdatePools: async () => ({ updated: 2, failed: 1, member_updated: 2, results: [
            { id: 1, name: '方案 1', success: true, sync_queued: true },
            { id: 2, name: '方案 2', success: true, sync_queued: true },
            { id: 3, name: '方案 3', success: false, error: '保存失败' }
        ] }),
        wecomPromotionSyncMemberRange: async ({ pool_id }) => {
            syncedIds.push(pool_id)
            if (pool_id === 2) throw '企微请求超时'
            return { pool_id, sync_status: 'synced', sync_error: '', sync_queued: false }
        }
    }, pools)
    Object.assign(state.batchConfigApply, { member_status: true })
    Object.assign(state.batchConfigForm, { pool_ids: [1, 2, 3], member_admin_ids: [2], member_status: 0 })
    state.batchConfigDialogVisible.value = true
    await state.saveBatchConfig()
    assert.deepEqual(syncedIds, [1, 2])
    assert.equal(state.savingBatchConfig.value, false)
    assert.equal(state.batchConfigDialogVisible.value, false)
    assert.deepEqual(state.selectedPoolIds.value, [2, 3])
    assert.match(messages.at(-1).message, /企微已确认同步 1 个，1 个尚未确认同步；1 个本地保存失败/)
    assert.equal(messages.at(-1).type, 'warning')
    assert.match(state.operationResults.value[1].sync_error, /企微请求超时/)
})

test('direct batch sync snapshots and deduplicates selection, limits concurrency, and waits for refresh', async () => {
    const pools = [pool(1), pool(2), pool(3), pool(4)]
    const pending = []
    const unrelatedCalls = []
    let active = 0
    let maximum = 0
    let refreshCount = 0
    let finishRefresh
    const api = Object.fromEntries([
        'wecomPromotionBatchUpdatePools', 'wecomPromotionSavePool', 'wecomPromotionSaveMember',
        'wecomPromotionBatchSetOperators', 'wecomPromotionSyncCustomers', 'wecomPromotionToggleMember'
    ].map((name) => [name, async (payload) => { unrelatedCalls.push({ name, payload }); return {} }]))
    const { state, messages } = page({
        ...api,
        wecomPromotionOverview: () => {
            refreshCount++
            return new Promise((resolve) => { finishRefresh = () => resolve({ pools }) })
        },
        wecomPromotionSyncMemberRange: ({ pool_id }) => new Promise((resolve) => {
            active++
            maximum = Math.max(maximum, active)
            pending.push({ id: pool_id, finish: () => {
                active--
                resolve({ pool_id, sync_status: 'synced', sync_error: '', sync_queued: false })
            } })
        })
    }, pools)
    state.selectedPoolIds.value = [1, 1, 2, 3]
    let completed = false
    const syncing = state.syncSelectedMemberRanges().then(() => { completed = true })
    assert.equal(state.syncingBatchMembers.value, true)
    assert.deepEqual(pending.map((item) => item.id), [1, 2])
    assert.deepEqual({ ...state.batchSyncProgress }, { completed: 0, total: 3 })

    // A changed ref must not alter the already-dispatched batch's work list.
    state.selectedPoolIds.value = [4]
    pending[0].finish()
    await new Promise((resolve) => setImmediate(resolve))
    assert.deepEqual(pending.map((item) => item.id), [1, 2, 3])
    assert.equal(state.batchSyncProgress.completed, 1)
    assert.equal(refreshCount, 0)
    pending[1].finish()
    await new Promise((resolve) => setImmediate(resolve))
    assert.equal(state.batchSyncProgress.completed, 2)
    assert.equal(completed, false)
    assert.equal(refreshCount, 0)
    pending[2].finish()
    await new Promise((resolve) => setImmediate(resolve))
    assert.equal(maximum, 2)
    assert.equal(refreshCount, 1)
    assert.equal(state.syncingBatchMembers.value, true)
    assert.equal(state.batchSyncProgress.completed, 3)
    assert.equal(completed, false)
    finishRefresh()
    await syncing

    assert.equal(state.syncingBatchMembers.value, false)
    assert.deepEqual({ ...state.batchSyncProgress }, { completed: 0, total: 0 })
    assert.deepEqual(state.selectedPoolIds.value, [])
    assert.deepEqual(state.operationResults.value.map((item) => item.id), [1, 2, 3])
    assert.ok(state.operationResults.value.every((item) => item.sync_only && item.sync_status === 'synced'))
    assert.deepEqual(unrelatedCalls, [])
    assert.equal(messages.at(-1).type, 'success')
    assert.match(messages.at(-1).message, /已确认同步 3 个/)
    assert.doesNotMatch(messages.at(-1).message, /本地.*保存/)
    for (const result of state.operationResults.value) {
        assert.match(state.operationResultText(result), /已确认同步/)
        assert.doesNotMatch(state.operationResultText(result), /本地.*保存/)
    }
})

test('direct batch sync keeps failed, pending and blocked pools selected with precise results', async () => {
    const pools = [pool(1), pool(2), pool(3), { ...pool(4), official_link: null }, { ...pool(5), can_operate: false }]
    const calls = []
    let refreshCount = 0
    const { state, messages } = page({
        wecomPromotionOverview: async () => { refreshCount++; return { pools } },
        wecomPromotionSyncMemberRange: async ({ pool_id }) => {
            calls.push(pool_id)
            if (pool_id === 2) throw new Error('企微请求超时，请检查网络')
            return { pool_id, sync_status: pool_id === 1 ? 'synced' : 'pending', sync_queued: pool_id === 3, sync_error: '' }
        }
    }, pools)
    state.selectedPoolIds.value = [1, 2, 3, 4, 5]
    await state.syncSelectedMemberRanges()

    assert.deepEqual(calls, [1, 2, 3])
    assert.equal(refreshCount, 1)
    assert.deepEqual(state.selectedPoolIds.value, [2, 3, 4, 5])
    assert.deepEqual(state.operationResults.value.map((item) => item.sync_status), ['synced', 'failed', 'pending', 'blocked', 'blocked'])
    assert.ok(state.operationResults.value.every((item) => item.sync_only))
    assert.match(state.operationResults.value[1].sync_error, /企微请求超时，请检查网络/)
    assert.equal(state.operationResults.value[2].sync_queued, true)
    assert.match(state.operationResultText(state.operationResults.value[3]), /链接/)
    assert.match(state.operationResultText(state.operationResults.value[4]), /权限|无权/)
    for (const result of state.operationResults.value) assert.doesNotMatch(state.operationResultText(result), /本地.*保存/)
    assert.equal(messages.at(-1).type, 'warning')
    assert.match(messages.at(-1).message, /已确认同步 1 个/)
    assert.match(messages.at(-1).message, /4 个尚未确认同步/)
    assert.doesNotMatch(messages.at(-1).message, /本地.*保存/)
    assert.equal(state.syncingBatchMembers.value, false)
    assert.deepEqual({ ...state.batchSyncProgress }, { completed: 0, total: 0 })
})

test('direct batch sync prevents duplicate requests and freezes member and selection changes while busy', async () => {
    const pools = [pool(1), pool(2)]
    const calls = []
    const toggles = []
    let finish
    const { state } = page({
        wecomPromotionSyncMemberRange: ({ pool_id }) => {
            calls.push(pool_id)
            return new Promise((resolve) => { finish = () => resolve({ pool_id, sync_status: 'synced' }) })
        },
        wecomPromotionToggleMember: async (payload) => { toggles.push(payload); return { sync_status: 'synced' } }
    }, pools)
    state.selectedPoolIds.value = [1]
    const syncing = state.syncSelectedMemberRanges()
    await state.syncSelectedMemberRanges()
    await state.syncMemberRange(2)
    await state.handleMemberToggle(member(2), false)
    state.togglePoolSelection(pools[0], false)
    state.togglePoolSelection(pools[1], true)
    assert.deepEqual(state.selectedPoolIds.value, [1])
    state.toggleAllPoolSelection(false)
    assert.deepEqual(state.selectedPoolIds.value, [1])
    state.toggleAllPoolSelection(true)
    assert.deepEqual(state.selectedPoolIds.value, [1])
    assert.deepEqual(calls, [1])
    assert.deepEqual(toggles, [])
    finish()
    await syncing
    assert.equal(state.syncingBatchMembers.value, false)
})

test('direct batch sync cannot begin while a single sync, member toggle or batch save is active', async () => {
    const calls = []
    const { state } = page({ wecomPromotionSyncMemberRange: async (payload) => { calls.push(payload); return { sync_status: 'synced' } } })
    state.selectedPoolIds.value = [1]
    for (const [busy, value] of [[state.syncingPoolId, 1], [state.togglingMemberId, 2], [state.savingBatchConfig, true]]) {
        busy.value = value
        await state.syncSelectedMemberRanges()
        assert.deepEqual(calls, [])
        assert.equal(state.syncingBatchMembers.value, false)
        busy.value = typeof value === 'boolean' ? false : 0
    }
})

test('direct batch sync rejects empty and oversized selections but accepts 100 unique pools', async () => {
    const pools = Array.from({ length: 101 }, (_, index) => pool(index + 1))
    const calls = []
    const { state, messages } = page({ wecomPromotionSyncMemberRange: async ({ pool_id }) => {
        calls.push(pool_id)
        return { pool_id, sync_status: 'synced' }
    } }, pools)
    await state.syncSelectedMemberRanges()
    assert.equal(messages.at(-1).type, 'warning')
    assert.match(messages.at(-1).message, /选择|勾选/)
    assert.deepEqual(calls, [])
    state.selectedPoolIds.value = pools.map((item) => item.id)
    await state.syncSelectedMemberRanges()
    assert.equal(messages.at(-1).type, 'warning')
    assert.match(messages.at(-1).message, /100/)
    assert.deepEqual(calls, [])
    assert.equal(state.syncingBatchMembers.value, false)
    state.selectedPoolIds.value = [...pools.slice(0, 100).map((item) => item.id), 1]
    await state.syncSelectedMemberRanges()
    assert.deepEqual(calls, pools.slice(0, 100).map((item) => item.id))
    assert.equal(messages.at(-1).type, 'success')
})

test('shared operators can select and sync pools while access and configuration stay manager-only', async () => {
    const pools = [
        { ...pool(1), can_manage_access: false },
        { ...pool(2), can_operate: false },
        { ...pool(3), can_operate: false, can_manage_access: false },
        pool(4)
    ]
    const calls = []
    const { state, messages } = page({ wecomPromotionSyncMemberRange: async ({ pool_id }) => {
        calls.push(pool_id)
        return { pool_id, sync_status: 'synced' }
    } }, pools)
    assert.deepEqual(state.selectablePoolIds.value, [1, 2, 4])
    state.togglePoolSelection(pools[0], true)
    state.togglePoolSelection(pools[2], true)
    await vue.nextTick()
    assert.deepEqual(state.selectedPoolIds.value, [1])
    state.openAccessDialog()
    assert.equal(state.accessDialogVisible.value, false)
    assert.equal(messages.at(-1).type, 'warning')
    state.openBatchConfigDialog()
    assert.equal(state.batchConfigDialogVisible.value, false)
    assert.equal(messages.at(-1).type, 'warning')
    await state.syncSelectedMemberRanges()
    assert.deepEqual(calls, [1])

    state.toggleAllPoolSelection(true)
    assert.deepEqual(state.selectedPoolIds.value, [1, 2, 4])
    state.openAccessDialog()
    assert.deepEqual(state.accessForm.pool_ids, [2, 4])
    state.openBatchConfigDialog()
    assert.deepEqual(state.batchConfigForm.pool_ids, [2, 4])
    state.overview.pools[0].can_operate = false
    await vue.nextTick()
    assert.deepEqual(state.selectedPoolIds.value, [2, 4])
})