/**
 * Phase B + Phase C integration tests — always uses a temporary SQLite file (never backend/data/app.db).
 * Run: npm run test:integration
 */
import assert from 'node:assert/strict'
import { randomUUID } from 'node:crypto'
import { mkdtempSync, rmSync } from 'node:fs'
import { tmpdir } from 'node:os'
import { join } from 'node:path'
import { ValidationPipe, BadRequestException } from '@nestjs/common'
import { JwtService } from '@nestjs/jwt'
import { Test } from '@nestjs/testing'
import { FastifyAdapter, NestFastifyApplication } from '@nestjs/platform-fastify'
import bcrypt from 'bcryptjs'
import { ApiExceptionFilter } from '../src/common/filters/api-exception.filter'
import { runSchemaMigrations } from '../src/database/migration.service'
import { DatabaseService } from '../src/database/database.service'

const JWT_SECRET = 'gold-land-dev-secret-change-in-production'
const testDir = mkdtempSync(join(tmpdir(), 'gold-land-nest-test-'))
process.env.DB_PATH = join(testDir, 'test.db')
process.env.NODE_ENV = 'test'
process.env.PORT = '3999'
process.env.JWT_SECRET = JWT_SECRET

async function createApp(): Promise<NestFastifyApplication> {
  const { AppModule } = await import('../src/app.module')
  const moduleRef = await Test.createTestingModule({
    imports: [AppModule],
  }).compile()

  const app = moduleRef.createNestApplication<NestFastifyApplication>(new FastifyAdapter())
  app.useGlobalPipes(
    new ValidationPipe({
      transform: true,
      whitelist: true,
      forbidNonWhitelisted: true,
    }),
  )
  app.useGlobalFilters(new ApiExceptionFilter())
  await app.init()
  await app.getHttpAdapter().getInstance().ready()
  return app
}

function authHeader(token: string) {
  return { authorization: `Bearer ${token}` }
}

function parseJson<T>(payload: string): T {
  return JSON.parse(payload) as T
}

function assertMeResponseShape(body: Record<string, unknown>) {
  assert.ok(body.user && typeof body.user === 'object')
  assert.ok(body.wallet && typeof body.wallet === 'object')
  assert.ok(body.progress && typeof body.progress === 'object')
  assert.ok(Array.isArray(body.achievements))
  assert.ok(Array.isArray(body.transactions))
  assert.ok(body.market && typeof body.market === 'object')
  const progress = body.progress as Record<string, unknown>
  assert.ok(Array.isArray(progress.mapLevels))
  assert.equal(typeof progress.totalStars, 'number')
  assert.equal(typeof progress.maxStars, 'number')
}

function assertFastifyDefaultAchievementSeed(
  achievements: Array<{ id: string; unlocked: boolean }>,
) {
  assert.equal(achievements.length, 4)
  assert.deepEqual(
    achievements.map((a) => ({ id: a.id, unlocked: a.unlocked })),
    [
      { id: 'first-gold', unlocked: true },
      { id: 'saver', unlocked: true },
      { id: 'market', unlocked: false },
      { id: 'inflation', unlocked: false },
    ],
  )
}

function testApiExceptionFilterShape() {
  const filter = new ApiExceptionFilter()
  let statusCode = 0
  let body: unknown

  const host = {
    switchToHttp: () => ({
      getResponse: () => ({
        status(code: number) {
          statusCode = code
          return {
            send(payload: unknown) {
              body = payload
            },
          }
        },
      }),
    }),
  }

  filter.catch(new BadRequestException('فیلد نامعتبر'), host as never)
  assert.equal(statusCode, 400)
  assert.deepEqual(body, { error: 'فیلد نامعتبر' })
}

function runSchemaMigrationsTwice(dbService: DatabaseService) {
  const db = dbService.getDb()
  runSchemaMigrations(db)
  runSchemaMigrations(db)
  const check = dbService.verifyMigrationsApplied()
  assert.equal(check.ok, true)
}

async function runTests() {
  testApiExceptionFilterShape()

  const app = await createApp()
  const dbService = app.get(DatabaseService)

  try {
    // 1–2. auth_accounts migration + idempotent re-run
    const firstMigration = dbService.verifyMigrationsApplied()
    assert.equal(firstMigration.ok, true, `missing tables: ${firstMigration.missing.join(', ')}`)
    assert.ok(firstMigration.tables.includes('auth_accounts'))
    runSchemaMigrationsTwice(dbService)

    const health = await app.inject({ method: 'GET', url: '/health' })
    assert.equal(health.statusCode, 200)

    // 13. request without token → 401
    const unauthorized = await app.inject({ method: 'GET', url: '/api/me' })
    assert.equal(unauthorized.statusCode, 401)
    assert.deepEqual(parseJson(unauthorized.payload), { error: 'لطفاً وارد شوید' })

    // 10. demo / 123456 on seed
    const demoLogin = await app.inject({
      method: 'POST',
      url: '/api/auth/login',
      payload: { username: 'demo', password: '123456' },
    })
    assert.equal(demoLogin.statusCode, 200)
    const demoBody = parseJson<{
      token: string
      user: { id: string; username: string; name: string }
      me: Record<string, unknown>
    }>(demoLogin.payload)
    assert.equal(demoBody.user.id, 'demo')
    assert.equal(demoBody.user.username, 'demo')
    assert.ok(demoBody.token)
    assertMeResponseShape(demoBody.me)

    // 11. JWT payload contains userId
    const jwtService = app.get(JwtService)
    const decoded = jwtService.decode(demoBody.token) as { userId?: string }
    assert.equal(decoded.userId, 'demo')

    // 12. token signed with legacy-compatible secret accepted by Nest
    const legacyToken = jwtService.sign({ userId: 'demo' })
    const meWithLegacyToken = await app.inject({
      method: 'GET',
      url: '/api/me',
      headers: authHeader(legacyToken),
    })
    assert.equal(meWithLegacyToken.statusCode, 200)
    assertMeResponseShape(parseJson(meWithLegacyToken.payload))

    // 14. malformed token → 401
    const badToken = await app.inject({
      method: 'GET',
      url: '/api/me',
      headers: { authorization: 'Bearer not-a-valid-jwt' },
    })
    assert.equal(badToken.statusCode, 401)
    assert.deepEqual(parseJson(badToken.payload), {
      error: 'نشست نامعتبر است. دوباره وارد شوید',
    })

    // 3. register success
    const username = `user_${randomUUID().slice(0, 8)}`
    const registerRes = await app.inject({
      method: 'POST',
      url: '/api/auth/register',
      payload: { username, password: 'secret12', name: 'کاربر تست' },
    })
    assert.equal(registerRes.statusCode, 200)
    const registerBody = parseJson<{
      token: string
      user: { id: string; username: string; name: string }
      me: Record<string, unknown>
    }>(registerRes.payload)
    assert.equal(registerBody.user.username, username.toLowerCase())
    assert.equal(registerBody.user.name, 'کاربر تست')
    assert.ok(registerBody.token)
    assertMeResponseShape(registerBody.me)
    assert.equal(JSON.stringify(registerRes.payload).includes('password_hash'), false)
    assert.equal(JSON.stringify(registerRes.payload).includes('passwordHash'), false)

    // 6. password hash not leaked in API
    const hashRow = dbService
      .getDb()
      .prepare('SELECT password_hash FROM auth_accounts WHERE username = ?')
      .get(username.toLowerCase()) as { password_hash: string }
    assert.ok(bcrypt.compareSync('secret12', hashRow.password_hash))

    // 4. duplicate username → 409
    const duplicate = await app.inject({
      method: 'POST',
      url: '/api/auth/register',
      payload: { username, password: 'secret12' },
    })
    assert.equal(duplicate.statusCode, 409)
    assert.deepEqual(parseJson(duplicate.payload), { error: 'این نام کاربری قبلاً ثبت شده' })

    // 5 + 22. unknown/extra fields rejected on register
    const extraField = await app.inject({
      method: 'POST',
      url: '/api/auth/register',
      headers: { 'content-type': 'application/json' },
      payload: JSON.stringify({ username: 'extra_user', password: 'secret12', hacker: true }),
    })
    assert.equal(extraField.statusCode, 400)

    // 7. login success
    const loginRes = await app.inject({
      method: 'POST',
      url: '/api/auth/login',
      payload: { username, password: 'secret12' },
    })
    assert.equal(loginRes.statusCode, 200)
    const loginBody = parseJson<{ token: string; user: { username: string } }>(loginRes.payload)
    assert.equal(loginBody.user.username, username.toLowerCase())

    // 8–9. login failures
    const badUser = await app.inject({
      method: 'POST',
      url: '/api/auth/login',
      payload: { username: 'nobody_here', password: 'secret12' },
    })
    assert.equal(badUser.statusCode, 401)
    assert.deepEqual(parseJson(badUser.payload), { error: 'نام کاربری یا رمز عبور اشتباه است' })

    const badPass = await app.inject({
      method: 'POST',
      url: '/api/auth/login',
      payload: { username, password: 'wrongpass' },
    })
    assert.equal(badPass.statusCode, 401)
    assert.deepEqual(parseJson(badPass.payload), { error: 'نام کاربری یا رمز عبور اشتباه است' })

    // Legacy hash compatibility — pre-existing bcrypt hash verifies
    const legacyUser = `legacy_${randomUUID().slice(0, 8)}`
    const legacyUserId = randomUUID()
    const legacyHash = bcrypt.hashSync('legacyPass1', 10)
    const now = new Date().toISOString()
    dbService.getDb().prepare('INSERT INTO users (id, state_json, updated_at) VALUES (?, ?, ?)').run(
      legacyUserId,
      JSON.stringify({ id: legacyUserId, name: 'Legacy', level: 1, xp: 0, maxXp: 100, coins: 50, cash: 1000, goldGrams: 0, missionProgress: 0, missionTarget: 3, completedChallenges: [], completedLessons: [], completedGames: [], claimedRewards: [], ownedItems: [], achievements: [], mapLevels: [], totalStars: 0, maxStars: 39, marketSelectedRange: '7d', transactions: [] }),
      now,
    )
    dbService.getDb().prepare(
      'INSERT INTO auth_accounts (id, username, password_hash, user_id, created_at) VALUES (?, ?, ?, ?, ?)',
    ).run(randomUUID(), legacyUser, legacyHash, legacyUserId, now)

    const legacyLogin = await app.inject({
      method: 'POST',
      url: '/api/auth/login',
      payload: { username: legacyUser, password: 'legacyPass1' },
    })
    assert.equal(legacyLogin.statusCode, 200)

    const userToken = loginBody.token

    const extraProfileField = await app.inject({
      method: 'PATCH',
      url: '/api/me/profile',
      headers: { ...authHeader(userToken), 'content-type': 'application/json' },
      payload: JSON.stringify({ name: 'نام', extra: true }),
    })
    assert.equal(extraProfileField.statusCode, 400)

    // 15. GET /api/me shape
    const meRes = await app.inject({
      method: 'GET',
      url: '/api/me',
      headers: authHeader(userToken),
    })
    assert.equal(meRes.statusCode, 200)
    const meBody = parseJson<Record<string, unknown>>(meRes.payload)
    assertMeResponseShape(meBody)

    // 16. GET /api/me for JWT user not yet in DB — ensureUser creates user
    const freshUserId = randomUUID()
    const freshToken = jwtService.sign({ userId: freshUserId })
    const freshMe = await app.inject({
      method: 'GET',
      url: '/api/me',
      headers: authHeader(freshToken),
    })
    assert.equal(freshMe.statusCode, 200)
    const freshMeBody = parseJson<{ user: { id: string } }>(freshMe.payload)
    assert.equal(freshMeBody.user.id, freshUserId)

    // corrupted state_json → controlled error
    dbService.getDb().prepare('UPDATE users SET state_json = ? WHERE id = ?').run('{bad json', freshUserId)
    const corruptMe = await app.inject({
      method: 'GET',
      url: '/api/me',
      headers: authHeader(freshToken),
    })
    assert.equal(corruptMe.statusCode, 401)
    assert.deepEqual(parseJson(corruptMe.payload), {
      error: 'نشست نامعتبر است. دوباره وارد شوید',
    })

    // 17–18. profile update persists without wiping other state fields
    const beforeProfile = parseJson<{ user: { name: string }; wallet: { cash: number } }>(
      (
        await app.inject({
          method: 'GET',
          url: '/api/me',
          headers: authHeader(userToken),
        })
      ).payload,
    )
    const originalCash = beforeProfile.wallet.cash

    const profileRes = await app.inject({
      method: 'PATCH',
      url: '/api/me/profile',
      headers: authHeader(userToken),
      payload: { name: 'نام جدید' },
    })
    assert.equal(profileRes.statusCode, 200)
    const profileBody = parseJson<{ user: { name: string }; wallet: { cash: number } }>(
      profileRes.payload,
    )
    assert.equal(profileBody.user.name, 'نام جدید')
    assert.equal(profileBody.wallet.cash, originalCash)

    const profileAgain = await app.inject({
      method: 'GET',
      url: '/api/me',
      headers: authHeader(userToken),
    })
    assert.equal(parseJson<{ user: { name: string } }>(profileAgain.payload).user.name, 'نام جدید')

    const invalidProfile = await app.inject({
      method: 'PATCH',
      url: '/api/me/profile',
      headers: authHeader(userToken),
      payload: { name: '   ' },
    })
    assert.equal(invalidProfile.statusCode, 400)
    assert.deepEqual(parseJson(invalidProfile.payload), { error: 'نام نمایشی الزامی است' })

    // 19–21. password change flow
    const passwordRes = await app.inject({
      method: 'PATCH',
      url: '/api/me/password',
      headers: authHeader(userToken),
      payload: { currentPassword: 'secret12', newPassword: 'newpass9' },
    })
    assert.equal(passwordRes.statusCode, 200)
    assert.deepEqual(parseJson(passwordRes.payload), { ok: true })

    const oldPassLogin = await app.inject({
      method: 'POST',
      url: '/api/auth/login',
      payload: { username, password: 'secret12' },
    })
    assert.equal(oldPassLogin.statusCode, 401)

    const newPassLogin = await app.inject({
      method: 'POST',
      url: '/api/auth/login',
      payload: { username, password: 'newpass9' },
    })
    assert.equal(newPassLogin.statusCode, 200)

    const wrongCurrent = await app.inject({
      method: 'PATCH',
      url: '/api/me/password',
      headers: authHeader(parseJson<{ token: string }>(newPassLogin.payload).token),
      payload: { currentPassword: 'wrong', newPassword: 'another1' },
    })
    assert.equal(wrongCurrent.statusCode, 401)
    assert.deepEqual(parseJson(wrongCurrent.payload), { error: 'رمز عبور فعلی اشتباه است' })

    const shortNew = await app.inject({
      method: 'PATCH',
      url: '/api/me/password',
      headers: authHeader(parseJson<{ token: string }>(newPassLogin.payload).token),
      payload: { currentPassword: 'newpass9', newPassword: '123' },
    })
    assert.equal(shortNew.statusCode, 400)
    assert.deepEqual(parseJson(shortNew.payload), { error: 'رمز عبور جدید باید حداقل ۶ کاراکتر باشد' })

    // password change for user without auth account → 404
    const orphanId = randomUUID()
    const orphanToken = jwtService.sign({ userId: orphanId })
    dbService.getDb().prepare('INSERT INTO users (id, state_json, updated_at) VALUES (?, ?, ?)').run(
      orphanId,
      JSON.stringify({ id: orphanId, name: 'Orphan', level: 1, xp: 0, maxXp: 100, coins: 0, cash: 0, goldGrams: 0, missionProgress: 0, missionTarget: 3, completedChallenges: [], completedLessons: [], completedGames: [], claimedRewards: [], ownedItems: [], achievements: [], mapLevels: [], totalStars: 0, maxStars: 39, marketSelectedRange: '7d', transactions: [] }),
      now,
    )
    const orphanPass = await app.inject({
      method: 'PATCH',
      url: '/api/me/password',
      headers: authHeader(orphanToken),
      payload: { currentPassword: 'x', newPassword: 'yyyyyy' },
    })
    assert.equal(orphanPass.statusCode, 404)
    assert.deepEqual(parseJson(orphanPass.payload), { error: 'حساب کاربری پیدا نشد' })

    // --- Phase D: Gold Land integration ---
    const { getGradableQuestions } = await import('../src/gold-land/lessons/lesson.grader')
    const { inflationLesson } = await import('../src/gold-land/lessons/inflation.lesson')
    const { GOLD_LAND_LEVELS } = await import('../src/gold-land/levels/levels')

    const glToken = parseJson<{ token: string }>(newPassLogin.payload).token

    const levelsMeta = await app.inject({
      method: 'GET',
      url: '/api/gold-land/levels',
      headers: authHeader(glToken),
    })
    assert.equal(levelsMeta.statusCode, 200)
    const levelsBody = parseJson<{ levels: Array<{ id: number; isActive: boolean }> }>(levelsMeta.payload)
    assert.equal(levelsBody.levels.length, GOLD_LAND_LEVELS.length)
    assert.equal(levelsBody.levels.filter((l) => l.isActive).length, 6)

    const noAuthProgress = await app.inject({ method: 'GET', url: '/api/gold-land/progress' })
    assert.equal(noAuthProgress.statusCode, 401)

    const progressRes = await app.inject({
      method: 'GET',
      url: '/api/gold-land/progress',
      headers: authHeader(glToken),
    })
    assert.equal(progressRes.statusCode, 200)
    const progressBody = parseJson<{
      levels: Array<{ id: number; status: string }>
      totalStars: number
      maxStars: number
    }>(progressRes.payload)
    assert.equal(progressBody.maxStars, 39)
    assert.equal(progressBody.levels.find((l) => l.id === 1)?.status !== 'locked', true)
    assert.equal(progressBody.levels.find((l) => l.id === 6)?.status, 'locked')

    const lockedStart = await app.inject({
      method: 'POST',
      url: '/api/gold-land/levels/6/start',
      headers: authHeader(glToken),
    })
    assert.equal(lockedStart.statusCode, 403)

    const glUserId = dbService
      .getDb()
      .prepare('SELECT user_id FROM auth_accounts WHERE username = ?')
      .get(username.toLowerCase()) as { user_id: string }
    for (let levelId = 1; levelId <= 5; levelId++) {
      dbService.getDb().prepare(`
        INSERT INTO user_level_progress (
          user_id, level_id, best_score, stars, attempts_count, started_at, completed_at, updated_at
        ) VALUES (?, ?, 65, 1, 1, ?, ?, ?)
        ON CONFLICT(user_id, level_id) DO UPDATE SET stars = 1, best_score = 65, completed_at = excluded.completed_at
      `).run(glUserId.user_id, levelId, now, now, now)
    }

    const levelDetail = await app.inject({
      method: 'GET',
      url: '/api/gold-land/levels/6',
      headers: authHeader(glToken),
    })
    assert.equal(levelDetail.statusCode, 200)
    assert.ok(!levelDetail.payload.includes('correctAnswerId'))
    assert.ok(!levelDetail.payload.includes('correctOrder'))

    const startRes = await app.inject({
      method: 'POST',
      url: '/api/gold-land/levels/6/start',
      headers: authHeader(glToken),
    })
    assert.equal(startRes.statusCode, 200)
    assert.deepEqual(parseJson(startRes.payload), { levelId: 6, status: 'in_progress' })

    const inflationAnswers = getGradableQuestions(inflationLesson).map(({ questionId, step }) => {
      if (step.type === 'sort') {
        return { questionId, orderedItemIds: [...step.correctOrder] }
      }
      return { questionId, answerId: step.correctAnswerId }
    })

    const completeRes = await app.inject({
      method: 'POST',
      url: '/api/gold-land/levels/6/complete',
      headers: { ...authHeader(glToken), 'content-type': 'application/json' },
      payload: JSON.stringify({ answers: inflationAnswers, durationMs: 5000 }),
    })
    assert.equal(completeRes.statusCode, 200)
    const completeBody = parseJson<{
      levelId: number
      stars: number
      score: number
      reward: { xp: number; coins: number }
      me: { progress: { mapLevels: Array<{ id: number; stars: number }> } }
    }>(completeRes.payload)
    assert.equal(completeBody.levelId, 6)
    assert.equal(completeBody.stars, 3)
    assert.equal(completeBody.score, 100)
    assert.ok(completeBody.reward.xp > 0)
    assert.equal(completeBody.me.progress.mapLevels.find((l) => l.id === 6)?.stars, 3)

    const meAfter = await app.inject({
      method: 'GET',
      url: '/api/me',
      headers: authHeader(glToken),
    })
    assert.equal(meAfter.statusCode, 200)
    const glMeBody = parseJson<{ progress: { mapLevels: Array<{ id: number; stars: number }> } }>(
      meAfter.payload,
    )
    assert.equal(glMeBody.progress.mapLevels.find((l) => l.id === 6)?.stars, 3)

    const duplicateComplete = await app.inject({
      method: 'POST',
      url: '/api/gold-land/levels/6/complete',
      headers: { ...authHeader(glToken), 'content-type': 'application/json' },
      payload: JSON.stringify({ answers: inflationAnswers }),
    })
    assert.equal(duplicateComplete.statusCode, 200)
    assert.equal(parseJson<{ reward: { xp: number } }>(duplicateComplete.payload).reward.xp, 0)

    const extraFieldComplete = await app.inject({
      method: 'POST',
      url: '/api/gold-land/levels/6/complete',
      headers: { ...authHeader(glToken), 'content-type': 'application/json' },
      payload: JSON.stringify({ answers: inflationAnswers, score: 100 }),
    })
    assert.equal(extraFieldComplete.statusCode, 400)

    // --- Phase E: Wallet + Market integration ---
    const { GOLD_PRICE } = await import('../src/shared/catalog/market.constants')

    const walletUser = `wallet_${randomUUID().slice(0, 8)}`
    const walletUserId = randomUUID()
    const walletHash = bcrypt.hashSync('walletPass1', 10)
    const walletState = {
      id: walletUserId,
      name: 'Wallet Test',
      level: 5,
      xp: 100,
      maxXp: 200,
      coins: 10_000,
      cash: 100_000,
      goldGrams: 42.5,
      missionProgress: 3,
      missionTarget: 20,
      completedChallenges: ['ch-1'],
      completedLessons: ['lesson-1'],
      completedGames: ['game-1'],
      claimedRewards: ['reward-1'],
      ownedItems: ['item-1'],
      achievements: [
        { id: 'first-gold', title: 'اولین خرید طلا', description: 'd', icon: '🥇', unlocked: false },
      ],
      mapLevels: [{ id: 1, title: 'تست', stars: 2, maxStars: 3, status: 'completed', x: 10, y: 20 }],
      totalStars: 2,
      maxStars: 39,
      marketSelectedRange: '1d',
      transactions: [
        { id: 'seed-1', type: 'expense', title: 'خرید طلا', amount: 1000, unit: 'تومان', date: '۱۴۰۴/۰۱/۰۱' },
      ],
    }
    dbService.getDb().prepare('INSERT INTO users (id, state_json, updated_at) VALUES (?, ?, ?)').run(
      walletUserId,
      JSON.stringify(walletState),
      now,
    )
    dbService.getDb().prepare(
      'INSERT INTO auth_accounts (id, username, password_hash, user_id, created_at) VALUES (?, ?, ?, ?, ?)',
    ).run(randomUUID(), walletUser, walletHash, walletUserId, now)

    const walletLogin = await app.inject({
      method: 'POST',
      url: '/api/auth/login',
      payload: { username: walletUser, password: 'walletPass1' },
    })
    assert.equal(walletLogin.statusCode, 200)
    const walletToken = parseJson<{ token: string }>(walletLogin.payload).token

    const walletEndpoints = [
      { method: 'GET' as const, url: '/api/wallet/transactions' },
      { method: 'POST' as const, url: '/api/wallet/gold/buy', payload: { grams: 0.01 } },
      { method: 'POST' as const, url: '/api/wallet/gold/sell', payload: { grams: 0.01 } },
      { method: 'GET' as const, url: '/api/market/gold?range=1d' },
      { method: 'PATCH' as const, url: '/api/market/preferences', payload: { range: '7d' } },
    ]
    for (const ep of walletEndpoints) {
      const unauth = await app.inject({
        method: ep.method,
        url: ep.url,
        payload: ep.payload,
      })
      assert.equal(unauth.statusCode, 401, `expected 401 for ${ep.method} ${ep.url}`)
    }

    const txRes = await app.inject({
      method: 'GET',
      url: '/api/wallet/transactions',
      headers: authHeader(walletToken),
    })
    assert.equal(txRes.statusCode, 200)
    const txBody = parseJson<{ transactions: Array<{ id: string; type: string; title: string }> }>(
      txRes.payload,
    )
    assert.ok(Array.isArray(txBody.transactions))
    assert.equal(txBody.transactions.length, 1)
    assert.equal(txBody.transactions[0].id, 'seed-1')

    const marketRes = await app.inject({
      method: 'GET',
      url: '/api/market/gold?range=7d',
      headers: authHeader(walletToken),
    })
    assert.equal(marketRes.statusCode, 200)
    const marketBody = parseJson<{
      currentPrice: number
      dailyChangePercent: number
      range: string
      history: number[]
      updatedAt: string
    }>(marketRes.payload)
    assert.equal(marketBody.currentPrice, GOLD_PRICE)
    assert.equal(marketBody.dailyChangePercent, 2.4)
    assert.equal(marketBody.range, '7d')
    assert.ok(Array.isArray(marketBody.history))
    assert.equal(marketBody.history.length, 28)
    assert.equal(marketBody.history[marketBody.history.length - 1], GOLD_PRICE)
    assert.ok(marketBody.updatedAt)

    const buyRes = await app.inject({
      method: 'POST',
      url: '/api/wallet/gold/buy',
      headers: { ...authHeader(walletToken), 'content-type': 'application/json' },
      payload: JSON.stringify({ grams: 0.05 }),
    })
    assert.equal(buyRes.statusCode, 200)
    const buyBody = parseJson<{
      wallet: { cash: number; goldGrams: number }
      transactions: Array<{ type: string; title: string; amount: number; unit: string }>
      progress: { completedChallenges: string[]; mapLevels: Array<{ id: number; stars: number }> }
      achievements: Array<{ id: string; unlocked: boolean }>
    }>(buyRes.payload)
    assert.equal(buyBody.wallet.cash, 100_000 - 0.05 * GOLD_PRICE)
    assert.equal(buyBody.wallet.goldGrams, 42.55)
    assert.ok(buyBody.wallet.cash >= 0)
    assert.ok(buyBody.wallet.goldGrams >= 0)
    assert.equal(buyBody.transactions[0].type, 'expense')
    assert.equal(buyBody.transactions[0].title, 'خرید طلا')
    assert.equal(buyBody.transactions[0].amount, 0.05 * GOLD_PRICE)
    assert.equal(buyBody.transactions[0].unit, 'تومان')
    assert.deepEqual(buyBody.progress.completedChallenges, ['ch-1'])
    assert.equal(buyBody.progress.mapLevels[0].stars, 2)
    assert.equal(buyBody.achievements.find((a) => a.id === 'first-gold')?.unlocked, true)

    const meAfterBuy = await app.inject({
      method: 'GET',
      url: '/api/me',
      headers: authHeader(walletToken),
    })
    assert.equal(meAfterBuy.statusCode, 200)
    const meBuyBody = parseJson<{ wallet: { cash: number; goldGrams: number } }>(meAfterBuy.payload)
    assert.equal(meBuyBody.wallet.cash, buyBody.wallet.cash)
    assert.equal(meBuyBody.wallet.goldGrams, buyBody.wallet.goldGrams)

    const sellRes = await app.inject({
      method: 'POST',
      url: '/api/wallet/gold/sell',
      headers: { ...authHeader(walletToken), 'content-type': 'application/json' },
      payload: JSON.stringify({ grams: 0.001 }),
    })
    assert.equal(sellRes.statusCode, 200)
    const sellBody = parseJson<{
      wallet: { cash: number; goldGrams: number }
      transactions: Array<{ type: string; title: string; amount: number }>
    }>(sellRes.payload)
    assert.equal(sellBody.wallet.goldGrams, 42.549)
    assert.equal(sellBody.wallet.cash, buyBody.wallet.cash + 0.001 * GOLD_PRICE)
    assert.equal(sellBody.transactions[0].type, 'income')
    assert.equal(sellBody.transactions[0].title, 'فروش طلا')
    assert.equal(sellBody.transactions[0].amount, 0.001 * GOLD_PRICE)

    const meAfterSell = await app.inject({
      method: 'GET',
      url: '/api/me',
      headers: authHeader(walletToken),
    })
    assert.equal(meAfterSell.statusCode, 200)
    const meSellBody = parseJson<{ wallet: { cash: number; goldGrams: number } }>(meAfterSell.payload)
    assert.equal(meSellBody.wallet.cash, sellBody.wallet.cash)
    assert.equal(meSellBody.wallet.goldGrams, sellBody.wallet.goldGrams)

    const zeroBuy = await app.inject({
      method: 'POST',
      url: '/api/wallet/gold/buy',
      headers: authHeader(walletToken),
      payload: { grams: 0 },
    })
    assert.equal(zeroBuy.statusCode, 400)
    assert.deepEqual(parseJson(zeroBuy.payload), { error: 'مقدار نامعتبر است' })

    const negativeBuy = await app.inject({
      method: 'POST',
      url: '/api/wallet/gold/buy',
      headers: authHeader(walletToken),
      payload: { grams: -1 },
    })
    assert.equal(negativeBuy.statusCode, 400)
    assert.deepEqual(parseJson(negativeBuy.payload), { error: 'مقدار نامعتبر است' })

    const nanBuy = await app.inject({
      method: 'POST',
      url: '/api/wallet/gold/buy',
      headers: authHeader(walletToken),
      payload: { grams: Number.NaN },
    })
    assert.equal(nanBuy.statusCode, 400)

    const infinityBuy = await app.inject({
      method: 'POST',
      url: '/api/wallet/gold/buy',
      headers: authHeader(walletToken),
      payload: { grams: Number.POSITIVE_INFINITY },
    })
    assert.equal(infinityBuy.statusCode, 400)

    const extraFieldBuy = await app.inject({
      method: 'POST',
      url: '/api/wallet/gold/buy',
      headers: { ...authHeader(walletToken), 'content-type': 'application/json' },
      payload: JSON.stringify({ grams: 0.01, goldPrice: 1 }),
    })
    assert.equal(extraFieldBuy.statusCode, 400)

    const stateBeforeFail = (
      dbService.getDb().prepare('SELECT state_json FROM users WHERE id = ?').get(walletUserId) as {
        state_json: string
      }
    ).state_json

    const insufficientCash = await app.inject({
      method: 'POST',
      url: '/api/wallet/gold/buy',
      headers: authHeader(walletToken),
      payload: { grams: 1000 },
    })
    assert.equal(insufficientCash.statusCode, 400)
    assert.deepEqual(parseJson(insufficientCash.payload), { error: 'موجودی نقد کافی نیست' })

    const stateAfterFailBuy = (
      dbService.getDb().prepare('SELECT state_json FROM users WHERE id = ?').get(walletUserId) as {
        state_json: string
      }
    ).state_json
    assert.equal(stateAfterFailBuy, stateBeforeFail, 'failed buy must rollback state')

    const insufficientGold = await app.inject({
      method: 'POST',
      url: '/api/wallet/gold/sell',
      headers: authHeader(walletToken),
      payload: { grams: 9999 },
    })
    assert.equal(insufficientGold.statusCode, 400)
    assert.deepEqual(parseJson(insufficientGold.payload), { error: 'طلای کافی نداری' })

    const stateAfterFailSell = (
      dbService.getDb().prepare('SELECT state_json FROM users WHERE id = ?').get(walletUserId) as {
        state_json: string
      }
    ).state_json
    assert.equal(stateAfterFailSell, stateBeforeFail, 'failed sell must rollback state')

    const prefsRes = await app.inject({
      method: 'PATCH',
      url: '/api/market/preferences',
      headers: authHeader(walletToken),
      payload: { range: '30d' },
    })
    assert.equal(prefsRes.statusCode, 200)
    const prefsBody = parseJson<{ market: { selectedRange: string }; progress: { completedLessons: string[] } }>(
      prefsRes.payload,
    )
    assert.equal(prefsBody.market.selectedRange, '30d')
    assert.deepEqual(prefsBody.progress.completedLessons, ['lesson-1'])

    const extraFieldPrefs = await app.inject({
      method: 'PATCH',
      url: '/api/market/preferences',
      headers: { ...authHeader(walletToken), 'content-type': 'application/json' },
      payload: JSON.stringify({ range: '7d', extra: true }),
    })
    assert.equal(extraFieldPrefs.statusCode, 400)

    const invalidRangePrefs = await app.inject({
      method: 'PATCH',
      url: '/api/market/preferences',
      headers: authHeader(walletToken),
      payload: { range: 'invalid' },
    })
    assert.equal(invalidRangePrefs.statusCode, 400)

    const invalidMarketRange = await app.inject({
      method: 'GET',
      url: '/api/market/gold?range=invalid',
      headers: authHeader(walletToken),
    })
    assert.equal(invalidMarketRange.statusCode, 200)
    const invalidRangeBody = parseJson<{ range: string; history: number[] }>(invalidMarketRange.payload)
    assert.equal(invalidRangeBody.range, 'invalid')
    assert.equal(invalidRangeBody.history.length, 24)

    // precision: third decimal trade
    const precisionBuy = await app.inject({
      method: 'POST',
      url: '/api/wallet/gold/buy',
      headers: authHeader(walletToken),
      payload: { grams: 0.005 },
    })
    assert.equal(precisionBuy.statusCode, 200)
    const precisionBody = parseJson<{ wallet: { cash: number; goldGrams: number } }>(precisionBuy.payload)
    assert.equal(precisionBody.wallet.goldGrams, sellBody.wallet.goldGrams + 0.005)
    assert.equal(precisionBody.wallet.cash, sellBody.wallet.cash - 0.005 * GOLD_PRICE)
    assert.ok(precisionBody.wallet.cash >= 0)
    assert.ok(precisionBody.wallet.goldGrams >= 0)

    // transaction order: newest first
    const txOrder = parseJson<{ transactions: Array<{ title: string }> }>(precisionBuy.payload)
    assert.equal(txOrder.transactions[0].title, 'خرید طلا')

    // --- Phase F1: Store integration ---
    const { STORE_PRODUCTS } = await import('../src/shared/catalog/store.constants')

    const storeUser = `store_${randomUUID().slice(0, 8)}`
    const storeUserId = randomUUID()
    const storeHash = bcrypt.hashSync('storePass1', 10)
    const storeState = {
      id: storeUserId,
      name: 'Store Test',
      level: 5,
      xp: 100,
      maxXp: 200,
      coins: 10_000,
      cash: 50_000,
      goldGrams: 10,
      missionProgress: 7,
      missionTarget: 20,
      completedChallenges: ['ch-a'],
      completedLessons: ['lesson-a'],
      completedGames: ['game-a'],
      claimedRewards: ['reward-a'],
      ownedItems: [] as string[],
      achievements: [
        { id: 'first-gold', title: 'اولین خرید طلا', description: 'd', icon: '🥇', unlocked: true },
        { id: 'market', title: 'شاگرد بازار', description: 'd', icon: '📊', unlocked: false },
      ],
      mapLevels: [{ id: 1, title: 'تست', stars: 1, maxStars: 3, status: 'completed', x: 10, y: 20 }],
      totalStars: 1,
      maxStars: 39,
      marketSelectedRange: '7d',
      transactions: [
        { id: 'seed-tx', type: 'income', title: 'seed', amount: 1, unit: 'سکه', date: '۱۴۰۴/۰۱/۰۱' },
      ],
    }
    dbService.getDb().prepare('INSERT INTO users (id, state_json, updated_at) VALUES (?, ?, ?)').run(
      storeUserId,
      JSON.stringify(storeState),
      now,
    )
    dbService.getDb().prepare(
      'INSERT INTO auth_accounts (id, username, password_hash, user_id, created_at) VALUES (?, ?, ?, ?, ?)',
    ).run(randomUUID(), storeUser, storeHash, storeUserId, now)

    const storeLogin = await app.inject({
      method: 'POST',
      url: '/api/auth/login',
      payload: { username: storeUser, password: 'storePass1' },
    })
    assert.equal(storeLogin.statusCode, 200)
    const storeToken = parseJson<{ token: string }>(storeLogin.payload).token

    const storeUnauthGet = await app.inject({ method: 'GET', url: '/api/store/products' })
    assert.equal(storeUnauthGet.statusCode, 401)
    const storeUnauthPost = await app.inject({
      method: 'POST',
      url: '/api/store/purchases',
      payload: { productId: 'suit' },
    })
    assert.equal(storeUnauthPost.statusCode, 401)

    const productsRes = await app.inject({
      method: 'GET',
      url: '/api/store/products',
      headers: authHeader(storeToken),
    })
    assert.equal(productsRes.statusCode, 200)
    const productsBody = parseJson<
      Array<{ id: string; title: string; price: number; category: string; emoji: string }>
    >(productsRes.payload)
    assert.equal(productsBody.length, 6)
    assert.deepEqual(
      productsBody.map((p) => p.id),
      STORE_PRODUCTS.map((p) => p.id),
    )
    assert.equal(productsBody[0].title, 'قلعه طلایی')
    assert.equal(productsBody[0].price, 5000)
    assert.equal(productsBody[0].category, 'special')
    assert.equal(productsBody[0].emoji, '🏰')

    const stateBeforeAnyPurchase = (
      dbService.getDb().prepare('SELECT state_json FROM users WHERE id = ?').get(storeUserId) as {
        state_json: string
      }
    ).state_json
    const lowCoinsState = JSON.parse(stateBeforeAnyPurchase) as typeof storeState
    lowCoinsState.coins = 100
    const lowCoinsJson = JSON.stringify(lowCoinsState)
    dbService.getDb().prepare('UPDATE users SET state_json = ? WHERE id = ?').run(lowCoinsJson, storeUserId)

    const insufficientCoins = await app.inject({
      method: 'POST',
      url: '/api/store/purchases',
      headers: authHeader(storeToken),
      payload: { productId: 'castle' },
    })
    assert.equal(insufficientCoins.statusCode, 400)
    assert.deepEqual(parseJson(insufficientCoins.payload), { error: 'سکه کافی نداری!' })
    const stateAfterInsufficient = (
      dbService.getDb().prepare('SELECT state_json FROM users WHERE id = ?').get(storeUserId) as {
        state_json: string
      }
    ).state_json
    assert.equal(stateAfterInsufficient, lowCoinsJson)

    lowCoinsState.coins = 10_000
    dbService.getDb().prepare('UPDATE users SET state_json = ? WHERE id = ?').run(
      JSON.stringify(lowCoinsState),
      storeUserId,
    )

    const purchaseRes = await app.inject({
      method: 'POST',
      url: '/api/store/purchases',
      headers: authHeader(storeToken),
      payload: { productId: 'suit' },
    })
    assert.equal(purchaseRes.statusCode, 200)
    const purchaseBody = parseJson<{
      user: { coins: number; missionProgress: number; level: number; xp: number }
      progress: { ownedItems: string[]; completedGames: string[] }
      transactions: Array<{ type: string; title: string; amount: number; unit: string }>
      achievements: Array<{ id: string; unlocked: boolean }>
    }>(purchaseRes.payload)
    assert.equal(purchaseBody.user.coins, 10_000 - 2500)
    assert.deepEqual(purchaseBody.progress.ownedItems, ['suit'])
    assert.equal(purchaseBody.transactions[0].type, 'expense')
    assert.equal(purchaseBody.transactions[0].title, 'خرید لباس ماجراجو')
    assert.equal(purchaseBody.transactions[0].amount, 2500)
    assert.equal(purchaseBody.transactions[0].unit, 'سکه')
    assert.equal(purchaseBody.user.missionProgress, 7)
    assert.equal(purchaseBody.user.level, 5)
    assert.equal(purchaseBody.user.xp, 100)
    assert.equal(purchaseBody.achievements.find((a) => a.id === 'market')?.unlocked, false)
    assert.deepEqual(purchaseBody.progress.completedGames, ['game-a'])

    const meAfterPurchase = await app.inject({
      method: 'GET',
      url: '/api/me',
      headers: authHeader(storeToken),
    })
    assert.equal(meAfterPurchase.statusCode, 200)
    const mePurchaseBody = parseJson<{
      user: { coins: number }
      progress: { ownedItems: string[] }
    }>(meAfterPurchase.payload)
    assert.equal(mePurchaseBody.user.coins, 7500)
    assert.deepEqual(mePurchaseBody.progress.ownedItems, ['suit'])

    const stateBeforeDuplicate = (
      dbService.getDb().prepare('SELECT state_json FROM users WHERE id = ?').get(storeUserId) as {
        state_json: string
      }
    ).state_json

    const duplicatePurchase = await app.inject({
      method: 'POST',
      url: '/api/store/purchases',
      headers: authHeader(storeToken),
      payload: { productId: 'suit' },
    })
    assert.equal(duplicatePurchase.statusCode, 409)
    assert.deepEqual(parseJson(duplicatePurchase.payload), { error: 'قبلاً خریدی!' })
    const stateAfterDuplicate = (
      dbService.getDb().prepare('SELECT state_json FROM users WHERE id = ?').get(storeUserId) as {
        state_json: string
      }
    ).state_json
    assert.equal(stateAfterDuplicate, stateBeforeDuplicate)

    const invalidProduct = await app.inject({
      method: 'POST',
      url: '/api/store/purchases',
      headers: authHeader(storeToken),
      payload: { productId: 'not-a-product' },
    })
    assert.equal(invalidProduct.statusCode, 404)
    assert.deepEqual(parseJson(invalidProduct.payload), { error: 'محصول پیدا نشد' })

    const emptyProductId = await app.inject({
      method: 'POST',
      url: '/api/store/purchases',
      headers: authHeader(storeToken),
      payload: { productId: '' },
    })
    assert.equal(emptyProductId.statusCode, 400)

    const emptyBody = await app.inject({
      method: 'POST',
      url: '/api/store/purchases',
      headers: { ...authHeader(storeToken), 'content-type': 'application/json' },
      payload: JSON.stringify({}),
    })
    assert.equal(emptyBody.statusCode, 400)

    const extraFieldPurchase = await app.inject({
      method: 'POST',
      url: '/api/store/purchases',
      headers: { ...authHeader(storeToken), 'content-type': 'application/json' },
      payload: JSON.stringify({ productId: 'pet', price: 1 }),
    })
    assert.equal(extraFieldPurchase.statusCode, 400)

    const clientPriceField = await app.inject({
      method: 'POST',
      url: '/api/store/purchases',
      headers: { ...authHeader(storeToken), 'content-type': 'application/json' },
      payload: JSON.stringify({ productId: 'pet', coins: 99999 }),
    })
    assert.equal(clientPriceField.statusCode, 400)

    const boostPurchase = await app.inject({
      method: 'POST',
      url: '/api/store/purchases',
      headers: authHeader(storeToken),
      payload: { productId: 'boost-xp' },
    })
    assert.equal(boostPurchase.statusCode, 200)
    const boostBody = parseJson<{
      user: { coins: number; level: number; xp: number; maxXp: number }
      progress: { ownedItems: string[] }
      transactions: Array<{ title: string; amount: number }>
    }>(boostPurchase.payload)
    assert.equal(boostBody.user.coins, 7500 - 800)
    assert.ok(boostBody.progress.ownedItems.includes('boost-xp'))
    assert.equal(boostBody.user.level, 5)
    assert.equal(boostBody.user.xp, 100)
    assert.equal(boostBody.transactions[0].title, 'خرید تقویت XP')
    assert.equal(boostBody.transactions[0].amount, 800)

    // --- Phase F2: Games integration ---
    const { GAMES } = await import('../src/shared/catalog/games.constants')

    const gamesUser = `games_${randomUUID().slice(0, 8)}`
    const gamesUserId = randomUUID()
    const gamesHash = bcrypt.hashSync('gamesPass1', 10)
    const gamesState = {
      id: gamesUserId,
      name: 'Games Test',
      level: 5,
      xp: 100,
      maxXp: 200,
      coins: 1000,
      cash: 20_000,
      goldGrams: 5,
      missionProgress: 4,
      missionTarget: 20,
      completedChallenges: [],
      completedLessons: [],
      completedGames: [],
      claimedRewards: [],
      ownedItems: ['suit'],
      achievements: [
        { id: 'first-gold', title: 't', description: 'd', icon: '🥇', unlocked: true },
      ],
      mapLevels: [{ id: 2, title: 't', stars: 1, maxStars: 3, status: 'completed', x: 1, y: 2 }],
      totalStars: 1,
      maxStars: 39,
      marketSelectedRange: '1d',
      transactions: [],
    }
    dbService.getDb().prepare('INSERT INTO users (id, state_json, updated_at) VALUES (?, ?, ?)').run(
      gamesUserId,
      JSON.stringify(gamesState),
      now,
    )
    dbService.getDb().prepare(
      'INSERT INTO auth_accounts (id, username, password_hash, user_id, created_at) VALUES (?, ?, ?, ?, ?)',
    ).run(randomUUID(), gamesUser, gamesHash, gamesUserId, now)

    const gamesLogin = await app.inject({
      method: 'POST',
      url: '/api/auth/login',
      payload: { username: gamesUser, password: 'gamesPass1' },
    })
    assert.equal(gamesLogin.statusCode, 200)
    const gamesToken = parseJson<{ token: string }>(gamesLogin.payload).token

    const gamesUnauthGet = await app.inject({ method: 'GET', url: '/api/games' })
    assert.equal(gamesUnauthGet.statusCode, 401)
    const gamesUnauthPost = await app.inject({
      method: 'POST',
      url: '/api/games/gold-guess/complete',
      payload: {},
    })
    assert.equal(gamesUnauthPost.statusCode, 401)

    const gamesListRes = await app.inject({
      method: 'GET',
      url: '/api/games',
      headers: authHeader(gamesToken),
    })
    assert.equal(gamesListRes.statusCode, 200)
    const gamesList = parseJson<
      Array<{ id: string; route?: string; rewardCoins?: number; rewardXp?: number }>
    >(gamesListRes.payload)
    assert.equal(gamesList.length, 6)
    assert.deepEqual(
      gamesList.map((g) => g.id),
      GAMES.map((g) => g.id),
    )
    assert.equal(gamesList[0].route, '/games/gold-guess')
    assert.equal(gamesList[0].rewardCoins, 20)
    assert.equal(gamesList[0].rewardXp, 50)
    assert.equal(gamesList[1].route, '/lessons/inflation')
    assert.equal(gamesList[1].rewardXp, 40)
    assert.equal(gamesList[1].rewardCoins, undefined)

    const completeGoldGuess = await app.inject({
      method: 'POST',
      url: '/api/games/gold-guess/complete',
      headers: { ...authHeader(gamesToken), 'content-type': 'application/json' },
      payload: JSON.stringify({}),
    })
    assert.equal(completeGoldGuess.statusCode, 200)
    const goldGuessBody = parseJson<{
      user: { coins: number; xp: number; level: number; missionProgress: number }
      progress: { claimedRewards: string[]; completedGames: string[]; ownedItems: string[] }
      transactions: Array<{ type: string; title: string; amount: number; unit: string }>
      achievements: Array<{ id: string; unlocked: boolean }>
    }>(completeGoldGuess.payload)
    assert.equal(goldGuessBody.user.coins, 1020)
    assert.equal(goldGuessBody.user.xp, 150)
    assert.equal(goldGuessBody.user.level, 5)
    assert.deepEqual(goldGuessBody.progress.claimedRewards, ['gold-guess'])
    assert.deepEqual(goldGuessBody.progress.completedGames, ['gold-guess'])
    assert.equal(goldGuessBody.transactions[0].type, 'income')
    assert.equal(goldGuessBody.transactions[0].title, 'پاداش بازی')
    assert.equal(goldGuessBody.transactions[0].amount, 20)
    assert.equal(goldGuessBody.transactions[0].unit, 'سکه')
    assert.equal(goldGuessBody.user.missionProgress, 4)
    assert.deepEqual(goldGuessBody.progress.ownedItems, ['suit'])
    assert.equal(goldGuessBody.achievements[0].unlocked, true)

    const meAfterGame = await app.inject({
      method: 'GET',
      url: '/api/me',
      headers: authHeader(gamesToken),
    })
    assert.equal(meAfterGame.statusCode, 200)
    const meGameBody = parseJson<{
      user: { coins: number; xp: number }
      progress: { claimedRewards: string[] }
    }>(meAfterGame.payload)
    assert.equal(meGameBody.user.coins, 1020)
    assert.equal(meGameBody.user.xp, 150)
    assert.deepEqual(meGameBody.progress.claimedRewards, ['gold-guess'])

    const stateBeforeGameDuplicate = (
      dbService.getDb().prepare('SELECT state_json FROM users WHERE id = ?').get(gamesUserId) as {
        state_json: string
      }
    ).state_json

    const duplicateGoldGuess = await app.inject({
      method: 'POST',
      url: '/api/games/gold-guess/complete',
      headers: authHeader(gamesToken),
      payload: {},
    })
    assert.equal(duplicateGoldGuess.statusCode, 200)
    const duplicateBody = parseJson<{ user: { coins: number; xp: number } }>(duplicateGoldGuess.payload)
    assert.equal(duplicateBody.user.coins, 1020)
    assert.equal(duplicateBody.user.xp, 150)
    const stateAfterDuplicateGame = (
      dbService.getDb().prepare('SELECT state_json FROM users WHERE id = ?').get(gamesUserId) as {
        state_json: string
      }
    ).state_json
    assert.equal(stateAfterDuplicateGame, stateBeforeGameDuplicate)

    const completeInflation = await app.inject({
      method: 'POST',
      url: '/api/games/inflation/complete',
      headers: authHeader(gamesToken),
      payload: {},
    })
    assert.equal(completeInflation.statusCode, 200)
    const inflationBody = parseJson<{
      user: { coins: number; xp: number }
      progress: { claimedRewards: string[]; completedGames: string[] }
      transactions: Array<{ title: string }>
    }>(completeInflation.payload)
    assert.equal(inflationBody.user.coins, 1020)
    assert.equal(inflationBody.user.xp, 190)
    assert.ok(inflationBody.progress.claimedRewards.includes('inflation'))
    assert.ok(inflationBody.progress.completedGames.includes('inflation'))
    assert.equal(inflationBody.transactions.length, 1)

    const completePortfolio = await app.inject({
      method: 'POST',
      url: '/api/games/portfolio/complete',
      headers: authHeader(gamesToken),
      payload: {},
    })
    assert.equal(completePortfolio.statusCode, 200)
    const portfolioBody = parseJson<{
      user: { coins: number; xp: number }
      progress: { claimedRewards: string[]; completedGames: string[] }
      transactions: unknown[]
    }>(completePortfolio.payload)
    assert.equal(portfolioBody.user.coins, 1020)
    assert.equal(portfolioBody.user.xp, 190)
    assert.ok(portfolioBody.progress.claimedRewards.includes('portfolio'))
    assert.ok(portfolioBody.progress.completedGames.includes('portfolio'))
    assert.equal(portfolioBody.transactions.length, 1)

    const levelUpUserId = randomUUID()
    const levelUpState = {
      ...gamesState,
      id: levelUpUserId,
      xp: 950,
      maxXp: 100,
      level: 1,
      coins: 500,
      claimedRewards: [],
      completedGames: [],
      transactions: [],
    }
    dbService.getDb().prepare('INSERT INTO users (id, state_json, updated_at) VALUES (?, ?, ?)').run(
      levelUpUserId,
      JSON.stringify(levelUpState),
      now,
    )
    const levelUpToken = jwtService.sign({ userId: levelUpUserId })

    const levelUpComplete = await app.inject({
      method: 'POST',
      url: '/api/games/gold-guess/complete',
      headers: authHeader(levelUpToken),
      payload: {},
    })
    assert.equal(levelUpComplete.statusCode, 200)
    const levelUpBody = parseJson<{ user: { xp: number; level: number; maxXp: number; coins: number } }>(
      levelUpComplete.payload,
    )
    assert.equal(levelUpBody.user.coins, 520)
    assert.equal(levelUpBody.user.level, 7)
    assert.equal(levelUpBody.user.xp, 125)
    assert.equal(levelUpBody.user.maxXp, 231)

    const rollbackUserId = randomUUID()
    const rollbackState = {
      id: rollbackUserId,
      name: 'Rollback Test',
      level: 3,
      xp: 40,
      maxXp: 120,
      coins: 777,
      cash: 12_345,
      goldGrams: 3.5,
      missionProgress: 2,
      missionTarget: 15,
      completedChallenges: ['daily-challenge'],
      completedLessons: ['lesson-x'],
      completedGames: [],
      claimedRewards: [],
      ownedItems: ['castle'],
      achievements: [
        { id: 'saver', title: 't', description: 'd', icon: '💰', unlocked: true },
      ],
      mapLevels: [{ id: 3, title: 'map', stars: 2, maxStars: 3, status: 'current', x: 5, y: 6 }],
      totalStars: 2,
      maxStars: 39,
      marketSelectedRange: '30d',
      transactions: [
        { id: 'rb-1', type: 'income', title: 'seed tx', amount: 10, unit: 'سکه', date: '۱۴۰۴/۰۲/۰۱' },
      ],
    }
    dbService.getDb().prepare('INSERT INTO users (id, state_json, updated_at) VALUES (?, ?, ?)').run(
      rollbackUserId,
      JSON.stringify(rollbackState),
      now,
    )
    const rollbackToken = jwtService.sign({ userId: rollbackUserId })
    const rollbackDb = dbService.getDb()
    const stateBeforeRollback = (
      rollbackDb.prepare('SELECT state_json FROM users WHERE id = ?').get(rollbackUserId) as {
        state_json: string
      }
    ).state_json

    rollbackDb.exec(`
      CREATE TRIGGER test_abort_games_users_update
      BEFORE UPDATE ON users
      WHEN NEW.id = '${rollbackUserId}'
      BEGIN
        SELECT RAISE(ABORT, 'integration test rollback');
      END;
    `)

    try {
      const rollbackComplete = await app.inject({
        method: 'POST',
        url: '/api/games/gold-guess/complete',
        headers: { ...authHeader(rollbackToken), 'content-type': 'application/json' },
        payload: JSON.stringify({}),
      })
      assert.equal(rollbackComplete.statusCode, 500)
      assert.deepEqual(parseJson(rollbackComplete.payload), { error: 'خطای سرور' })

      const stateAfterRollback = (
        rollbackDb.prepare('SELECT state_json FROM users WHERE id = ?').get(rollbackUserId) as {
          state_json: string
        }
      ).state_json
      assert.equal(stateAfterRollback, stateBeforeRollback)

      const beforeParsed = JSON.parse(stateBeforeRollback) as typeof rollbackState
      const afterParsed = JSON.parse(stateAfterRollback) as typeof rollbackState
      assert.equal(afterParsed.coins, beforeParsed.coins)
      assert.equal(afterParsed.xp, beforeParsed.xp)
      assert.equal(afterParsed.level, beforeParsed.level)
      assert.equal(afterParsed.maxXp, beforeParsed.maxXp)
      assert.deepEqual(afterParsed.claimedRewards, beforeParsed.claimedRewards)
      assert.deepEqual(afterParsed.completedGames, beforeParsed.completedGames)
      assert.deepEqual(afterParsed.transactions, beforeParsed.transactions)
      assert.equal(afterParsed.cash, beforeParsed.cash)
      assert.equal(afterParsed.goldGrams, beforeParsed.goldGrams)
      assert.deepEqual(afterParsed.ownedItems, beforeParsed.ownedItems)
      assert.deepEqual(afterParsed.achievements, beforeParsed.achievements)
      assert.equal(afterParsed.missionProgress, beforeParsed.missionProgress)
      assert.deepEqual(afterParsed.mapLevels, beforeParsed.mapLevels)
    } finally {
      rollbackDb.exec('DROP TRIGGER IF EXISTS test_abort_games_users_update')
    }

    const stateBeforeInvalid = (
      dbService.getDb().prepare('SELECT state_json FROM users WHERE id = ?').get(gamesUserId) as {
        state_json: string
      }
    ).state_json

    const invalidGame = await app.inject({
      method: 'POST',
      url: '/api/games/not-a-game/complete',
      headers: authHeader(gamesToken),
      payload: {},
    })
    assert.equal(invalidGame.statusCode, 404)
    assert.deepEqual(parseJson(invalidGame.payload), { error: 'بازی پیدا نشد' })
    const stateAfterInvalid = (
      dbService.getDb().prepare('SELECT state_json FROM users WHERE id = ?').get(gamesUserId) as {
        state_json: string
      }
    ).state_json
    assert.equal(stateAfterInvalid, stateBeforeInvalid)

    const extraFieldGame = await app.inject({
      method: 'POST',
      url: '/api/games/gold-guess/complete',
      headers: { ...authHeader(gamesToken), 'content-type': 'application/json' },
      payload: JSON.stringify({ score: 100 }),
    })
    assert.equal(extraFieldGame.statusCode, 400)

    const rewardFieldGame = await app.inject({
      method: 'POST',
      url: '/api/games/gold-guess/complete',
      headers: { ...authHeader(gamesToken), 'content-type': 'application/json' },
      payload: JSON.stringify({ reward: 999 }),
    })
    assert.equal(rewardFieldGame.statusCode, 400)

    // --- Phase F3: Daily Challenge integration ---
    const { DAILY_CHALLENGE, CHALLENGE_OPTIONS } = await import(
      '../src/shared/catalog/challenge.constants'
    )

    const challengeUser = `challenge_${randomUUID().slice(0, 8)}`
    const challengeUserId = randomUUID()
    const challengeHash = bcrypt.hashSync('challengePass1', 10)
    const challengeState = {
      id: challengeUserId,
      name: 'Challenge Test',
      level: 4,
      xp: 80,
      maxXp: 100,
      coins: 200,
      cash: 5000,
      goldGrams: 2,
      missionProgress: 5,
      missionTarget: 20,
      completedChallenges: [] as string[],
      completedLessons: [],
      completedGames: ['game-a'],
      claimedRewards: ['reward-a'],
      ownedItems: ['pet'],
      achievements: [{ id: 'saver', title: 't', description: 'd', icon: '💰', unlocked: true }],
      mapLevels: [{ id: 1, title: 't', stars: 1, maxStars: 3, status: 'completed', x: 1, y: 2 }],
      totalStars: 1,
      maxStars: 39,
      marketSelectedRange: '7d',
      transactions: [],
    }
    dbService.getDb().prepare('INSERT INTO users (id, state_json, updated_at) VALUES (?, ?, ?)').run(
      challengeUserId,
      JSON.stringify(challengeState),
      now,
    )
    dbService.getDb().prepare(
      'INSERT INTO auth_accounts (id, username, password_hash, user_id, created_at) VALUES (?, ?, ?, ?, ?)',
    ).run(randomUUID(), challengeUser, challengeHash, challengeUserId, now)

    const challengeLogin = await app.inject({
      method: 'POST',
      url: '/api/auth/login',
      payload: { username: challengeUser, password: 'challengePass1' },
    })
    assert.equal(challengeLogin.statusCode, 200)
    const challengeToken = parseJson<{ token: string }>(challengeLogin.payload).token

    const challengeUnauthGet = await app.inject({ method: 'GET', url: '/api/challenges/daily' })
    assert.equal(challengeUnauthGet.statusCode, 401)
    const challengeUnauthPost = await app.inject({
      method: 'POST',
      url: '/api/challenges/daily/complete',
      payload: { optionId: 'gold' },
    })
    assert.equal(challengeUnauthPost.statusCode, 401)

    const dailyGet = await app.inject({
      method: 'GET',
      url: '/api/challenges/daily',
      headers: authHeader(challengeToken),
    })
    assert.equal(dailyGet.statusCode, 200)
    const dailyBody = parseJson<{
      id: string
      question: string
      coinReward: number
      xpReward: number
      completed: boolean
      options: Array<{ id: string; label: string; icon: string; color: string }>
    }>(dailyGet.payload)
    assert.equal(dailyBody.id, DAILY_CHALLENGE.id)
    assert.equal(dailyBody.question, DAILY_CHALLENGE.question)
    assert.equal(dailyBody.coinReward, 50)
    assert.equal(dailyBody.xpReward, 30)
    assert.equal(dailyBody.completed, false)
    assert.deepEqual(
      dailyBody.options.map((o) => o.id),
      CHALLENGE_OPTIONS.map((o) => o.id),
    )
    assert.ok(!dailyGet.payload.includes('isCorrect'))
    assert.ok(!dailyGet.payload.includes('feedback'))
    assert.equal(dailyBody.options[0].label, 'طلا')

    const completeGold = await app.inject({
      method: 'POST',
      url: '/api/challenges/daily/complete',
      headers: authHeader(challengeToken),
      payload: { optionId: 'gold' },
    })
    assert.equal(completeGold.statusCode, 200)
    const goldBody = parseJson<{
      user: { coins: number; xp: number; level: number; missionProgress: number }
      progress: { completedChallenges: string[]; claimedRewards: string[]; completedGames: string[]; ownedItems: string[] }
      transactions: Array<{ type: string; title: string; amount: number; unit: string }>
      achievements: Array<{ id: string; unlocked: boolean }>
      feedback: string
      alreadyCompleted: boolean
    }>(completeGold.payload)
    assert.equal(goldBody.user.coins, 250)
    assert.equal(goldBody.user.xp, 10)
    assert.equal(goldBody.user.level, 5)
    assert.equal(goldBody.user.missionProgress, 6)
    assert.deepEqual(goldBody.progress.completedChallenges, ['daily-challenge'])
    assert.equal(goldBody.transactions[0].type, 'income')
    assert.equal(goldBody.transactions[0].title, 'چالش روزانه')
    assert.equal(goldBody.transactions[0].amount, 50)
    assert.equal(goldBody.transactions[0].unit, 'سکه')
    assert.equal(goldBody.feedback, CHALLENGE_OPTIONS[0].feedback)
    assert.equal(goldBody.alreadyCompleted, false)
    assert.deepEqual(goldBody.progress.claimedRewards, ['reward-a'])
    assert.deepEqual(goldBody.progress.completedGames, ['game-a'])
    assert.deepEqual(goldBody.progress.ownedItems, ['pet'])
    assert.equal(goldBody.achievements[0].unlocked, true)

    const dailyAfter = await app.inject({
      method: 'GET',
      url: '/api/challenges/daily',
      headers: authHeader(challengeToken),
    })
    assert.equal(parseJson<{ completed: boolean }>(dailyAfter.payload).completed, true)

    const meAfterChallenge = await app.inject({
      method: 'GET',
      url: '/api/me',
      headers: authHeader(challengeToken),
    })
    assert.equal(meAfterChallenge.statusCode, 200)
    const meChallengeBody = parseJson<{
      user: { coins: number; xp: number }
      progress: { completedChallenges: string[] }
    }>(meAfterChallenge.payload)
    assert.equal(meChallengeBody.user.coins, 250)
    assert.equal(meChallengeBody.user.xp, 10)
    assert.deepEqual(meChallengeBody.progress.completedChallenges, ['daily-challenge'])

    const stateBeforeChallengeDuplicate = (
      dbService.getDb().prepare('SELECT state_json FROM users WHERE id = ?').get(challengeUserId) as {
        state_json: string
      }
    ).state_json

    const duplicateChallenge = await app.inject({
      method: 'POST',
      url: '/api/challenges/daily/complete',
      headers: authHeader(challengeToken),
      payload: { optionId: 'gold' },
    })
    assert.equal(duplicateChallenge.statusCode, 200)
    const duplicateChallengeBody = parseJson<{
      user: { coins: number; xp: number; missionProgress: number }
      feedback: string
      alreadyCompleted: boolean
    }>(duplicateChallenge.payload)
    assert.equal(duplicateChallengeBody.alreadyCompleted, true)
    assert.equal(duplicateChallengeBody.user.coins, 250)
    assert.equal(duplicateChallengeBody.user.xp, 10)
    assert.equal(duplicateChallengeBody.user.missionProgress, 6)
    assert.equal(duplicateChallengeBody.feedback, CHALLENGE_OPTIONS[0].feedback)
    const stateAfterChallengeDuplicate = (
      dbService.getDb().prepare('SELECT state_json FROM users WHERE id = ?').get(challengeUserId) as {
        state_json: string
      }
    ).state_json
    assert.equal(stateAfterChallengeDuplicate, stateBeforeChallengeDuplicate)

    const wrongUserId = randomUUID()
    const wrongState = {
      ...challengeState,
      id: wrongUserId,
      completedChallenges: [],
      coins: 300,
      xp: 70,
      maxXp: 100,
      level: 4,
      missionProgress: 2,
      transactions: [],
    }
    dbService.getDb().prepare('INSERT INTO users (id, state_json, updated_at) VALUES (?, ?, ?)').run(
      wrongUserId,
      JSON.stringify(wrongState),
      now,
    )
    const wrongToken = jwtService.sign({ userId: wrongUserId })

    const completeWrong = await app.inject({
      method: 'POST',
      url: '/api/challenges/daily/complete',
      headers: authHeader(wrongToken),
      payload: { optionId: 'phone' },
    })
    assert.equal(completeWrong.statusCode, 200)
    const wrongBody = parseJson<{
      user: { coins: number; xp: number; missionProgress: number }
      progress: { completedChallenges: string[] }
      feedback: string
      alreadyCompleted: boolean
    }>(completeWrong.payload)
    assert.equal(wrongBody.user.coins, 350)
    assert.equal(wrongBody.user.xp, 0)
    assert.equal(wrongBody.user.level, 5)
    assert.equal(wrongBody.user.missionProgress, 3)
    assert.deepEqual(wrongBody.progress.completedChallenges, ['daily-challenge'])
    assert.equal(wrongBody.feedback, CHALLENGE_OPTIONS[3].feedback)
    assert.equal(wrongBody.alreadyCompleted, false)

    const invalidOption = await app.inject({
      method: 'POST',
      url: '/api/challenges/daily/complete',
      headers: authHeader(wrongToken),
      payload: { optionId: 'invalid' },
    })
    assert.equal(invalidOption.statusCode, 400)
    assert.deepEqual(parseJson(invalidOption.payload), { error: 'گزینه نامعتبر است' })

    const emptyOption = await app.inject({
      method: 'POST',
      url: '/api/challenges/daily/complete',
      headers: authHeader(wrongToken),
      payload: { optionId: '' },
    })
    assert.equal(emptyOption.statusCode, 400)

    const emptyBodyChallenge = await app.inject({
      method: 'POST',
      url: '/api/challenges/daily/complete',
      headers: { ...authHeader(wrongToken), 'content-type': 'application/json' },
      payload: JSON.stringify({}),
    })
    assert.equal(emptyBodyChallenge.statusCode, 400)

    const extraFieldChallenge = await app.inject({
      method: 'POST',
      url: '/api/challenges/daily/complete',
      headers: { ...authHeader(challengeToken), 'content-type': 'application/json' },
      payload: JSON.stringify({ optionId: 'gold', coins: 999 }),
    })
    assert.equal(extraFieldChallenge.statusCode, 400)

    const rollbackChallengeUserId = randomUUID()
    const rollbackChallengeState = {
      ...challengeState,
      id: rollbackChallengeUserId,
      completedChallenges: [],
      coins: 400,
      xp: 90,
      maxXp: 100,
      level: 4,
      missionProgress: 1,
      transactions: [],
    }
    dbService.getDb().prepare('INSERT INTO users (id, state_json, updated_at) VALUES (?, ?, ?)').run(
      rollbackChallengeUserId,
      JSON.stringify(rollbackChallengeState),
      now,
    )
    const rollbackChallengeToken = jwtService.sign({ userId: rollbackChallengeUserId })
    const rollbackChallengeDb = dbService.getDb()
    const stateBeforeChallengeRollback = (
      rollbackChallengeDb.prepare('SELECT state_json FROM users WHERE id = ?').get(rollbackChallengeUserId) as {
        state_json: string
      }
    ).state_json

    rollbackChallengeDb.exec(`
      CREATE TRIGGER test_abort_challenge_users_update
      BEFORE UPDATE ON users
      WHEN NEW.id = '${rollbackChallengeUserId}'
      BEGIN
        SELECT RAISE(ABORT, 'integration test challenge rollback');
      END;
    `)

    try {
      const rollbackChallengeComplete = await app.inject({
        method: 'POST',
        url: '/api/challenges/daily/complete',
        headers: authHeader(rollbackChallengeToken),
        payload: { optionId: 'gold' },
      })
      assert.equal(rollbackChallengeComplete.statusCode, 500)
      assert.deepEqual(parseJson(rollbackChallengeComplete.payload), { error: 'خطای سرور' })

      const stateAfterChallengeRollback = (
        rollbackChallengeDb.prepare('SELECT state_json FROM users WHERE id = ?').get(rollbackChallengeUserId) as {
          state_json: string
        }
      ).state_json
      assert.equal(stateAfterChallengeRollback, stateBeforeChallengeRollback)

      const beforeRb = JSON.parse(stateBeforeChallengeRollback) as typeof rollbackChallengeState
      const afterRb = JSON.parse(stateAfterChallengeRollback) as typeof rollbackChallengeState
      assert.equal(afterRb.coins, beforeRb.coins)
      assert.equal(afterRb.xp, beforeRb.xp)
      assert.equal(afterRb.level, beforeRb.level)
      assert.equal(afterRb.maxXp, beforeRb.maxXp)
      assert.equal(afterRb.missionProgress, beforeRb.missionProgress)
      assert.deepEqual(afterRb.completedChallenges, beforeRb.completedChallenges)
      assert.deepEqual(afterRb.transactions, beforeRb.transactions)
    } finally {
      rollbackChallengeDb.exec('DROP TRIGGER IF EXISTS test_abort_challenge_users_update')
    }

    // --- Phase F4: Achievements integration ---
    const { ACHIEVEMENTS: achievementCatalog } = await import(
      '../src/shared/catalog/achievements.constants'
    )
    const expectedDefinitionOrder = ['first-gold', 'saver', 'market', 'inflation']

    const f4User = `f4_${randomUUID().slice(0, 8)}`
    const f4UserId = randomUUID()
    const f4Hash = bcrypt.hashSync('f4Pass123', 10)
    const f4State = {
      id: f4UserId,
      name: 'F4 Test',
      level: 5,
      xp: 100,
      maxXp: 200,
      coins: 10_000,
      cash: 10_000_000,
      goldGrams: 0,
      missionProgress: 3,
      missionTarget: 20,
      completedChallenges: [],
      completedLessons: [],
      completedGames: [],
      claimedRewards: [],
      ownedItems: [],
      achievements: [
        { id: 'first-gold', title: 'اولین خرید طلا', description: 'd1', icon: '🥇', unlocked: false },
        { id: 'saver', title: 'پس‌اندازگر کوچک', description: 'd2', icon: '💰', unlocked: true },
        { id: 'market', title: 'شاگرد بازار', description: 'd3', icon: '📊', unlocked: false },
        { id: 'inflation', title: 'شکست‌دهنده تورم', description: 'd4', icon: '👾', unlocked: false },
      ],
      mapLevels: [{ id: 1, title: 'تست', stars: 1, maxStars: 3, status: 'current', x: 10, y: 20 }],
      totalStars: 1,
      maxStars: 39,
      marketSelectedRange: '1d',
      transactions: [],
    }
    dbService.getDb().prepare('INSERT INTO users (id, state_json, updated_at) VALUES (?, ?, ?)').run(
      f4UserId,
      JSON.stringify(f4State),
      now,
    )
    dbService.getDb().prepare(
      'INSERT INTO auth_accounts (id, username, password_hash, user_id, created_at) VALUES (?, ?, ?, ?, ?)',
    ).run(randomUUID(), f4User, f4Hash, f4UserId, now)

    const f4Login = await app.inject({
      method: 'POST',
      url: '/api/auth/login',
      payload: { username: f4User, password: 'f4Pass123' },
    })
    assert.equal(f4Login.statusCode, 200)
    const f4Token = parseJson<{ token: string }>(f4Login.payload).token

    const achUnauth = await app.inject({ method: 'GET', url: '/api/achievements' })
    assert.equal(achUnauth.statusCode, 401)
    assert.deepEqual(parseJson(achUnauth.payload), { error: 'لطفاً وارد شوید' })

    const achBadToken = await app.inject({
      method: 'GET',
      url: '/api/achievements',
      headers: { authorization: 'Bearer not-a-valid-jwt' },
    })
    assert.equal(achBadToken.statusCode, 401)
    assert.deepEqual(parseJson(achBadToken.payload), {
      error: 'نشست نامعتبر است. دوباره وارد شوید',
    })

    const rowBeforeAch = dbService
      .getDb()
      .prepare('SELECT state_json, updated_at FROM users WHERE id = ?')
      .get(f4UserId) as { state_json: string; updated_at: string }

    const achRes = await app.inject({
      method: 'GET',
      url: '/api/achievements',
      headers: authHeader(f4Token),
    })
    assert.equal(achRes.statusCode, 200)
    const achBody = parseJson<{
      definitions: Array<{ id: string; title: string; description: string; icon: string; unlocked?: boolean }>
      unlocked: Array<{ id: string; title: string; description: string; icon: string; unlocked: boolean }>
    }>(achRes.payload)

    assert.ok(Array.isArray(achBody.definitions))
    assert.ok(Array.isArray(achBody.unlocked))
    assert.equal(achBody.definitions.length, achievementCatalog.length)
    assert.deepEqual(
      achBody.definitions.map((d) => d.id),
      expectedDefinitionOrder,
    )
    for (const def of achBody.definitions) {
      assert.equal(typeof def.id, 'string')
      assert.equal(typeof def.title, 'string')
      assert.equal(typeof def.description, 'string')
      assert.equal(typeof def.icon, 'string')
      assert.equal('unlocked' in def, false)
    }
    assert.deepEqual(
      achBody.definitions.map(({ id, title, description, icon }) => ({ id, title, description, icon })),
      achievementCatalog.map(({ id, title, description, icon }) => ({ id, title, description, icon })),
    )
    assert.deepEqual(achBody.unlocked, f4State.achievements)
    assert.equal(achBody.unlocked.filter((a) => !a.unlocked).length, 3)
    assert.equal(achBody.unlocked.find((a) => a.id === 'saver')?.unlocked, true)

    const rowAfterAch = dbService
      .getDb()
      .prepare('SELECT state_json, updated_at FROM users WHERE id = ?')
      .get(f4UserId) as { state_json: string; updated_at: string }
    assert.equal(rowAfterAch.state_json, rowBeforeAch.state_json)
    assert.equal(rowAfterAch.updated_at, rowBeforeAch.updated_at)

    const catalogSnapshot = achievementCatalog.map((a) => ({ ...a }))
    achBody.definitions[0].title = 'mutated'
    assert.deepEqual(
      achievementCatalog.map(({ id, title, description, icon }) => ({ id, title, description, icon })),
      catalogSnapshot,
    )

    const { createDefaultUserState: createDefaultUserStateF0 } = await import(
      '../src/shared/catalog/default-user-state'
    )
    const defaultState1 = createDefaultUserState('f4-default-1')
    const defaultState2 = createDefaultUserState('f4-default-2')
    assert.notEqual(defaultState1.achievements, defaultState2.achievements)
    assert.equal(defaultState1.achievements.length, achievementCatalog.length)
    assert.deepEqual(
      defaultState1.achievements.map((a) => a.id),
      expectedDefinitionOrder,
    )
    for (const achievement of defaultState1.achievements) {
      const expected =
        achievement.id === 'first-gold' || achievement.id === 'saver'
          ? true
          : false
      assert.equal(achievement.unlocked, expected)
    }
    defaultState1.achievements[0].unlocked = false
    assert.equal(defaultState2.achievements[0].unlocked, true)

    const buyBeforeAch = await app.inject({
      method: 'GET',
      url: '/api/achievements',
      headers: authHeader(f4Token),
    })
    const buyBeforeBody = parseJson<{ unlocked: Array<{ id: string; unlocked: boolean }> }>(
      buyBeforeAch.payload,
    )
    assert.equal(buyBeforeBody.unlocked.find((a) => a.id === 'first-gold')?.unlocked, false)

    const f4BuyRes = await app.inject({
      method: 'POST',
      url: '/api/wallet/gold/buy',
      headers: { ...authHeader(f4Token), 'content-type': 'application/json' },
      payload: JSON.stringify({ grams: 0.01 }),
    })
    assert.equal(f4BuyRes.statusCode, 200)
    const f4BuyBody = parseJson<{ achievements: Array<{ id: string; unlocked: boolean }> }>(
      f4BuyRes.payload,
    )
    assert.equal(f4BuyBody.achievements.find((a) => a.id === 'first-gold')?.unlocked, true)

    const buyAfterAch = await app.inject({
      method: 'GET',
      url: '/api/achievements',
      headers: authHeader(f4Token),
    })
    const buyAfterBody = parseJson<{ unlocked: Array<{ id: string; unlocked: boolean }> }>(
      buyAfterAch.payload,
    )
    assert.equal(buyAfterBody.unlocked.find((a) => a.id === 'first-gold')?.unlocked, true)

    const f4MeRes = await app.inject({
      method: 'GET',
      url: '/api/me',
      headers: authHeader(f4Token),
    })
    const f4MeBody = parseJson<{ achievements: Array<{ id: string; unlocked: boolean }> }>(
      f4MeRes.payload,
    )
    assert.equal(f4MeBody.achievements.find((a) => a.id === 'first-gold')?.unlocked, true)

    const { unlockAchievement: unlockAchievementOnce } = await import(
      '../src/shared/economy/user-economy.helpers'
    )
    const dupState = createDefaultUserState('f4-dup')
    const dupCountBefore = dupState.achievements.length
    unlockAchievementOnce(dupState, 'first-gold')
    unlockAchievementOnce(dupState, 'first-gold')
    assert.equal(dupState.achievements.length, dupCountBefore)
    assert.equal(dupState.achievements.filter((a) => a.id === 'first-gold').length, 1)

    const f4StoreRes = await app.inject({
      method: 'POST',
      url: '/api/store/purchases',
      headers: { ...authHeader(f4Token), 'content-type': 'application/json' },
      payload: JSON.stringify({ productId: 'boost-xp' }),
    })
    assert.equal(f4StoreRes.statusCode, 200)
    const f4StoreBody = parseJson<{ achievements: Array<{ id: string; unlocked: boolean }> }>(
      f4StoreRes.payload,
    )
    assert.equal(f4StoreBody.achievements.length, f4State.achievements.length)
    assert.equal(f4StoreBody.achievements.find((a) => a.id === 'market')?.unlocked, false)

    const f4GameRes = await app.inject({
      method: 'POST',
      url: '/api/games/gold-guess/complete',
      headers: { ...authHeader(f4Token), 'content-type': 'application/json' },
      payload: JSON.stringify({}),
    })
    assert.equal(f4GameRes.statusCode, 200)
    const f4GameBody = parseJson<{ achievements: Array<{ id: string; unlocked: boolean }> }>(
      f4GameRes.payload,
    )
    assert.equal(f4GameBody.achievements.find((a) => a.id === 'market')?.unlocked, false)

    const f4ChallengeRes = await app.inject({
      method: 'POST',
      url: '/api/challenges/daily/complete',
      headers: { ...authHeader(f4Token), 'content-type': 'application/json' },
      payload: JSON.stringify({ optionId: 'gold' }),
    })
    assert.equal(f4ChallengeRes.statusCode, 200)
    const f4ChallengeBody = parseJson<{ achievements: Array<{ id: string; unlocked: boolean }> }>(
      f4ChallengeRes.payload,
    )
    assert.equal(f4ChallengeBody.achievements.find((a) => a.id === 'saver')?.unlocked, true)
    assert.equal(f4ChallengeBody.achievements.find((a) => a.id === 'market')?.unlocked, false)

    const f4FinalRow = dbService
      .getDb()
      .prepare('SELECT state_json FROM users WHERE id = ?')
      .get(f4UserId) as { state_json: string }
    const f4FinalState = JSON.parse(f4FinalRow.state_json) as typeof f4State
    assert.ok(typeof f4FinalState.coins === 'number')
    assert.ok(typeof f4FinalState.xp === 'number')
    assert.ok(typeof f4FinalState.level === 'number')
    assert.ok(typeof f4FinalState.maxXp === 'number')
    assert.ok(Array.isArray(f4FinalState.ownedItems))
    assert.ok(Array.isArray(f4FinalState.completedGames))
    assert.ok(Array.isArray(f4FinalState.completedChallenges))
    assert.ok(Array.isArray(f4FinalState.transactions))
    assert.ok(Array.isArray(f4FinalState.mapLevels))
    assert.equal(f4FinalState.achievements.find((a) => a.id === 'market')?.unlocked, false)

    const nestRoutes = [
      'GET /health',
      'POST /api/auth/register',
      'POST /api/auth/login',
      'GET /api/me',
      'PATCH /api/me/profile',
      'PATCH /api/me/password',
      'GET /api/wallet/transactions',
      'POST /api/wallet/gold/buy',
      'POST /api/wallet/gold/sell',
      'GET /api/market/gold',
      'PATCH /api/market/preferences',
      'GET /api/gold-land/levels',
      'GET /api/gold-land/progress',
      'GET /api/gold-land/levels/:levelId',
      'POST /api/gold-land/levels/:levelId/start',
      'POST /api/gold-land/levels/:levelId/complete',
      'GET /api/store/products',
      'POST /api/store/purchases',
      'GET /api/games',
      'POST /api/games/:gameId/complete',
      'GET /api/challenges/daily',
      'POST /api/challenges/daily/complete',
      'GET /api/achievements',
    ]
    assert.equal(nestRoutes.length, 23)
    assert.ok(nestRoutes.includes('GET /api/achievements'))
    assert.equal(
      nestRoutes.filter((r) => r.startsWith('GET /api/achievements') || r.startsWith('POST /api/achievements')).length,
      1,
    )

    // --- Phase F4.1: Default achievement seed parity ---
    const { DEFAULT_ACHIEVEMENT_UNLOCK_STATE, createDefaultAchievements } = await import(
      '../src/shared/catalog/achievements.constants'
    )
    assert.deepEqual(DEFAULT_ACHIEVEMENT_UNLOCK_STATE, {
      'first-gold': true,
      saver: true,
      market: false,
      inflation: false,
    })

    const f41RegisterUser = `f41_reg_${randomUUID().slice(0, 8)}`
    const f41RegisterRes = await app.inject({
      method: 'POST',
      url: '/api/auth/register',
      payload: { username: f41RegisterUser, password: 'secret12', name: 'F41 Register' },
    })
    assert.equal(f41RegisterRes.statusCode, 200)
    const f41RegisterBody = parseJson<{
      token: string
      me: { achievements: Array<{ id: string; unlocked: boolean }> }
    }>(f41RegisterRes.payload)
    assertFastifyDefaultAchievementSeed(f41RegisterBody.me.achievements)

    const f41RegisterAch = await app.inject({
      method: 'GET',
      url: '/api/achievements',
      headers: authHeader(f41RegisterBody.token),
    })
    assert.equal(f41RegisterAch.statusCode, 200)
    const f41RegisterAchBody = parseJson<{
      definitions: Array<{ id: string; unlocked?: boolean }>
      unlocked: Array<{ id: string; unlocked: boolean }>
    }>(f41RegisterAch.payload)
    assertFastifyDefaultAchievementSeed(f41RegisterAchBody.unlocked)
    for (const def of f41RegisterAchBody.definitions) {
      assert.equal('unlocked' in def, false)
    }

    const f41DemoAchRes = await app.inject({
      method: 'GET',
      url: '/api/achievements',
      headers: authHeader(demoBody.token),
    })
    assert.equal(f41DemoAchRes.statusCode, 200)
    const f41DemoAchBody = parseJson<{
      unlocked: Array<{ id: string; unlocked: boolean }>
    }>(f41DemoAchRes.payload)
    assertFastifyDefaultAchievementSeed(f41DemoAchBody.unlocked)

    const f41DemoMeRes = await app.inject({
      method: 'GET',
      url: '/api/me',
      headers: authHeader(demoBody.token),
    })
    const f41DemoMeBody = parseJson<{
      achievements: Array<{ id: string; unlocked: boolean }>
    }>(f41DemoMeRes.payload)
    assertFastifyDefaultAchievementSeed(f41DemoMeBody.achievements)

    const f41EnsureAuth = `f41_ensure_${randomUUID().slice(0, 8)}`
    const f41EnsureUserId = randomUUID()
    const f41EnsureHash = bcrypt.hashSync('ensurePass1', 10)
    dbService.getDb().prepare(
      'INSERT INTO auth_accounts (id, username, password_hash, user_id, created_at) VALUES (?, ?, ?, ?, ?)',
    ).run(randomUUID(), f41EnsureAuth, f41EnsureHash, f41EnsureUserId, now)
    const f41EnsureLogin = await app.inject({
      method: 'POST',
      url: '/api/auth/login',
      payload: { username: f41EnsureAuth, password: 'ensurePass1' },
    })
    assert.equal(f41EnsureLogin.statusCode, 200)
    const f41EnsureBody = parseJson<{
      me: { achievements: Array<{ id: string; unlocked: boolean }> }
    }>(f41EnsureLogin.payload)
    assertFastifyDefaultAchievementSeed(f41EnsureBody.me.achievements)

    const f41DefaultA = createDefaultAchievements()
    const f41DefaultB = createDefaultAchievements()
    assert.notEqual(f41DefaultA, f41DefaultB)
    assert.notEqual(f41DefaultA[0], f41DefaultB[0])
    f41DefaultA[0].unlocked = false
    assert.equal(f41DefaultB[0].unlocked, true)

    const f41LegacyUserId = randomUUID()
    const f41LegacyState = {
      id: f41LegacyUserId,
      name: 'Legacy Seed',
      level: 1,
      xp: 0,
      maxXp: 100,
      coins: 50,
      cash: 1000,
      goldGrams: 0,
      missionProgress: 0,
      missionTarget: 3,
      completedChallenges: [],
      completedLessons: [],
      completedGames: [],
      claimedRewards: [],
      ownedItems: [],
      achievements: [{ id: 'custom-only', title: 'Custom', description: 'x', icon: '⭐', unlocked: true }],
      mapLevels: [],
      totalStars: 0,
      maxStars: 39,
      marketSelectedRange: '7d',
      transactions: [],
    }
    const f41LegacyAuth = `f41_legacy_${randomUUID().slice(0, 8)}`
    const f41LegacyJson = JSON.stringify(f41LegacyState)
    const f41LegacyUpdatedAt = '2020-01-01T00:00:00.000Z'
    dbService.getDb().prepare('INSERT INTO users (id, state_json, updated_at) VALUES (?, ?, ?)').run(
      f41LegacyUserId,
      f41LegacyJson,
      f41LegacyUpdatedAt,
    )
    dbService.getDb().prepare(
      'INSERT INTO auth_accounts (id, username, password_hash, user_id, created_at) VALUES (?, ?, ?, ?, ?)',
    ).run(randomUUID(), f41LegacyAuth, bcrypt.hashSync('legacyPass1', 10), f41LegacyUserId, now)
    const f41LegacyLogin = await app.inject({
      method: 'POST',
      url: '/api/auth/login',
      payload: { username: f41LegacyAuth, password: 'legacyPass1' },
    })
    const f41LegacyToken = parseJson<{ token: string }>(f41LegacyLogin.payload).token
    await app.inject({
      method: 'GET',
      url: '/api/achievements',
      headers: authHeader(f41LegacyToken),
    })
    const f41LegacyRow = dbService
      .getDb()
      .prepare('SELECT state_json, updated_at FROM users WHERE id = ?')
      .get(f41LegacyUserId) as { state_json: string; updated_at: string }
    assert.equal(f41LegacyRow.state_json, f41LegacyJson)
    assert.equal(f41LegacyRow.updated_at, f41LegacyUpdatedAt)

    const f41DefaultBuyUser = `f41_buy_${randomUUID().slice(0, 8)}`
    const f41DefaultBuyRes = await app.inject({
      method: 'POST',
      url: '/api/auth/register',
      payload: { username: f41DefaultBuyUser, password: 'secret12', name: 'F41 Buy' },
    })
    const f41DefaultBuyBody = parseJson<{
      token: string
      me: { achievements: Array<{ id: string; unlocked: boolean }> }
    }>(f41DefaultBuyRes.payload)
    assert.equal(f41DefaultBuyBody.me.achievements.find((a) => a.id === 'first-gold')?.unlocked, true)
    const f41DefaultBuyAchCount = f41DefaultBuyBody.me.achievements.length
    const f41GoldBuyRes = await app.inject({
      method: 'POST',
      url: '/api/wallet/gold/buy',
      headers: {
        ...authHeader(f41DefaultBuyBody.token),
        'content-type': 'application/json',
      },
      payload: JSON.stringify({ grams: 0.01 }),
    })
    assert.equal(f41GoldBuyRes.statusCode, 200)
    const f41GoldBuyBody = parseJson<{ achievements: Array<{ id: string; unlocked: boolean }> }>(
      f41GoldBuyRes.payload,
    )
    assert.equal(f41GoldBuyBody.achievements.length, f41DefaultBuyAchCount)
    assert.equal(f41GoldBuyBody.achievements.filter((a) => a.id === 'first-gold').length, 1)
    assert.equal(f41GoldBuyBody.achievements.find((a) => a.id === 'first-gold')?.unlocked, true)

    // --- Phase F0: shared economy helpers regression ---
    const {
      addXp,
      addTransaction,
      incrementMission,
      unlockAchievement,
    } = await import('../src/shared/economy/user-economy.helpers')
    const { createDefaultUserState: createDefaultUserStateF0 } = await import(
      '../src/shared/catalog/default-user-state'
    )

    const xpState = createDefaultUserStateF0('f0-xp')
    xpState.xp = 950
    xpState.maxXp = 100
    xpState.level = 1
    addXp(xpState, 200)
    assert.equal(xpState.level, 8)
    assert.equal(xpState.xp, 44)
    assert.equal(xpState.maxXp, 266)

    const txCapState = createDefaultUserStateF0('f0-tx')
    txCapState.transactions = []
    for (let i = 0; i < 55; i++) {
      addTransaction(txCapState, {
        type: 'income',
        title: `tx-${i}`,
        amount: 1,
        unit: 'سکه',
      })
    }
    assert.equal(txCapState.transactions.length, 50)
    assert.equal(txCapState.transactions[0].title, 'tx-54')

    const missionState = createDefaultUserStateF0('f0-mission')
    missionState.missionProgress = 0
    missionState.missionTarget = 3
    incrementMission(missionState)
    incrementMission(missionState)
    incrementMission(missionState)
    incrementMission(missionState)
    assert.equal(missionState.missionProgress, 3)

    const achState = createDefaultUserStateF0('f0-ach')
    const firstGold = achState.achievements.find((a) => a.id === 'first-gold')
    assert.ok(firstGold)
    assert.equal(firstGold!.unlocked, true)
    firstGold!.unlocked = false
    unlockAchievement(achState, 'first-gold')
    unlockAchievement(achState, 'first-gold')
    assert.equal(firstGold!.unlocked, true)

    const buyMissionBody = parseJson<{ user: { missionProgress: number } }>(buyRes.payload)
    assert.equal(buyMissionBody.user.missionProgress, 4)

    // 23. shutdown closes DB connection
    await app.close()
    assert.throws(() => dbService.getDb(), /not initialized|Database is not initialized/)

    // idempotent migration on fresh app instance
    const app2 = await createApp()
    const secondMigration = app2.get(DatabaseService).verifyMigrationsApplied()
    assert.equal(secondMigration.ok, true)
    await app2.close()

    console.log('integration tests passed (Phase B + C + D + E + F0 + F1 + F2 + F3 + F4 + F4.1)')
  } finally {
    try {
      rmSync(testDir, { recursive: true, force: true })
    } catch {
      // ignore
    }
  }
}

runTests().catch((error) => {
  console.error(error)
  process.exit(1)
})