const assert = require('assert').strict
const fs = require('fs')
const path = require('path')
const Module = require('module')
const { transformSync } = require('@babel/core')
const compiler = require('vue-template-compiler')
const Vue = require('vue')

const root = path.resolve(__dirname, '..')
const originalResolve = Module._resolveFilename
Module._resolveFilename = function(request, parent, ...rest) {
  return originalResolve.call(this, request.startsWith('@/') ? path.join(root, 'src', request.slice(2)) : request, parent, ...rest)
}
const originalJs = require.extensions['.js']
function compileScript(source, filename) {
  return transformSync(source, {
    filename,
    babelrc: false,
    configFile: false,
    plugins: ['@babel/plugin-transform-modules-commonjs']
  }).code
}
require.extensions['.js'] = (module, filename) => {
  if (!filename.startsWith(path.join(root, 'src') + path.sep)) return originalJs(module, filename)
  module._compile(compileScript(fs.readFileSync(filename, 'utf8'), filename), filename)
}
require.extensions['.vue'] = (module, filename) => {
  const { script, template } = compiler.parseComponent(fs.readFileSync(filename, 'utf8'))
  const compiled = compiler.compile(template.content)
  assert.deepEqual(compiled.errors, [], `${filename}: 템플릿 컴파일`)
  module._compile(compileScript(script.content, filename), filename)
  Object.assign(module.exports.default, compiler.compileToFunctions(template.content))
}

const api = require('../src/api/gift_category')
const { createGiftCategoryForm, buildGiftCategoryRequest, validateGiftCategory } = require('../src/utils/gift_category')
const GiftCategory = require('../src/views/Gift/GiftCategory.vue').default
const SideMenu = require('../src/components/SideMenu.vue').default
const tests = []
const test = (name, run) => tests.push({ name, run })
const envelope = data => ({ success: true, data })
const category = (overrides = {}) => ({
  categoryId: 1, classificationNumber: '100', categoryCode: 'DOLL', name: '인형',
  receiptCode: 'A', representativeItem: '피규어', requiresDamageWaiver: false, isActive: true,
  ...overrides
})
const request = (overrides = {}) => ({
  classificationNumber: '100', categoryCode: 'DOLL', name: '인형', receiptCode: 'A',
  representativeItem: '피규어', requiresDamageWaiver: false, isActive: true,
  ...overrides
})
function page() {
  const errors = []
  const successes = []
  const vm = new Vue({ ...GiftCategory, created: undefined })
  vm.$dialog = { notify: { error: message => errors.push(message), success: message => successes.push(message) } }
  return { vm, errors, successes }
}
function deferred() {
  let resolve
  const promise = new Promise(done => { resolve = done })
  return { promise, resolve }
}
function nodes(vnode) {
  if (!vnode) return []
  return [vnode].concat((vnode.children || (vnode.componentOptions && vnode.componentOptions.children) || []).flatMap(nodes))
}
const text = vnode => nodes(vnode).map(node => node.text || '').join('').trim()
const button = (vm, label) => nodes(vm._render()).find(node => node.tag === 'v-btn' && text(node) === label)

test('카테고리 API: GET/POST/PUT/DELETE 경로, 본문 및 공통 envelope를 사용한다', async () => {
  const calls = []
  const response = envelope(category())
  Vue.axios = Object.fromEntries(['get', 'post', 'put', 'delete'].map(method => [method, async (...args) => {
    calls.push([method, ...args])
    return { data: response }
  }]))
  assert.equal(await api.getGiftCategories(), response)
  assert.equal(await api.createGiftCategory(category({ extra: '제외' })), response)
  assert.equal(await api.updateGiftCategory(1, category({ extra: '제외' })), response)
  assert.equal(await api.deactivateGiftCategory(1), response)
  assert.deepEqual(calls, [
    ['get', '/api/v2/admin/gift-categories'],
    ['post', '/api/v2/admin/gift-categories', request()],
    ['put', '/api/v2/admin/gift-categories/1', request()],
    ['delete', '/api/v2/admin/gift-categories/1']
  ])
})

test('카테고리 validation: 필수/형식/길이/boolean 오류를 검사한다', () => {
  const invalid = {
    classificationNumber: ['', ' ', null, undefined, 100, '10', '1000', 'A10', '１２３', '100\n', ' 10'],
    categoryCode: ['', ' \t ', null, undefined, 1, 'A'.repeat(51)],
    name: ['', ' \n ', null, undefined, 1, '가'.repeat(51)],
    receiptCode: ['', ' ', null, undefined, 1, 'a', 'Aa', 'A1', '가', 'A B', 'A\n', 'A'.repeat(10)],
    representativeItem: ['', ' ', null, undefined, 1, '가'.repeat(101)],
    requiresDamageWaiver: [null, undefined, '', 'false', 0, 1],
    isActive: [null, undefined, '', 'true', 0, 1]
  }
  for (const [key, values] of Object.entries(invalid)) {
    for (const value of values) {
      const errors = validateGiftCategory(request({ [key]: value }))
      assert.deepEqual(Object.keys(errors), [key], `${key}: ${String(value)}`)
      assert.equal(typeof errors[key], 'string')
    }
  }
})

test('카테고리 validation: 최대 길이/앞자리 0/false를 보존하며 ID는 본문에서 제외한다', () => {
  for (const requiresDamageWaiver of [true, false]) {
    for (const isActive of [true, false]) {
      const form = request({
        classificationNumber: '001', categoryCode: 'A'.repeat(50), name: '가'.repeat(50),
        receiptCode: 'ABCDEFGHI', representativeItem: '가'.repeat(100), requiresDamageWaiver, isActive
      })
      assert.deepEqual(validateGiftCategory(form), {})
      assert.deepEqual(buildGiftCategoryRequest({ categoryId: 7, extra: '제외', ...form }), form)
    }
  }
  const first = createGiftCategoryForm()
  first.name = '변경'
  assert.equal(createGiftCategoryForm().name, '')
})

test('카테고리 목록: 최초 GET의 response.data 배열과 필수 9개 컬럼을 표시한다', async () => {
  const { vm } = page()
  const calls = []
  Vue.axios = { get: async (...args) => { calls.push(args); return { data: envelope([category()]) } } }
  await GiftCategory.created.call(vm)
  assert.deepEqual(calls, [['/api/v2/admin/gift-categories']])
  assert.deepEqual(Array.from(vm.categories), [category()])
  const rendered = nodes(vm._render())
  assert.deepEqual(rendered.filter(node => node.tag === 'th').map(text), [
    '카테고리 ID', '분류번호', '카테고리 코드', '카테고리명', '접수 코드', '대표 품목', '파손면책 동의 필요 여부', '활성 여부', '관리'
  ])
  assert.deepEqual(rendered.filter(node => node.tag === 'td').slice(0, 8).map(text), ['1', '100', 'DOLL', '인형', 'A', '피규어', '아니오', '활성'])
  button(vm, '수정').data.on.click()
  assert.equal(vm.isEdit, true)
  vm.closeForm()
  button(vm, '카테고리 등록').data.on.click()
  assert.equal(vm.isEdit, false)
  assert.equal(vm.show_form_dialog, true)
})

test('카테고리 목록: 빈 목록, 로딩 및 오류 재조회 상태를 표시한다', async () => {
  const { vm, errors } = page()
  assert.ok(text(vm._render()).includes('등록된 카테고리가 없습니다.'))
  const pending = deferred()
  Vue.axios = { get: async () => pending.promise }
  const load = vm.getCategories()
  assert.equal(vm.is_loading, true)
  assert.ok(text(vm._render()).includes('조회 중입니다.'))
  assert.equal(button(vm, '카테고리 등록').data.attrs.disabled, true)
  pending.resolve({ data: { success: false, message: '조회 실패' } })
  await load
  assert.deepEqual(errors, ['조회 실패'])
  assert.equal(vm.is_loading, false)
  assert.equal(vm.list_error, true)
  Vue.axios.get = async () => ({ data: envelope([]) })
  await button(vm, '다시 조회').data.on.click()
  assert.equal(vm.list_error, false)
})

test('카테고리 폼: 수정 코드는 읽기 전용이며 취소는 목록을 변경하지 않고 등록은 초기화한다', () => {
  const { vm } = page()
  const item = category()
  vm.openEdit(item)
  assert.equal(vm.categoryId, 1)
  assert.deepEqual(vm.form, request())
  const fields = nodes(vm._render()).filter(node => node.tag === 'v-text-field')
  assert.equal(fields.length, 5)
  for (const field of fields) assert.equal(field.data.attrs.readonly, field.data.attrs.label === '카테고리 코드')
  assert.equal(nodes(vm._render()).filter(node => node.tag === 'v-switch').length, 2)
  vm.form.name = '변경'
  vm.form.isActive = false
  vm.closeForm()
  assert.equal(item.name, '인형')
  assert.equal(item.isActive, true)
  vm.form_errors = { name: '오류' }
  vm.openCreate()
  assert.equal(vm.categoryId, null)
  assert.deepEqual(vm.form, createGiftCategoryForm())
  assert.deepEqual(vm.form_errors, {})
  assert.equal(nodes(vm._render()).find(node => node.tag === 'v-text-field' && node.data.attrs.label === '카테고리 코드').data.attrs.readonly, false)
})

test('카테고리 폼: validation 실패 시 등록/수정 API 없이 필드 오류를 표시한다', async () => {
  for (const edit of [false, true]) {
    const { vm, successes } = page()
    const calls = []
    Vue.axios = { post: async () => { calls.push('POST') }, put: async () => { calls.push('PUT') } }
    if (edit) vm.openEdit(category())
    else vm.openCreate()
    vm.form = request({ classificationNumber: '10', categoryCode: '', name: '', receiptCode: 'a', representativeItem: '', requiresDamageWaiver: null, isActive: null })
    const form = nodes(vm._render()).find(node => node.tag === 'v-form')
    await form.data.on.submit({ preventDefault() {} })
    assert.deepEqual(calls, [])
    assert.deepEqual(successes, [])
    assert.equal(Object.keys(vm.form_errors).length, 7)
    for (const field of nodes(vm._render()).filter(node => ['v-text-field', 'v-switch'].includes(node.tag))) {
      assert.ok(field.data.attrs['error-messages'])
    }
    assert.equal(vm.show_form_dialog, true)
    assert.equal(vm.is_operating, false)
  }
})

test('카테고리 저장: POST/PUT 성공 후 재조회하고 모달을 닫으며 중복 제출을 차단한다', async () => {
  for (const edit of [false, true]) {
    const { vm, successes } = page()
    const pending = deferred()
    const calls = []
    const payload = request({ classificationNumber: '001', requiresDamageWaiver: true, isActive: false })
    const saved = category(payload)
    Vue.axios = {
      [edit ? 'put' : 'post']: async (...args) => { calls.push([edit ? 'PUT' : 'POST', ...args]); return { data: envelope(saved) } },
      get: async (...args) => { calls.push(['GET', ...args]); return pending.promise }
    }
    if (edit) vm.openEdit(category())
    else vm.openCreate()
    vm.form = { ...payload, categoryId: 99, extra: '제외' }
    const operation = vm.saveCategory()
    await vm.saveCategory()
    await Vue.nextTick()
    assert.equal(vm.is_operating, true)
    assert.equal(vm.show_form_dialog, true)
    vm.closeForm()
    vm.openEdit(category({ categoryId: 2 }))
    vm.openCreate()
    assert.equal(vm.categoryId, edit ? 1 : null)
    assert.equal(vm.show_form_dialog, true)
    pending.resolve({ data: envelope([saved]) })
    await operation
    assert.deepEqual(calls, [
      [edit ? 'PUT' : 'POST', `/api/v2/admin/gift-categories${edit ? '/1' : ''}`, payload],
      ['GET', '/api/v2/admin/gift-categories']
    ])
    assert.deepEqual(Array.from(vm.categories), [saved])
    assert.equal(vm.show_form_dialog, false)
    assert.equal(vm.is_operating, false)
    assert.deepEqual(successes, [edit ? '카테고리가 수정되었습니다.' : '카테고리가 등록되었습니다.'])
    await vm.saveCategory()
    assert.equal(calls.length, 2)
  }
})

test('카테고리 저장 실패: 공통 오류 알림과 입력/모달을 유지한다', async () => {
  for (const edit of [false, true]) {
    for (const fail of [
      async () => ({ data: { success: false, message: '저장 실패' } }),
      async () => { throw { response: { data: { message: '저장 실패' } } } },
      async () => { throw new Error('저장 실패') }
    ]) {
      const { vm, errors, successes } = page()
      let loads = 0
      Vue.axios = { post: fail, put: fail, get: async () => { loads++ } }
      if (edit) vm.openEdit(category())
      else vm.openCreate()
      vm.form = request()
      await vm.saveCategory()
      assert.deepEqual(errors, ['저장 실패'])
      assert.deepEqual(successes, [])
      assert.deepEqual(vm.form, request())
      assert.equal(vm.show_form_dialog, true)
      assert.equal(vm.is_operating, false)
      assert.equal(loads, 0)
    }
  }
})

test('카테고리 저장 후 조회 실패: 저장 성공과 조회 오류를 구분하며 중복 등록을 방지한다', async () => {
  const { vm, errors, successes } = page()
  Vue.axios = {
    post: async () => ({ data: envelope(category()) }),
    get: async () => { throw new Error('조회 실패') }
  }
  vm.openCreate()
  vm.form = request()
  await vm.saveCategory()
  assert.deepEqual(successes, ['카테고리가 등록되었습니다.'])
  assert.deepEqual(errors, ['조회 실패'])
  assert.equal(vm.show_form_dialog, false)
  assert.equal(vm.list_error, true)
  assert.equal(vm.is_operating, false)
})

test('카테고리 비활성화: 확인 전/취소 후/이미 비활성이면 DELETE하지 않는다', async () => {
  const { vm } = page()
  let calls = 0
  Vue.axios = { delete: async () => { calls++ } }
  vm.categories = [category()]
  button(vm, '비활성화').data.on.click()
  assert.equal(vm.show_confirm_dialog, true)
  assert.ok(text(vm._render()).includes('인형 카테고리를 비활성화하시겠습니까?'))
  assert.equal(calls, 0)
  vm.cancelDeactivation()
  await vm.deactivateCategory()
  assert.equal(calls, 0)
  assert.equal(vm.pendingCategory, null)
  vm.categories = [category({ isActive: false, requiresDamageWaiver: true })]
  assert.equal(button(vm, '비활성화').data.attrs.disabled, true)
  assert.ok(text(vm._render()).includes('비활성'))
  assert.ok(text(vm._render()).includes('예'))
  vm.requestDeactivation(vm.categories[0])
  await vm.deactivateCategory()
  assert.equal(calls, 0)
  assert.equal(vm.show_confirm_dialog, false)
})

test('카테고리 비활성화 성공: 응답의 isActive=false를 반영하고 row는 유지한다', async () => {
  const { vm, successes } = page()
  const pending = deferred()
  const calls = []
  Vue.axios = { delete: async (...args) => { calls.push(args); return pending.promise } }
  vm.categories = [category(), category({ categoryId: 2 })]
  vm.requestDeactivation(vm.categories[0])
  const operation = button(vm, '확인').data.on.click()
  await vm.deactivateCategory()
  vm.cancelDeactivation()
  assert.equal(vm.show_confirm_dialog, true)
  assert.equal(vm.is_operating, true)
  assert.equal(button(vm, '비활성화').data.attrs.disabled, true)
  pending.resolve({ data: envelope(category({ isActive: false })) })
  await operation
  assert.deepEqual(calls, [['/api/v2/admin/gift-categories/1']])
  assert.deepEqual(Array.from(vm.categories), [category({ isActive: false }), category({ categoryId: 2 })])
  assert.equal(button(vm, '비활성화').data.attrs.disabled, true)
  assert.equal(vm.show_confirm_dialog, false)
  assert.equal(vm.pendingCategory, null)
  assert.equal(vm.is_operating, false)
  assert.deepEqual(successes, ['카테고리가 비활성화되었습니다.'])
})

test('카테고리 비활성화 실패: 기존 활성 상태를 유지하고 공통 오류를 표시한다', async () => {
  for (const fail of [
    async () => ({ data: { success: false, message: '비활성화 실패' } }),
    async () => { throw { response: { data: { message: '비활성화 실패' } } } }
  ]) {
    const { vm, errors, successes } = page()
    Vue.axios = { delete: fail }
    vm.categories = [category()]
    vm.requestDeactivation(vm.categories[0])
    await vm.deactivateCategory()
    assert.equal(vm.categories[0].isActive, true)
    assert.equal(vm.show_confirm_dialog, true)
    assert.equal(vm.is_operating, false)
    assert.deepEqual(errors, ['비활성화 실패'])
    assert.deepEqual(successes, [])
  }
})

test('카테고리 목록: 늦게 도착한 이전 응답은 최신 목록을 덮어쓰지 않는다', async () => {
  const { vm } = page()
  const pending = deferred()
  Vue.axios = { get: async () => pending.promise }
  const old = vm.getCategories()
  Vue.axios.get = async () => ({ data: envelope([category({ categoryId: 2 })]) })
  await vm.getCategories()
  pending.resolve({ data: envelope([category()]) })
  await old
  assert.deepEqual(Array.from(vm.categories), [category({ categoryId: 2 })])
  assert.equal(vm.is_loading, false)
})

test('카테고리 메뉴: ADMIN 보완 메뉴와 서버 메뉴를 중복 없이 유지한다', async () => {
  for (const role of ['ADMIN', 'CONTENT_MANAGER']) {
    for (const existing of ['none', 'null', 'list', 'category', 'object']) {
      const menus = []
      if (existing !== 'none') {
        const items = existing === 'null' ? null : existing === 'list'
          ? [{ title: '선물함 리스트', route: '/gift/list' }]
          : existing === 'object' ? { title: '선물 카테고리', route: '/gift/category' }
            : [{ title: '선물 카테고리', route: '/gift/category' }]
        menus.push({ title: '선물함 관리', items })
      }
      Vue.axios = { get: async () => ({ status: 200, data: envelope(menus) }) }
      const vm = new Vue({ ...SideMenu, created: undefined })
      vm.$store = { state: { accountStore: { role } } }
      await vm.getMenus()
      const gifts = vm.items.filter(item => item.title === '선물함 관리')
      assert.equal(gifts.length, role === 'ADMIN' || existing !== 'none' ? 1 : 0)
      const children = gifts.length && gifts[0].items ? [].concat(gifts[0].items) : []
      assert.equal(children.filter(item => item.route === '/gift/category').length, role === 'ADMIN' || ['category', 'object'].includes(existing) ? 1 : 0)
      if (role === 'ADMIN') assert.equal(children.filter(item => item.route === '/gift/list').length, 1)
    }
  }
})

;(async () => {
  for (const { name, run } of tests) {
    try {
      await run()
      console.log(`PASS ${name}`)
    } catch (error) {
      process.exitCode = 1
      console.error(`FAIL ${name}`, error)
    }
  }
})()