/**
 * I-003: Transition + Routing — Filter Pass → Main + Award Parallel
 */

import { describe, it, expect, beforeAll, afterAll } from 'vitest'
import { prisma } from '../setup'
import {
  createTestUser,
  createTestProgram,
  createTestPipeline,
  createTestTrack,
  createTestStage,
  createTestTransition,
  createTestProject,
  createTestPSS,
  createTestRoutingRule,
  cleanupTestData,
} from '../helpers'
import { executeTransition } from '@/server/services/stage-engine'
import { evaluateRoutingRules, executeRouting } from '@/server/services/routing-engine'

let programId: string
let userIds: string[] = []

beforeAll(async () => {
  const program = await createTestProgram({ name: 'Transition+Routing Test' })
  programId = program.id
})

afterAll(async () => {
  await cleanupTestData(programId, userIds)
})

describe('I-003: Transition + Routing — Parallel Award Track', () => {
  it('transitions a project then routes it to a parallel award track', async () => {
    const admin = await createTestUser('SUPER_ADMIN')
    userIds.push(admin.id)

    const pipeline = await createTestPipeline(programId)

    // Main track: FILTER → EVALUATION
    const mainTrack = await createTestTrack(pipeline.id, {
      name: 'Main',
      kind: 'MAIN',
      sortOrder: 0,
    })
    const filterStage = await createTestStage(mainTrack.id, {
      name: 'Filter',
      stageType: 'FILTER',
      status: 'STAGE_ACTIVE',
      sortOrder: 0,
    })
    const evalStage = await createTestStage(mainTrack.id, {
      name: 'Evaluation',
      stageType: 'EVALUATION',
      status: 'STAGE_ACTIVE',
      sortOrder: 1,
    })
    await createTestTransition(filterStage.id, evalStage.id)

    // Award track (PARALLEL)
    const awardTrack = await createTestTrack(pipeline.id, {
      name: 'Innovation Award',
      kind: 'AWARD',
      sortOrder: 1,
      routingMode: 'PARALLEL',
    })
    const awardEvalStage = await createTestStage(awardTrack.id, {
      name: 'Award Eval',
      stageType: 'EVALUATION',
      status: 'STAGE_ACTIVE',
      sortOrder: 0,
    })

    // Routing rule: projects from France → Award track (parallel)
    await createTestRoutingRule(pipeline.id, awardTrack.id, {
      name: 'France → Innovation Award',
      priority: 0,
      predicateJson: { field: 'project.country', operator: 'eq', value: 'France' },
    })

    // Create project in filter stage
    const project = await createTestProject(programId, { country: 'France' })
    await createTestPSS(project.id, mainTrack.id, filterStage.id, { state: 'PENDING' })

    // Step 1: Transition from filter → evaluation
    const transResult = await executeTransition(
      project.id, mainTrack.id, filterStage.id, evalStage.id,
      'PENDING', admin.id, prisma
    )
    expect(transResult.success).toBe(true)

    // Step 2: Evaluate routing rules
    const matchedRule = await evaluateRoutingRules(
      project.id, evalStage.id, pipeline.id, prisma
    )
    expect(matchedRule).not.toBeNull()
    expect(matchedRule!.destinationTrackId).toBe(awardTrack.id)
    expect(matchedRule!.routingMode).toBe('PARALLEL')

    // Step 3: Execute routing
    const routeResult = await executeRouting(project.id, matchedRule!, admin.id, prisma)
    expect(routeResult.success).toBe(true)

    // Verify: Project should be in BOTH main eval stage AND award eval stage
    const mainPSS = await prisma.projectStageState.findFirst({
      where: { projectId: project.id, stageId: evalStage.id, exitedAt: null },
    })
    expect(mainPSS).not.toBeNull() // Still in main track

    const awardPSS = await prisma.projectStageState.findFirst({
      where: { projectId: project.id, stageId: awardEvalStage.id, exitedAt: null },
    })
    expect(awardPSS).not.toBeNull() // Also in award track
    expect(awardPSS!.state).toBe('PENDING')
  })
})