import { expect } from '@playwright/test';
import type { Page, Frame } from '@playwright/test';
import type { Csp } from './data';
import { test } from './fixtures';
import { loginAsAdmin, selectWorkspaceProject } from './ui';
import { WORKSPACE, DEFAULT_PROJECT } from './data';

// IV6(Cost Analysis) 화면 헬퍼 — 2026-10-07 AWS 탐색(읽기 전용)으로 확인
// - 사이드바 Analytics > Cost Analysis 아래 별도 메뉴 4개: Dash Board(/_view/costdashboard) · Billing Report(/_view/billingreport) · Cost Alarm(/_view/costalarm) · Budget(/_view/budget)
//   (본문 iframe 주소는 :7780/ , /billing-report , /alarm , /budget 로 메뉴마다 다르다)
// - Billing Report 의 [Cost Setup] → 모달(CSP 탭: 현재 AWS, GCP 만). 모달 버튼 Close(.btn-secondary) / Reconfigure(AWS) / Check Now(GCP) — 누르지 않는다
export type CostMenu = 'dashboard' | 'billing' | 'alarm' | 'budget';
const SLUG: Record<CostMenu, string> = { dashboard: 'costdashboard', billing: 'billingreport', alarm: 'costalarm', budget: 'budget' };
const note = (type: string, description: string) => test.info().annotations.push({ type, description });

export const costFrame = (page: Page): Frame => page.frames().find((x) => x !== page.mainFrame() && x.url().includes(':7780'))!;
export const frameText = async (page: Page) => (await costFrame(page).locator('body').innerText()).replace(/\s+/g, ' ');

/** 로그인 → 사이드바 Cost Analysis 그룹 펼침 → 해당 메뉴 클릭. 화면 본문 텍스트를 돌려준다. project 기본값 default(2026-10-16: 비용 없는 Project 조회용 인자 추가) */
export async function openCost(page: Page, menu: CostMenu, project: string = DEFAULT_PROJECT) {
  await loginAsAdmin(page, WORKSPACE, project);
  const link = page.locator(`a[href*="/_view/${SLUG[menu]}"]`).first();
  if (!(await link.isVisible().catch(() => false))) await page.getByText('Cost Analysis', { exact: true }).first().click(); // 그룹 펼침
  await link.click();
  await page.waitForURL(new RegExp(SLUG[menu]));
  await selectWorkspaceProject(page, WORKSPACE, project, true); // 메뉴 이동 시 선택이 초기화될 수 있음
  await expect.poll(() => !!costFrame(page), { timeout: 60_000 }).toBe(true);
  await page.waitForTimeout(8000); // iframe 데이터 로딩(+Project 선택 시 재로드)
  const text = await frameText(page);
  note('screen', text.slice(0, 300));
  return text;
}
/** Billing Report 에서 Cost Setup 모달을 열고 CSP 탭 유무를 확인. 탭이 있으면 선택한 상태로 돌려준다. */
export async function openCostSetupTab(page: Page, c: Csp) {
  await openCost(page, 'billing');
  const f = costFrame(page);
  await f.getByText('Cost Setup', { exact: true }).first().click();
  const modal = f.locator('.modal.show, [role=dialog]').first();
  await expect(modal).toBeVisible({ timeout: 15_000 });
  const tabs = (await modal.locator('a.nav-link').allInnerTexts()).map((s) => s.replace(/[✓\s]+/g, ' ').trim());
  note('cost-setup-tabs', JSON.stringify(tabs));
  const tab = modal.locator('a.nav-link').filter({ hasText: new RegExp(`^\\s*${c.code}\\b`, 'i') }).first();
  const has = (await tab.count()) > 0;
  if (has) { await tab.click(); await page.waitForTimeout(1500); }
  return { f, modal, tabs, has };
}

// ── 비용 데이터(2026-10-14 점검) ───────────────────────────────────────────────
// 화면이 부르는 BE API(:9090 /api/costopti/be/…) 응답으로 금액을 읽는다. 화면 문구는 반올림(0.43 USD)이라 API 값으로 합계를 맞춘다.
//   Billing Report: invoice/getBillingBaseInfo → [{csp:'AWS'|'AZURE'|'GCP'|'NCP', cost}], invoice/getInvoice → {invoice:[{csp, productID, bill, resourceID}]}
//   Dash Board   : getTop5Bill → {top5bill:[{csp, resourceNm, bill}]}, getCurMonthBill → {curMonthBill}
// Cost Analysis 가 다루는 CSP 는 AWS·Azure·GCP·NCP 4개(요청 selectedCsps 기준). 나머지 CSP 는 비용 화면 대상이 아니다.
export const COST_CSP: Record<string, string> = { AWS: 'AWS', Azure: 'AZURE', GCP: 'GCP', NCP: 'NCP' };
export const costCspOf = (c: Csp) => COST_CSP[c.code] ?? null;

/** 페이지에서 비용 BE API 응답을 모은다. 반환 함수로 이름(getTop5Bill 등) → 마지막 Data 를 꺼낸다. */
export function costApi(page: Page) {
  const data: Record<string, any> = {};
  page.on('response', async (r) => {
    const m = r.url().match(/\/api\/costopti\/be\/(?:invoice\/)?(\w+)/);
    if (!m || r.request().resourceType() === 'document') return;
    try { const j = await r.json(); data[m[1]] = j?.Data ?? j; } catch { /* JSON 아님 */ }
  });
  return (name: string) => data[name];
}

/** Billing Report·Dash Board 를 열어 CSP 별 금액·Top5·Invoice 를 모은다 */
export async function readCosts(page: Page) {
  const get = costApi(page);
  const billing = await openCost(page, 'billing');
  await expect.poll(() => !!get('getBillingBaseInfo') && !!get('getInvoice'), { timeout: 60_000 }).toBe(true);
  const base: { csp: string; cost: number }[] = get('getBillingBaseInfo') ?? [];
  const invoice: { csp: string; productID: string; bill: number; resourceID: string }[] = get('getInvoice')?.invoice ?? [];
  const dashboard = await openCost(page, 'dashboard');
  await expect.poll(() => !!get('getTop5Bill') && !!get('getCurMonthBill'), { timeout: 60_000 }).toBe(true);
  const top5: { csp: string; resourceNm: string; bill: number }[] = get('getTop5Bill')?.top5bill ?? [];
  const cur: number = get('getCurMonthBill')?.curMonthBill ?? NaN;
  const total = Number(billing.match(/Total Amount\s*([\d.,]+)\s*USD/i)?.[1] ?? NaN);
  note('cost-base-info', base.map((b) => `${b.csp} ${b.cost.toFixed(4)}`).join(' / ') + ` | 화면 Total ${total} USD | 당월(Dash Board) ${cur.toFixed(4)} USD`);
  note('cost-top5', top5.map((t) => `${t.resourceNm}(${t.csp}) ${t.bill.toFixed(4)}`).join(' / ') || '(없음)');
  note('cost-invoice', invoice.map((i) => `${i.csp} ${i.productID} ${i.bill.toFixed(4)}`).join(' / ') || '(없음)');
  return { billing, dashboard, base, invoice, top5, cur, total };
}

/**
 * 비용 수집 결과 화면 반영(IV6_S07~S09 공통) — 시트 기대결과 '대시보드 월비용/Top5/요약에 반영' 기준:
 * Billing Report Base Info 금액 > 0, Dash Board Top 5 에 서비스. Invoices 행은 기록만 한다(2026-10-14: GCP 는 금액이 있어도 Invoices 에 행 없음).
 * 금액이 없으면 수집 사전 설정(인증키·권한) 미비로 보고 SKIP(사용자 지시 2026-10-14).
 */
export async function checkCollected(page: Page, c: Csp) {
  const csp = costCspOf(c)!;
  const { base, invoice, top5 } = await readCosts(page);
  const mine = base.find((b) => b.csp === csp);
  test.skip(!mine || mine.cost <= 0, `${csp} 비용 없음 — 수집 사전 설정(인증키·권한) 미비로 판단(SKIP)`);
  const inv = invoice.filter((i) => i.csp === csp);
  note('invoice-check', inv.length ? `Invoices 에 ${csp} ${inv.length}행` : `Invoices 에 ${csp} 행 없음(Base Info·Top 5 에는 반영) — 참고`);
  expect(top5.map((t) => t.csp), `Top 5 Services 에 ${csp}`).toContain(csp);
}

// ── TC-COST-013~020 (2026-10-16 화면 탐색) ───────────────────────────────────────
//   Billing Report > Invoices: 내보내기 아이콘 버튼 2개(svg.tabler-icon-file-type-csv / -xls) → 바로 다운로드(invoice_YYYY-MM-DD.csv)
//   Archive(🗄 Archive) → 모달 'Cost Archive': Target month select(archive/months), CSP 체크박스 AWS·GCP·NCP·AZURE(기본 모두 체크), Close / Archive(month 미선택 시 disabled)
//   Budget > CSP Budget Setting: 행 AWS·Azure·NCP·GCP, 열 Total·Jan~Dec(셀은 클릭하면 편집), Save Budget / Reset. API budget/{year}, budget/comparison/{year}
//   Alarm > Resource Recommendation: Provider 영역(키 없으면 'No API key registered yet…'), 🔑 API Key Management, 인스턴스 표(체크박스), 빠른 질문 칩 4개, Recommend(선택 0 이면 disabled)
//   Alarm > History: Mailing/Slack Apply·Test 버튼, Recommendation History 표(DATE·CSP·RESOURCE ID·RESOURCE TYPE·ALARM TYPE·ALARM MESSAGE·RECOMMENDATION TYPE)
//   LLM 키 상태: GET llm_recommender/apikey/{openai|google|anthropic}/status?nsId=<project>
export const LLM_PROVIDERS = ['openai', 'google', 'anthropic'] as const;
/** 화면이 부르는 키 상태 API 응답을 모은다(openCost 전에 호출) */
export function llmKeyStatus(page: Page) {
  const st: Record<string, boolean | undefined> = {};
  page.on('response', async (r) => {
    const m = r.url().match(/llm_recommender\/apikey\/(\w+)\/status/);
    if (m) try { const j = await r.json(); st[m[1]] = !!(j?.Data ?? j)?.registered; } catch { /* 무시 */ }
  });
  return st;
}

/** .xlsx(zip) 의 sharedStrings·sheet1 에서 문자열을 꺼낸다 — 별도 라이브러리 없이 zlib 로 로컬 헤더를 차례로 읽음 */
export function xlsxStrings(buf: Buffer): string[] {
  const zlib = require('zlib') as typeof import('zlib');
  const out: string[] = [];
  let i = 0;
  while (i + 30 <= buf.length && buf.readUInt32LE(i) === 0x04034b50) {
    const method = buf.readUInt16LE(i + 8), csize = buf.readUInt32LE(i + 18), nlen = buf.readUInt16LE(i + 26), xlen = buf.readUInt16LE(i + 28);
    const name = buf.toString('utf8', i + 30, i + 30 + nlen);
    const start = i + 30 + nlen + xlen, data = buf.subarray(start, start + csize);
    if (/sharedStrings\.xml$|worksheets\/sheet1\.xml$/.test(name)) {
      const xml = (method === 8 ? zlib.inflateRawSync(data) : data).toString('utf8');
      for (const m of xml.matchAll(/<t[^>]*>([^<]*)<\/t>|<v>([^<]*)<\/v>|<is><t[^>]*>([^<]*)<\/t>/g)) out.push((m[1] ?? m[2] ?? m[3] ?? '').trim());
    }
    if (csize === 0 && (buf.readUInt16LE(i + 6) & 8)) break; // 데이터 디스크립터 방식(크기 0) — 더 못 읽음
    i = start + csize;
  }
  return out;
}

export async function closeModal(modal: import('@playwright/test').Locator) {
  await modal.locator('button.btn-secondary').click().catch(() => {});
}

import { expect, type Page, type Locator } from '@playwright/test';
import { test } from './fixtures';
import { loginAsAdmin } from './ui';

// Credential(Settings > Cloud SPs > Credentials) 화면 헬퍼 — 2026-10-14 소스(credentials.html/js) 기준
// 출처: 위키 Test-Specs-IV10 의 lib/iv10.ts(다른 세션 작성). 2026-10-14 IV1_S32~S37(TC-INFRA-001~006)로 편입하면서 이름만 바꿈
//  - 목록: Tabulator #credential-table (Credential Holder, Providers, Connections, Verified, Default)
//  - 행 클릭 → #credential-detail-panel (#detail-holder-id/provider/connections/verified/default)
//  - Register: #credential-create-modal → #create-holder-name, #create-holder-provider(선택 시 KV 행 자동 생성), #kv-list-container(.kv-key/.kv-value), Register 버튼
export const CREDENTIALS_URL = '/webconsole/settings/environment/cloudsps/credentials';
export const TEST_HOLDER = process.env.CRED_HOLDER ?? 'test';

export async function gotoCredentials(page: Page) {
  await page.goto(CREDENTIALS_URL);
  await expect(page.locator('#credential-table')).toBeVisible({ timeout: 30_000 });
  await expect(page.locator('#credential-table .tabulator-row').first()).toBeVisible({ timeout: 30_000 });
}

export const holderRow = (page: Page, holder: string): Locator =>
  page.locator('#credential-table .tabulator-row').filter({ has: page.locator('[tabulator-field="credentialHolder"]', { hasText: new RegExp(`^\\s*${holder}\\s*$`) }) });

export async function rowCells(row: Locator): Promise<Record<string, string>> {
  const cells = row.locator('.tabulator-cell');
  const out: Record<string, string> = {};
  for (let i = 0; i < await cells.count(); i++) {
    const c = cells.nth(i);
    out[(await c.getAttribute('tabulator-field')) ?? `col${i}`] = (await c.innerText()).replace(/\s+/g, ' ').trim();
  }
  return out;
}

// 웹 콘솔 API(공용 proxy)로 mc-infra-manager 호출 — 화면 값과 비교할 때만 사용
export async function consoleApi(page: Page, operationId: string, data: unknown = {}) {
  return page.evaluate(async ([op, body]) => {
    const r = await (window as any).webconsolejs['common/api/http'].commonAPIPost(`/api/mc-infra-manager/${op}`, body);
    return { status: r?.status, data: r?.data };
  }, [operationId, data] as const);
}

// ── 등록 ────────────────────────────────────────────────────────────────
// 자격증명 값 파일(CRED_VALUES_FILE, JSON {csp: {key: value}})을 읽는다. 값은 리포트·녹화에 남기지 않는다.
import fs from 'node:fs';
export function credValues(csp: string): Record<string, string> {
  const f = process.env.CRED_VALUES_FILE;
  if (!f || !fs.existsSync(f)) throw new Error('CRED_VALUES_FILE(자격증명 값 JSON) 미지정');
  return JSON.parse(fs.readFileSync(f, 'utf8'))[csp] ?? {};
}
export const scrub = (s: string, values: Record<string, string>) => Object.values(values).reduce((t, v) => (v && v.length > 3 ? t.split(v).join('***') : t), s);

export type HolderInfo = { credentialHolder?: string; providers?: string[]; connectionCount?: number; verifiedConnectionCount?: number };
export async function getHolder(page: Page, holder: string): Promise<{ status: number; info: HolderInfo }> {
  const r = await consoleApi(page, 'GetCredentialHolder', { pathParams: { holderId: holder } });
  return { status: r.status, info: r.data?.responseData ?? {} };
}

// Register Credential 모달로 등록. 화면이 자동으로 채운 Key 를 그대로 쓰고 Value 만 입력한다.
// 녹화에 비밀값이 찍히지 않도록 Value 입력란은 글자를 가린다(-webkit-text-security: disc, 화면 동작에는 영향 없음).
export async function uiRegister(page: Page, holder: string, provider: string, values: Record<string, string>) {
  await page.getByRole('button', { name: /Register Credential/ }).first().click();
  const modal = page.locator('#credential-create-modal');
  await expect(modal).toBeVisible();
  await page.addStyleTag({ content: '#credential-create-modal .kv-value{-webkit-text-security:disc;}' });
  await page.locator('#create-holder-name').fill(holder);
  await page.locator('#create-holder-provider').selectOption(provider);
  const keyInputs = page.locator('#kv-list-container .kv-key');
  await expect(keyInputs.first()).toBeVisible();
  const keys = (await keyInputs.evaluateAll((els) => els.map((e) => (e as HTMLInputElement).value))).filter(Boolean);
  const missing: string[] = [];
  for (let i = 0; i < keys.length; i++) {
    const v = values[keys[i]];
    if (v === undefined) { missing.push(keys[i]); continue; }
    await page.locator('#kv-list-container .kv-value').nth(i).fill(v);
  }
  const respP = page.waitForResponse((r) => r.url().includes('/RegisterCredential'), { timeout: 180_000 });
  await modal.getByRole('button', { name: /^Register$/ }).click();
  const resp = await respP;
  let body = '';
  try { body = await resp.text(); } catch { /* ignore */ }
  const toast = await page.locator('.toast, .toastify, [class*="toast"]').last().innerText({ timeout: 10_000 }).catch(() => '');
  if (await modal.isVisible()) await modal.getByRole('button', { name: 'Cancel' }).click().catch(() => {});
  return { keys, missing, status: resp.status(), body: scrub(body, values).slice(0, 600), toast: scrub(toast, values) };
}

// ── UI 등록 테스트 본문 (IV1_S35 AWS, IV1_S36 CSP별) ─────────────────────────
// 출처: 위키 Test-Specs-IV10 의 tests/iv10/_register.ts. spec 폴더가 아니라 lib 에 두어 위키 Test-Specs-Common 에 함께 게시한다.
// 자격증명 값은 CRED_VALUES_FILE(JSON {provider: {key: value}})에서 읽고 리포트·녹화에는 남기지 않는다.
export function uiRegisterTest(id: string, tc: string, provider: string) {
  test(`${id} ${tc} Credential 등록 — ${provider} UI`, async ({ page }) => {
    const v = credValues(provider);
    expect(Object.keys(v).length, `${provider} 자격증명 값 없음`).toBeGreaterThan(0);
    let r: Awaited<ReturnType<typeof uiRegister>>;

    await test.step('1. admin 로그인 후 Settings > Cloud SPs > Credentials 이동', async () => { await loginAsAdmin(page); await gotoCredentials(page); });

    await test.step(`2. Register Credential → holder ${TEST_HOLDER}, Provider ${provider} 선택 → 자동 생성된 Key 에 Value 입력 → Register`, async () => {
      r = await uiRegister(page, TEST_HOLDER, provider, v);
      test.info().annotations.push({ type: 'keys', description: `화면 자동 Key: ${r.keys.join(', ')}${r.missing.length ? ` / 값 없는 Key: ${r.missing.join(', ')}` : ''}` });
      test.info().annotations.push({ type: 'response', description: `RegisterCredential HTTP ${r.status}: ${r.body}` });
      test.info().annotations.push({ type: 'toast', description: r.toast || '(토스트 없음)' });
    });

    await test.step('3. 등록 성공: 서버 거부 없음 · 성공 토스트', async () => {
      expect(r.missing, '자격증명 값이 없는 Key').toEqual([]);
      expect(r.body, '서버가 등록을 거부함').not.toMatch(/invalid credential key|"code":\s*[45]\d\d|Internal Server Error|Bad Request/i);
      expect(r.status).toBe(200);
      expect(r.toast).toMatch(/registered successfully/i);
    });

    await test.step(`4. GetCredentialHolder(${TEST_HOLDER}) providers 에 ${provider} 포함`, async () => {
      const h = await getHolder(page, TEST_HOLDER);
      test.info().annotations.push({ type: 'holder', description: JSON.stringify(h.info) });
      expect(h.info.providers ?? []).toContain(provider);
    });
  });
}

// lib/data.ts 의 CSP code → Credentials 화면 Provider 값
export const PROVIDER: Record<string, string> = { AWS: 'aws', Azure: 'azure', Alibaba: 'alibaba', GCP: 'gcp', Tencent: 'tencent', NHNCloud: 'nhn', NCP: 'ncp', IBM: 'ibm', KT: 'kt' };

// 테스트 데이터 정의. MCMP_IV_Test_Plan.xlsx 의 "조직도_사용자", "Infra_구성도", "K8s_구성도" 시트와 동일하게 유지할 것.

export const ADMIN = {
  id: process.env.ADMIN_ID ?? 'mcmp',
  pw: process.env.ADMIN_PW ?? '<ADMIN_PW>',
};

export const WORKSPACE = 'ws01';
export const DEFAULT_PROJECT = 'default';

/** 사용자 비밀번호 규칙: {id}_password */
export const pwOf = (id: string) => `${id}_<PW>`;

// ---------- 조직 / 사용자 / 역할 ----------
export const ROOT_ORG = 'mcmp';
export const TEAMS = ['iam', 'infra', 'workflow', 'app', 'cost', 'monitor'] as const;
export type Team = (typeof TEAMS)[number];

export type Role = 'admin' | 'operator' | 'viewer' | 'billviewer' | 'billadmin';
export const ROLES: Role[] = ['admin', 'operator', 'viewer', 'billviewer', 'billadmin'];

export interface TestUser {
  id: string; // 로그인 ID (= 이메일 앞부분)
  first: string;
  last: string;
  email: string;
  team: Team;
  role: Role;
  via: 'admin' | 'signup'; // admin: 관리자가 Add User, signup: 사용자가 직접 가입 후 승인
}

const mk = (id: string, first: string, last: string, team: Team, role: Role, via: TestUser['via']): TestUser => ({
  id, first, last, email: `${id}@mcmp.test`, team, role, via,
});

export const USERS: TestUser[] = [
  mk('iam01', 'iam', '01', 'iam', 'admin', 'admin'),
  mk('infra01', 'infra', '01', 'infra', 'operator', 'admin'),
  mk('workflow01', 'workflow', '01', 'workflow', 'operator', 'signup'),
  mk('app01', 'app', '01', 'app', 'operator', 'signup'),
  mk('monitor01', 'monitor', '01', 'monitor', 'viewer', 'signup'),
  mk('cost01', 'cost', '01', 'cost', 'billviewer', 'signup'),
  mk('cost02', 'cost', '02', 'cost', 'billadmin', 'signup'),
];
export const PENDING_USER = mk('pending01', 'pending', '01', 'iam', 'viewer', 'signup'); // 가입만 하고 승인하지 않음

// ---------- CSP ----------
export interface Csp {
  n: number; // CSP 번호 (Infra mc{n}, K8s k{n}, Project p{n}, nodegroup g{n})
  name: string;
  code: string;
  skip?: string; // 사유가 있으면 SKIP
  infra: { conn: string; spec: string; image: string; note: string };
  k8s: { conn: string; version: string; spec: string; note: string };
}

export const CSPS: Csp[] = [
  { n: 1, name: 'AWS', code: 'AWS',
    infra: { conn: 'aws-ap-northeast-2', spec: 't3.micro', image: 'ami-0afe1fd15675c3f15', note: '생성 PASS 이력' },
    k8s: { conn: 'aws-ap-northeast-2', version: '1.33~1.35 중 선택', spec: 't3.medium', note: '클러스터 생성 시 nodegroup 지정 불가 → 생성 후 추가. 삭제 시 nodegroup 먼저 삭제' } },
  { n: 2, name: 'Azure', code: 'Azure',
    infra: { conn: 'azure-koreacentral', spec: 'Standard_B1s', image: 'Canonical:0001-com-ubuntu-server-jammy:22_04-lts-gen2:22.04.202606110', note: '이미지는 같은 계열 최신으로 대체될 수 있음' },
    k8s: { conn: 'azure-koreacentral', version: '(미검증)', spec: 'Standard_B2s (후보)', note: '실생성 기록 없음. 결과 그대로 기록' } },
  { n: 3, name: 'Alibaba', code: 'Alibaba',
    infra: { conn: 'alibaba-ap-northeast-2', spec: 'ecs.t6-c1m2.large', image: 'ubuntu_22_04_x64_20G_alibase_20260615.vhd', note: '콘솔 nodegroup 추가 시 spec 목록에 없으면 ecs.c7nex.large' },
    k8s: { conn: 'alibaba-ap-northeast-2', version: '1.35.7-aliyun.1', spec: 'ecs.e-c1m4.xlarge', note: '허용 버전만 선택(1.36.2/1.35.7/1.34.10-aliyun.1). 루트 디스크 cloud_essd 40GB' } },
  { n: 4, name: 'GCP', code: 'GCP',
    infra: { conn: 'gcp-asia-northeast3', spec: 'n1-standard-1', image: '.../ubuntu-os-cloud/global/images/ubuntu-2204-jammy-v20260623', note: '생성 성공 이력' },
    k8s: { conn: 'gcp-asia-northeast3', version: '(미검증)', spec: 'e2-standard-2 (후보)', note: '실생성 기록 없음. 결과 그대로 기록' } },
  { n: 5, name: 'Tencent', code: 'Tencent',
    infra: { conn: 'tencent-ap-seoul', spec: 'S5.MEDIUM2', image: 'img-487zeit5', note: '콘솔 nodegroup 추가 시 BF1.MEDIUM2 (응답 504이나 node는 생성됨)' },
    k8s: { conn: 'tencent-ap-seoul', version: '1.34.1', spec: 'S8.LARGE16', note: '시스템 디스크 CLOUD_BSSD 50GB 필수(기본값이면 node 0대). nodegroup은 생성 후 추가' } },
  { n: 6, name: 'NHN Cloud', code: 'NHNCloud',
    infra: { conn: 'nhn-kr1', spec: 'm2.c1m2', image: '0f07c795-2a46-44fc-a61b-fa0d96763ce2', note: '기존 공용 vNet 사용 필수(신규 VPC 생성 금지: 과금/쿼터 초과)' },
    k8s: { conn: 'nhn-kr1', version: 'v1.33', spec: 'r2.c4m16', note: '마지막 nodegroup 삭제 거부. 기존 공용 vNet 사용' } },
  { n: 7, name: 'NCP', code: 'NCP',
    infra: { conn: 'ncp-kr', spec: 'ci2-g3', image: '23214590', note: 'g3 spec 필수(g2에는 Ubuntu 22.04 이미지 없음)' },
    k8s: { conn: 'ncp-kr', version: '1.34 (예정)', spec: 'c2-g3 (후보)', note: '계정 VM 쿼터 0(ERROR_VM_LIMIT) 실패 이력 → BLOCKED 가능' } },
  { n: 8, name: 'IBM', code: 'IBM',
    infra: { conn: 'ibm-jp-tok', spec: 'bx2-2x8', image: 'Ubuntu 22.04 Minimal(리전별 ID)', note: '6월 e2e 생성 실패 기록. 2026-10-12 사전점검으로 jp-tok/bx2-2x8 결정. 결과 그대로 기록' },
    k8s: { conn: 'ibm-jp-tok', version: '1.34.10', spec: 'bx2-4x16', note: 'Expert 생성만 가능(Simple은 항상 실패). Active까지 약 28분' } },
  // KT: Credential 등록됨(2026-10-08), 연결 kt-kr1. IV2(vNet/SG/SSH Key/Disk) 외 Infra·K8s 입력값(spec/image)은 아직 미검증
  { n: 9, name: 'KT', code: 'KT',
    infra: { conn: 'kt-kr1', spec: '(미검증)', image: '(미검증)', note: 'IV2 자원 생성만 확인. Infra spec/image 는 사전점검 필요' },
    k8s: { conn: 'kt-kr1', version: '(미검증)', spec: '(미검증)', note: 'K8s 는 AWS 에 한해 진행' } },
];

// ---------- TC_VARIANT: 실행할 CSP 선택 ----------
// 사용 예)  TC_VARIANT=azure npx playwright test tests/iv2_to_cleanup.pending.spec.ts
//   - 값은 CSP 이름/코드(대소문자·공백·_·- 무시): aws, azure, alibaba, gcp, tencent, nhn(또는 nhncloud), ncp, ibm, kt
//   - 지정하지 않으면 KT 를 제외한 모든 CSP 를 실행. CSP 와 무관한 시나리오(IV1 등)는 영향 없음.
const norm = (s: string) => s.toLowerCase().replace(/[\s_-]/g, '');
export const VARIANT = norm(process.env.TC_VARIANT ?? '');
const aliases: Record<string, string> = { nhn: 'nhncloud' };
const wanted = aliases[VARIANT] ?? VARIANT;
if (wanted && !CSPS.some((c) => norm(c.code) === wanted || norm(c.name) === wanted)) {
  throw new Error(`TC_VARIANT=${process.env.TC_VARIANT} 에 해당하는 CSP 가 없습니다. 사용 가능: ${CSPS.map((c) => c.code).join(', ')}`);
}
/**
 * TC_VARIANT 로 선택된 CSP (KT 등 skip 사유가 있는 CSP 는 제외).
 * only: 시나리오가 엑셀에서 특정 CSP 에만 있는 경우(예: IV3_S09 는 AWS) 그 CSP 목록으로 한정한다.
 */
export const activeCsps = (only?: string[]) => {
  const set = only && only.length ? new Set(only.map(norm)) : null;
  return CSPS.filter(
    (c) => !c.skip && (!set || set.has(norm(c.code)) || set.has(norm(c.name))) && (!wanted || norm(c.code) === wanted || norm(c.name) === wanted),
  );
};

// ---------- 이름 규칙 ----------
export const infraName = (c: Csp) => `mc${c.n}`;
/** Infra nodegroup 2개: g{n}a, g{n}b */
export const infraNodegroups = (c: Csp) => [`g${c.n}`, `g${c.n}b`]; // 직접 생성 시 g{n}, 생성 후 추가하는 nodegroup g{n}b

/** Workflow 로 만든 Infra: mw{n} (직접 생성 Infra 는 mc{n}) */
export const wfInfraName = (c: Csp) => `mw${c.n}`;
/** IV2 직접 생성 자원 이름 */
export const vnetName = (c: Csp) => `v${c.n}`;
export const sgName = (c: Csp) => `sg${c.n}`;
export const keyName = (c: Csp) => `key${c.n}`;
export const diskName = (c: Csp) => `disk${c.n}`;
export const diskNameB = (c: Csp) => `disk${c.n}b`;
/** Infra node 에서 만든 Custom Image */
export const imageName = (c: Csp) => `img${c.n}`;
export const k8sName = (c: Csp) => `k${c.n}`;
/** K8s nodegroup 1개: g{n} */
export const k8sNodegroup = (c: Csp) => `g${c.n}`;
export const k8sProject = (c: Csp) => `p${c.n}`;

/** 멀티 CSP Infra mc10: KT 제외 CSP별 nodegroup 1개 (g10a, g10b, ...) */
export const MC10 = {
  name: 'mc10',
  nodegroups: CSPS.filter((c) => !c.skip).map((c, i) => ({ name: `g10${String.fromCharCode(97 + i)}`, csp: c })),
};

/** 테스트 ID: IV3_S01_AWS / IV1_S01 */
export const tid = (scn: string, csp?: Csp) => (csp ? `${scn}_${csp.code}` : scn);

import { test as base, expect } from '@playwright/test';
import fs from 'node:fs';
import path from 'node:path';
import { RUN_DIR, REC_PREFIX } from './runtag';

/**
 * 공통 fixture
 * 1) 네이티브 alert/confirm 을 자동 수락하고 메시지를 기록한다.
 *    (콘솔이 "Group created successfully." 같은 네이티브 alert 를 사용하므로 자동화에서 반드시 처리해야 한다.
 *     수동 녹화 시에는 사람이 직접 "확인"을 눌러야 한다.)
 * 2) 테스트가 끝나면 비디오를 results/recordings/{녹화파일명}.webm 으로 복사한다.
 *    테스트 ID(=녹화번호) = 테스트 제목의 첫 단어 (예: "IV3_S01_AWS 이름...").
 *    녹화파일명은 엑셀 '녹화파일명' 열(run-order.json 의 rec)이고, 비어 있으면 테스트 ID 를 쓴다.
 *    규칙(2026-10-02): {시나리오번호}_{화면}_{동작}[_{CSP}][_NG]  예) IV1_S01_Groups_CreateOrg, IV3_S02_InfraWorkloads_Create_AWS, IV1_S10_Login_WrongPassword_NG
 */
let recNames: Record<string, string> | undefined;
function recordingName(id: string): string {
  if (!recNames) {
    recNames = {};
    try {
      for (const r of JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'run-order.json'), 'utf-8'))) if (r.rec) recNames[r.id] = r.rec;
    } catch {
      // run-order.json 이 없거나 읽을 수 없으면 테스트 ID 로 저장
    }
  }
  return recNames[id] || id;
}

export const test = base.extend<{ dialogs: string[]; recording: void; netRetry: void }>({
  // WSL 에서 Docker 브릿지 등 네트워크 인터페이스가 바뀌면 Chromium 이 로딩 중 ERR_NETWORK_CHANGED 로 끊는다(2026-10-01 관찰).
  // 환경 일시 오류이므로 page.goto / page.reload 를 최대 3회 재시도한다(reload 도 같은 오류로 실패, 2026-10-05).
  netRetry: [
    async ({ page }, use) => {
      const retry = <T>(fn: (...a: any[]) => Promise<T>) => async (...args: any[]): Promise<T> => {
        for (let i = 0; ; i++) {
          try {
            return await fn(...args);
          } catch (e) {
            if (i < 3 && /ERR_NETWORK_CHANGED|ERR_NETWORK_IO_SUSPENDED|ERR_CONNECTION_RESET|ERR_NAME_NOT_RESOLVED/.test(String(e))) {
              await page.waitForTimeout(1500);
              continue;
            }
            throw e;
          }
        }
      };
      (page as any).goto = retry(page.goto.bind(page));
      (page as any).reload = retry(page.reload.bind(page));
      await use();
    },
    { auto: true },
  ],
  dialogs: [
    async ({ page }, use, testInfo) => {
      const log: string[] = [];
      page.on('dialog', async (d) => {
        log.push(`${d.type()}: ${d.message()}`);
        await d.accept();
      });
      await use(log);
      testInfo.annotations.push({ type: 'dialogs', description: log.join(' | ') || '(없음)' });
    },
    { auto: true },
  ],
  recording: [
    async ({ page }, use, testInfo) => {
      await use();
      const video = page.video();
      await page.close();
      if (!video) return;
      const id = testInfo.title.split(' ')[0];
      const dir = path.join(RUN_DIR, 'recordings'); // 예: results/v07/recordings/v07_IV1_S01_Groups_CreateOrg.webm
      fs.mkdirSync(dir, { recursive: true });
      await video.saveAs(path.join(dir, `${REC_PREFIX}${recordingName(id)}.webm`));
    },
    { auto: true },
  ],
});

export { expect };

/** 알려진 제품 이슈: 테스트는 실패할 것으로 기대한다(수정되면 통과로 바뀌어 알 수 있음). */
export const knownIssue = (t: typeof test, reason: string) => t.fail(true, reason);

import type { Locator, Page } from '@playwright/test';
import { expect } from '@playwright/test';
import { pwOf, type TestUser } from './data';

export const URL_GROUPS = '/webconsole/settings/accountnaccess/organizations/groups';
export const URL_USERS = '/webconsole/settings/accountnaccess/organizations/users';
export const URL_APPROVALS = '/webconsole/settings/accountnaccess/organizations/approvals';
export const URL_ROLES = '/webconsole/operations/manage/workspaces/roles';

/** <select> 에서 라벨이 prefix 로 시작하는 옵션을 선택 (조직은 "iam (0201)" 처럼 코드가 붙는다). */
export async function selectByPrefix(select: Locator, prefix: string) {
  // 옵션은 비동기로 채워진다(팝업을 연 직후에는 "Select a group" 하나뿐) → 2개 이상이 될 때까지 대기
  await expect.poll(async () => select.locator('option').count(), { timeout: 15_000 }).toBeGreaterThan(1);
  const labels = await select.locator('option').allTextContents();
  const label = labels.map((s) => s.trim()).find((s) => s === prefix || s.startsWith(`${prefix} (`));
  if (!label) throw new Error(`옵션 없음: ${prefix} / 존재: ${labels.join(', ')}`);
  await select.selectOption({ label });
}

/** Groups > Create Org 로 조직 생성. parent 가 없으면 최상위. */
export async function createOrg(page: Page, name: string, parent?: string) {
  await page.getByRole('button', { name: 'Create Org' }).click();
  const dlg = page.getByRole('dialog');
  await dlg.getByPlaceholder('Enter group name').fill(name);
  if (parent) await selectByPrefix(dlg.getByRole('combobox'), parent);
  await dlg.getByRole('button', { name: 'Save' }).click();
}

/** Users > Add User (관리자가 사용자 생성). 폼이 이전 값을 지우지 않으므로 fill 로 덮어쓴다. */
export async function adminCreateUser(page: Page, u: TestUser) {
  await page.goto(URL_USERS);
  await page.getByRole('link', { name: 'Add User' }).click();
  await page.getByPlaceholder('Enter first name').fill(u.first);
  await page.getByPlaceholder('Enter last name').fill(u.last);
  await page.getByPlaceholder('Login ID (e.g. abc)').fill(u.id);
  await page.getByPlaceholder('Enter email address').fill(u.email);
  await page.getByRole('button', { name: 'Deploy' }).click();
}

/** Users 목록에 사용자가 이미 있는지(재실행 가능하도록 "없을 때만 생성"하는 데 사용). admin 로그인 상태 필요. */
export async function userExists(page: Page, u: TestUser): Promise<boolean> {
  await page.goto(URL_USERS);
  await page.getByRole('gridcell').first().waitFor({ timeout: 20_000 }).catch(() => {});
  return (await page.getByRole('gridcell', { name: `${u.first} ${u.last}` }).count()) > 0;
}

/** Users 목록의 Platform Roles 열이 Y 인지(= 역할이 이미 할당됐는지). 행 텍스트 "… Enabled Y Y N" 에서 읽는다. */
export async function platformRoleAssigned(page: Page, u: TestUser): Promise<boolean> {
  await page.goto(URL_USERS);
  await page.getByRole('gridcell').first().waitFor({ timeout: 20_000 }).catch(() => {});
  const row = page.getByRole('row').filter({ hasText: u.email }).first();
  // 행 텍스트는 셀 사이 공백 없이 붙어서 읽힌다: "workflow [email protected]"
  const text = ((await row.innerText().catch(() => '')) || '').replace(/\s+/g, ' ');
  const m = text.match(/(Enabled|Disabled)\s*([YN])\s*([YN])\s*([YN])/);
  return m ? m[2] === 'Y' : false;
}

/** Approvals 에 승인 대기 중인지. admin 로그인 상태 필요. */
export async function pendingApproval(page: Page, u: TestUser): Promise<boolean> {
  await page.goto(URL_APPROVALS);
  await page.waitForTimeout(2500);
  return (await page.getByRole('row', { name: new RegExp(u.email) }).count()) > 0;
}

/** Users 목록에서 사용자 행 선택. */
export async function selectUserRow(page: Page, u: TestUser) {
  await page.getByRole('gridcell', { name: `${u.first} ${u.last}` }).click();
}

/** Users > 사용자 선택 > Add Group (Assign Group 팝업). */
export async function addGroupFromUsers(page: Page, u: TestUser) {
  await page.getByRole('button', { name: 'Add Group' }).click();
  const dlg = page.getByRole('dialog');
  await selectByPrefix(dlg.getByRole('combobox'), u.team);
  await dlg.getByRole('button', { name: 'Assign' }).click();
}

/** Groups > 조직 선택 > Invite Member (사용자 체크 후 Invite). */
export async function inviteMemberFromGroups(page: Page, u: TestUser) {
  await page.goto(URL_GROUPS);
  // 트리 항목은 Playwright 에서 treeitem 역할로 잡히지 않아(2026-10-01) 트리 안의 텍스트로 찾는다.
  await page.getByRole('tree').getByText(u.team, { exact: true }).first().click();
  // 상세(Path /mcmp/{team})가 뜨기 전에 Invite Member 를 누르면 클릭이 무시된다(2026-10-01 Playwright 확인) → 상세를 기다린 뒤 클릭
  await expect(page.getByText(`/mcmp/${u.team}`, { exact: true })).toBeVisible();
  await page.getByRole('button', { name: /Invite Member/ }).click();
  const dlg = page.getByRole('dialog');
  await expect(dlg).toBeVisible();
  const cb = dlg.locator('li, tr, div').filter({ hasText: u.email }).getByRole('checkbox').first();
  await cb.waitFor();
  if (await cb.isDisabled()) {
    // 이미 이 조직의 멤버이면 체크박스가 disabled 로 표시된다 → 건너뜀
    await dlg.getByRole('button', { name: 'Cancel' }).click();
    return;
  }
  await cb.check();
  await dlg.getByRole('button', { name: 'Invite' }).click();
  // exact: 부분 일치면 닫힌 초대 팝업의 이메일 span(hidden)을 먼저 잡는다(2026-10-04, rec1004b)
  await expect(page.getByText(u.id, { exact: true }).first()).toBeVisible();
}

/** Add Role Mapping 팝업: platform / workspace 역할 부여. Role Type 은 버튼에 따라 자동 선택되므로 Role 만 고른다. */
export async function addRole(page: Page, kind: 'platform' | 'workspace', role: string) {
  await page.getByRole('button', { name: kind === 'platform' ? /Add platform role/i : /Add Workspace role/i }).click();
  const dlg = page.getByRole('dialog');
  await dlg.getByRole('combobox').nth(1).selectOption({ label: role });
  await dlg.getByRole('button', { name: 'Add Role' }).click();
}

export async function addBothRoles(page: Page, role: string) {
  await addRole(page, 'platform', role);
  await addRole(page, 'workspace', role);
}

/**
 * 사용자 직접 가입: 로그인 화면 -> Sign Up.
 * 가입 후에는 로그인 화면으로 이동하지 않고 /auth/signup 에 머물며 다음 안내를 보여 준다(2026-10-01 Playwright 확인):
 *   "Registration request submitted. You can log in after administrator approval. You will be notified by email upon approval." + [Go to Login]
 */
export async function signUp(page: Page, u: TestUser) {
  await page.goto('/auth/login');
  await page.getByRole('link', { name: 'Sign Up' }).click();
  await page.getByPlaceholder('Your email address').fill(u.email);
  await page.getByPlaceholder('Your password').fill(pwOf(u.id));
  await page.getByPlaceholder('Your first name').fill(u.first);
  await page.getByPlaceholder('Your last name').fill(u.last);
  await page.getByRole('button', { name: 'Sign Up' }).click();
  await expect(page.getByText(/Registration request submitted/)).toBeVisible();
}

/** Users > Reset Password (관리자가 만든 사용자의 비밀번호 설정). 비밀번호는 {id}_password. */
export async function resetPassword(page: Page, u: TestUser) {
  await page.getByRole('button', { name: 'Reset Password' }).click();
  const dlg = page.getByRole('dialog');
  await dlg.getByPlaceholder('Enter new password').fill(pwOf(u.id));
  await dlg.getByPlaceholder('Confirm new password').fill(pwOf(u.id));
  await dlg.getByRole('button', { name: 'Reset Password' }).click();
}

/**
 * Groups > Export JSON. 화면이 Blob 다운로드로 {최상위 조직명}-OrganizationTree-YYYYMMDD.json 을 내려준다(2026-10-02 사전점검).
 * 내려받은 파일을 savePath 에 저장하고 파일명을 돌려준다.
 */
export async function exportGroupsJson(page: Page, savePath: string): Promise<string> {
  const dl = page.waitForEvent('download');
  await page.getByRole('button', { name: 'Export JSON' }).click();
  const d = await dl;
  await d.saveAs(savePath);
  return d.suggestedFilename();
}

/**
 * Groups > Import JSON. 버튼은 숨겨진 파일 입력(#import-groups-file, .json)을 열고, 파일을 고르는 즉시 가져온다(확인창 없음).
 * 동작(2026-10-02 소스 확인): organization_code 로 기존 그룹과 비교 → 이름 같으면 변경 없음, 다르면 이름 수정, 없으면 생성.
 * 결과는 #import-result-body("Import complete." + N group(s) created/updated ...), JSON 파싱 실패 시 알럿 "Invalid JSON file.".
 */
export async function importGroupsJson(page: Page, file: string | { name: string; mimeType: string; buffer: Buffer }) {
  const chooser = page.waitForEvent('filechooser');
  await page.getByRole('button', { name: 'Import JSON' }).click();
  await (await chooser).setFiles(file);
}


/**
 * 다운로드 결과를 녹화에 남기기 위한 화면 표시. 헤드리스 브라우저는 다운로드 표시줄(파일명)이 영상에 잡히지 않으므로
 * 페이지 위에 (1) 우상단 '다운로드 완료: 파일명' 알림 (2) 내려받은 파일 내용(JSON 은 들여쓰기) 패널을 띄우고 holdMs 동안 보여 준다.
 */
export async function showDownloadOverlay(page: Page, fileName: string, content: string, holdMs = 6000) {
  let body = content;
  try { body = JSON.stringify(JSON.parse(content), null, 2); } catch { /* JSON 이 아니면 원문 */ }
  await page.evaluate(([name, text]) => {
    const bubble = document.createElement('div');
    bubble.id = 'e2e-download-bubble';
    bubble.style.cssText = 'position:fixed;top:16px;right:16px;z-index:2147483647;background:#fff;color:#1f2937;border:1px solid #d1d5db;border-radius:8px;box-shadow:0 4px 16px rgba(0,0,0,.25);padding:12px 16px;font:14px/1.4 sans-serif;min-width:320px';
    bubble.innerHTML = '<div style="color:#16a34a;font-weight:600">다운로드 완료</div><div id="e2e-dl-name" style="margin-top:4px;font-family:monospace"></div>';
    document.body.appendChild(bubble);
    (document.getElementById('e2e-dl-name') as HTMLElement).textContent = name;
    const panel = document.createElement('div');
    panel.id = 'e2e-download-content';
    panel.style.cssText = 'position:fixed;top:96px;right:16px;bottom:16px;width:760px;z-index:2147483646;background:#0f172a;color:#e2e8f0;border-radius:8px;box-shadow:0 4px 16px rgba(0,0,0,.35);padding:12px 16px;font:12px/1.5 monospace;overflow:auto;white-space:pre';
    panel.textContent = text;
    document.body.appendChild(panel);
  }, [fileName, body]);
  await page.waitForTimeout(holdMs);
}

import { test, expect } from '@playwright/test';
import type { Page } from '@playwright/test';
import { URL_APPROVALS, URL_GROUPS, URL_USERS, selectByPrefix } from './forms';
import type { TestUser } from './data';

// Groups 화면(조직) 생성/상세/수정/삭제 셀렉터: 2026-10-04 프로브로 확인
//   상세 패널 버튼 #btn-add-child, #btn-edit, #btn-delete
//   Create Org 팝업 #group-name, #group-description, #group-parent-select, #group-code(비우면 자동)
//   Edit 팝업 #edit-group-modal: #edit-group-name, #edit-group-description, #edit-group-parent-select, #edit-group-code
//   Delete 팝업 #delete-group-modal: "Groups with child organizations or assigned users cannot be deleted."

/** 녹화용 조직(실제 조직 mcmp/iam… 은 사용자 배정이 있어 수정·삭제 대상에서 제외, 2026-10-04 사용자 결정) */
export const REC_ORG = 'recorg';
export const REC_TEAM = 'recteam';
export const REC_TEAM_EDITED = 'recteam2';

/**
 * 녹화용 사용자(IV1_S02~S04). stage 는 사용자 삭제가 불가하므로 재녹화 때마다 접미사를 바꾼다(REC_SUFFIX, 기본 1004 = 2026-10-04).
 * 권한 최소화: 조직 monitor, 역할 viewer.
 */
const REC_SUFFIX = process.env.REC_SUFFIX ?? '1004';
const recUser = (id: string, via: TestUser['via']): TestUser => ({ id, first: 'rec', last: id.slice(3), email: `${id}@mcmp.test`, team: 'monitor', role: 'viewer', via });
export const REC_ADMIN_USER = recUser(`rec${REC_SUFFIX}a`, 'admin');   // IV1_S02: 관리자가 Add User
export const REC_SIGNUP_USER = recUser(`rec${REC_SUFFIX}b`, 'signup'); // IV1_S03 가입 → IV1_S04 승인
/** IV1_S22 삭제 대상: 이름이 'rec' + 숫자로 시작하는 녹화용 사용자(Users 목록에서 동적으로 수집) */
export const REC_USER_ID = /^rec\d{4}[a-z]{1,2}$/;
export const recUserFromId = (id: string) => recUser(id, 'admin');

/**
 * Users 목록을 열고 모든 사용자가 한 페이지에 보이게 한다.
 * 녹화용 사용자가 늘어 기존 사용자가 2페이지로 밀리면 forms.ts userExists/platformRoleAssigned 가 '없음'으로 오판(2026-10-05 관찰) → 페이지 크기 최대.
 */
export async function gotoUsersAll(page: Page) {
  await page.goto(URL_USERS);
  // 주소 이동 직후 목록이 90초 넘게 비어 있는 경우가 있었음(IV1_S28, 2026-10-05 2회 연속) → 30초씩 기다리며 새로고침 재시도
  for (let attempt = 1; ; attempt++) {
    if (await page.getByRole('gridcell').first().waitFor({ timeout: 30_000 }).then(() => true, () => false)) break;
    if (attempt >= 3) throw new Error('Users 목록이 90초 동안 표시되지 않음');
    test.info().annotations.push({ type: 'list-retry', description: `시도 ${attempt}: Users 목록 미표시 → 새로고침` });
    await page.reload();
  }
  const sizeSel = page.locator('select.tabulator-page-size').first();
  if (await sizeSel.count()) {
    const vals = (await sizeSel.locator('option').evaluateAll((os) => os.map((o) => (o as HTMLOptionElement).value))).filter((v) => /^\d+$/.test(v));
    const max = vals.sort((a, b) => Number(b) - Number(a))[0];
    if (max) await sizeSel.selectOption(max);
    await page.waitForTimeout(1500);
  }
}

export async function userExistsAll(page: Page, u: TestUser) {
  await gotoUsersAll(page);
  return (await page.getByRole('gridcell', { name: `${u.first} ${u.last}` }).count()) > 0;
}

/** Platform Roles 열 Y 여부(행 텍스트 '… Enabled Y Y N'). 전체 페이지 기준 */
export async function roleAssignedAll(page: Page, u: TestUser) {
  await gotoUsersAll(page);
  const text = ((await page.getByRole('row').filter({ hasText: u.email }).first().innerText().catch(() => '')) || '').replace(/\s+/g, ' ');
  const m = text.match(/(Enabled|Disabled)\s*([YN])\s*([YN])\s*([YN])/);
  return m ? m[2] === 'Y' : false;
}

/**
 * Approvals 에 승인 대기 중인지. forms.ts pendingApproval 은 2.5초만 기다려 stage 지연 시 '없음'으로 오판(2026-10-05) →
 * waitMs 동안 대기 행이 나타나는지 확인(녹화용 사용자처럼 대기 중이어야 하는 대상에 사용).
 */
export async function pendingApprovalWait(page: Page, u: TestUser, waitMs = 60_000) {
  await page.goto(URL_APPROVALS);
  return page.getByRole('row', { name: new RegExp(u.email) }).first().waitFor({ timeout: waitMs }).then(() => true, () => false);
}

/**
 * Users 목록에서 사용자 삭제: **행 클릭(사용자 선택)** → 목록 ⌄ 메뉴 Delete → #commonDefaultModal('Would you like to delete this user ?') Confirm.
 * 체크박스만 선택하면 Confirm 후 삭제 요청이 나가지 않음(2026-10-05 관찰) → 사용자 지시로 행 클릭 방식(2026-10-05).
 * 반환: 확인 모달 문구(삭제 API 요청·응답은 annotation 'user-delete-api').
 */
export async function deleteUserByRow(page: Page, u: TestUser) {
  await gotoUsersAll(page);
  await page.getByRole('row').filter({ hasText: u.email }).first().getByRole('gridcell', { name: `${u.first} ${u.last}` }).click();
  await page.waitForTimeout(2000); // 상세 로딩(선택 사용자 지정)
  const apis: string[] = [];
  const onResp = async (r: import('@playwright/test').Response) => {
    if (/delete/i.test(r.url()) && r.request().method() !== 'OPTIONS') apis.push(`${r.status()} ${r.url().replace(/^https?:\/\/[^/]+/, '')} ${(r.request().postData() || '').slice(0, 150)}`);
  };
  page.on('response', onResp);
  await page.locator('.dropdown').filter({ has: page.locator('.dropdown-item', { hasText: /^\s*Delete\s*$/ }) }).locator('[data-bs-toggle="dropdown"]').first().click();
  await page.locator('.dropdown-item', { hasText: /^\s*Delete\s*$/ }).first().click();
  const modal = page.locator('#commonDefaultModal');
  await expect(modal).toBeVisible();
  const text = (await modal.innerText()).replace(/\s+/g, ' ');
  await modal.getByRole('button', { name: 'Confirm' }).click();
  await page.waitForTimeout(4000);
  page.off('response', onResp);
  test.info().annotations.push({ type: 'user-delete-api', description: apis.join(' | ') || '(요청 없음)' });
  return text;
}

/** Groups > 조직 선택 > Invite Member: 사용자 체크 후 Invite → 멤버 목록에 표시(트리 로딩을 기다림) */
export async function inviteToGroup(page: Page, u: TestUser) {
  await gotoGroups(page);
  await openGroup(page, u.team, `/mcmp/${u.team}`);
  // 상세가 다 뜨기 전 클릭은 무시된다(2026-10-01 관찰, 2026-10-05 재발) → 팝업이 열릴 때까지 최대 3회 클릭
  const dlg = page.getByRole('dialog');
  for (let i = 1; ; i++) {
    await page.locator('#btn-invite-member').click();
    if (await dlg.waitFor({ timeout: 5_000 }).then(() => true, () => false)) break;
    if (i >= 3) await expect(dlg, 'Invite Member 팝업').toBeVisible();
    test.info().annotations.push({ type: 'invite-retry', description: `Invite Member 클릭 후 팝업 없음(시도 ${i})` });
    await page.waitForTimeout(1500);
  }
  // 사용자 한 줄 = div.invite-user-row(이미 멤버면 체크박스 비활성 + 'Already a member'). 넓은 div 로 찾으면 목록 전체가 걸려
  // 첫 행(다른 사용자)의 비활성 체크박스를 집어 '이미 멤버'로 오판했음(2026-10-05 IV1_S27) → 행 클래스로 한정
  const cb = dlg.locator('.invite-user-row').filter({ hasText: u.email }).getByRole('checkbox');
  await cb.waitFor({ timeout: 30_000 });
  if (await cb.isDisabled()) {
    test.info().annotations.push({ type: 'preexisting', description: `${u.id}: 이미 ${u.team} 멤버` });
    await dlg.getByRole('button', { name: 'Cancel' }).click();
    return;
  }
  await cb.check();
  await dlg.getByRole('button', { name: 'Invite' }).click();
  await expect(page.getByText(u.id, { exact: true }).first(), `${u.team} 멤버에 ${u.id}`).toBeVisible({ timeout: 20_000 });
}

/** Users 목록에서 사용자 선택 → 상세 패널 텍스트(사용자 이름 이후) 기록 */
export async function userDetail(page: Page, u: TestUser) {
  await page.getByRole('gridcell', { name: `${u.first} ${u.last}` }).first().click();
  await page.waitForTimeout(2500);
  const body = (await page.locator('body').innerText()).replace(/\s+/g, ' ');
  const i = Math.max(body.lastIndexOf(u.email), body.lastIndexOf(`${u.first} ${u.last}`));
  if (i < 0) throw new Error(`${u.id} 상세 텍스트를 찾지 못함`);
  const text = body.slice(i, i + 800);
  test.info().annotations.push({ type: `user:${u.id}`, description: text.slice(0, 700) });
  return text;
}

export const groupTree = (page: Page) => page.getByRole('tree');
// jstree 항목 <a class="jstree-anchor" role="treeitem"> (getByRole('treeitem') 이 안 잡힌 이력이 있어 앵커 텍스트로 찾는다, forms.ts 참고)
export const treeItem = (page: Page, name: string) => groupTree(page).locator('a.jstree-anchor').filter({ hasText: new RegExp(`^\\s*${name}\\s*$`) });

export async function gotoGroups(page: Page) {
  await page.goto(URL_GROUPS);
  // 트리는 비동기로 채워진다 → 최상위 mcmp 가 보일 때까지 대기(stage 지연 시 20초 초과 관찰, 2026-10-05).
  // 주소 이동 직후 트리가 60초 넘게 비어 있는 경우가 있었음(IV1_S18·S20, 2026-10-02/05) → 30초씩 기다리며 Refresh 버튼 → 새로고침 순으로 재시도
  const root = treeItem(page, 'mcmp').first();
  for (let attempt = 1; ; attempt++) {
    if (await root.waitFor({ timeout: 30_000 }).then(() => true, () => false)) break;
    if (attempt >= 3) throw new Error('Groups 트리(mcmp)가 90초 동안 표시되지 않음');
    test.info().annotations.push({ type: 'tree-retry', description: `시도 ${attempt}: 트리 미표시 → ${attempt === 1 ? 'Refresh 버튼' : '새로고침'}` });
    if (attempt === 1) await page.getByRole('button', { name: 'Refresh' }).click().catch(() => page.reload());
    else await page.reload();
  }
  await page.getByRole('button', { name: 'Expand All' }).click();
  await page.waitForTimeout(500);
}

/** 조직 클릭 → 상세 패널(Code, Level, Path, Users, Description) 텍스트 반환 */
export async function openGroup(page: Page, name: string, path: string) {
  await treeItem(page, name).first().click();
  await expect(page.getByText(path, { exact: true }), `상세 Path ${path}`).toBeVisible({ timeout: 20_000 });
  await page.waitForTimeout(800);
  const body = (await page.locator('body').innerText()).replace(/\s+/g, ' ');
  const m = body.match(new RegExp(`Add Child Edit Delete (.*?)(Platform Roles|$)`));
  const detail = (m?.[1] ?? '').trim();
  test.info().annotations.push({ type: `detail:${name}`, description: detail.slice(0, 300) });
  return detail;
}

/** Create Org 팝업으로 생성(parent 없으면 최상위). Save 후 알럿 'Group created successfully.' 는 fixtures 가 수락 */
export async function createGroup(page: Page, name: string, description: string, parent?: string) {
  await page.getByRole('button', { name: 'Create Org' }).click();
  const dlg = page.getByRole('dialog');
  await dlg.locator('#group-name').fill(name);
  await dlg.locator('#group-description').fill(description);
  if (parent) await selectByPrefix(dlg.locator('#group-parent-select'), parent);
  await dlg.getByRole('button', { name: 'Save' }).click();
  await expect(treeItem(page, name).first(), `트리에 ${name} 표시`).toBeVisible({ timeout: 20_000 });
}

/** 선택된 조직 Edit: 이름·설명 변경 후 Save */
export async function editGroup(page: Page, newName: string, description: string) {
  await page.locator('#btn-edit').click();
  const dlg = page.locator('#edit-group-modal');
  await expect(dlg).toBeVisible();
  await dlg.locator('#edit-group-name').fill(newName);
  await dlg.locator('#edit-group-description').fill(description);
  await dlg.getByRole('button', { name: 'Save' }).click();
  await expect(dlg).toBeHidden({ timeout: 20_000 });
}

/** 선택된 조직 Delete → 확인 팝업 문구 반환 후 Delete 클릭 */
export async function deleteGroup(page: Page) {
  await page.locator('#btn-delete').click();
  const dlg = page.locator('#delete-group-modal');
  await expect(dlg).toBeVisible();
  const text = (await dlg.innerText()).replace(/\s+/g, ' ');
  await dlg.getByRole('button', { name: 'Delete', exact: true }).click();
  await page.waitForTimeout(2500);
  return text;
}

/** 화면 토스트(오류 포함) 텍스트 */
export const groupToasts = async (page: Page) =>
  (await page.locator('[class*="toast"], [role="alert"]').allInnerTexts()).map((s) => s.replace(/\s+/g, ' ').trim()).filter(Boolean);