// IV4_S01: Infra Node 라이프사이클 ①: 상세(nodegroup·node) 확인 → Node Reboot [정상, CSP별]
// 화면: Infra 목록 → Infra 선택 → Infra Info / Group 탭 / Default 탭 Node List → node 선택(Node Info Detail) → Node List ⌄ 메뉴 'Reboot' → 확인 팝업 → 종 아이콘 Requests 패널
// 시작 상태: admin(mcmp) 로그인 상태, Workspace=ws01 / Project=default 선택된 상태에서 시작. IV3 Infra Running
// 절차 (예: AWS 기준): 1.Infra 목록에서 mc1 선택 2.Infra Info(Name, Status, Provider) 확인 3.nodegroup 확인(g1, nodegroup 추가 후 g1b)
//   4.Default 탭 Node List 에서 node g1-1 선택 → Node Info(CSP, Region, Zone, Node Spec, OS, Public/Private IP) 및 Detail 탭 Node Status=Running 확인
//   5.node 체크 → Node List ⌄ 메뉴 Reboot → 확인 팝업('reboot the node') Confirm 6.Requests 패널 'Node reboot: g1-1' Completed 확인 7.Node Status Running 확인
// 기대결과: Infra·nodegroup·node 상세 정보 표시, Reboot 요청 Completed 후 Running (AWS 는 reboot 중에도 Running 으로 표시될 수 있음)
//
// 라이프사이클 시리즈: ①Reboot(S01) → ②Suspend/Resume(S04) → ③Terminate(S09) → ④Terminated Node Delete(S10)
// 구현 메모(2026-10-02 사전점검): Node List 카드(#tabs-mci-default)의 ⌄ 메뉴 Reboot = node 대상(VmReboot, "reboot the node").
// 목록 툴바 ⌄ 메뉴 Reboot 은 Infra 전체 대상(MciReboot)이라 쓰지 않는다. 확인 모달 #commonDefaultModal → Confirm.
// 제어는 비동기 요청: 요청 ID(mcwc-...) → 종 아이콘 패널 "Node reboot: g1-1 · Completed" 로 결과 확인.
// 선행 Infra 가 없으면 선행 미충족으로 실패 처리(ensure 는 tools/iv4-probe/ensure-mc1.spec.ts 에서 별도 수행).

import { test, expect } from '../../lib/fixtures';
import { activeCsps, tid, infraName, infraNodegroups, ADMIN } from '../../lib/data';
import { loginAndSettle } from '../../lib/ui';
import { gotoInfraList, infraRow, infraRowText, waitInfraListed, openInfraDetail, infraInfoStatus, nodeNames, readNodeInfo, nodeMenuAction, waitAsyncRequest, watchInfraStatus } from '../../lib/iv4-infra';

for (const c of activeCsps(["AWS","Azure","Alibaba","GCP","Tencent","NHN Cloud","NCP","IBM","KT"])) { // 엑셀에 있는 CSP: AWS, Azure, Alibaba, GCP, Tencent, NHN Cloud, NCP, IBM, KT
  test(`${tid("IV4_S01", c)} ` + "Infra Node 라이프사이클 ①: 상세(nodegroup·node) 확인 → Node Reboot", async ({ page }) => {
    test.setTimeout(20 * 60_000);
    const name = infraName(c);
    const [ng, ngB] = infraNodegroups(c);

    await loginAndSettle(page, ADMIN.id, ADMIN.pw);
    await gotoInfraList(page);

    // 1. 목록에서 Infra 선택(선행: Running)
    expect(await waitInfraListed(page, name), `선행 Infra ${name} 존재`).toBeTruthy();
    await expect(infraRow(page, name)).toHaveCount(1);
    const before = await infraRowText(page, name);
    test.info().annotations.push({ type: 'list-before', description: before });
    expect(before, `선행 Infra ${name} Running`).toMatch(/^Running/);

    // 2. Infra Info
    await openInfraDetail(page, name);
    const infraStatus = await infraInfoStatus(page);
    test.info().annotations.push({ type: 'infra-info', description: `Infra Info [ ${name} ] Status: ${infraStatus}` });
    expect(infraStatus).toMatch(/^Running/);

    // 3. nodegroup: Group 탭 카드 g{n}(k) 확인 (g{n}b 는 nodegroup 추가 시나리오 이후 존재)
    await page.getByRole('tab', { name: 'Group' }).click();
    const groups = (await page.locator('#tabs-mci-group li[id^="serverGroup_status_icon_"]').allInnerTexts()).map((t) => t.trim());
    test.info().annotations.push({ type: 'nodegroups', description: groups.join(', ') || '(없음)' });
    expect(groups.some((g) => g.startsWith(`${ng}(`)), `nodegroup ${ng} 표시`).toBeTruthy();
    if (!groups.some((g) => g.startsWith(`${ngB}(`))) {
      test.info().annotations.push({ type: 'nodegroup-missing', description: `${ngB} 없음 (nodegroup 추가 시나리오 미진행 상태) → ${ng} 로 진행` });
    }
    await page.getByRole('tab', { name: 'Default' }).click();

    // 4. node 상세: g{n}-1 (없으면 g{n} 의 첫 node)
    const nodes = await nodeNames(page);
    test.info().annotations.push({ type: 'nodes', description: nodes.join(', ') });
    const node = nodes.includes(`${ng}-1`) ? `${ng}-1` : nodes.find((n) => n.startsWith(`${ng}-`))!;
    expect(node, `nodegroup ${ng} 의 node`).toBeTruthy();
    const info = await readNodeInfo(page, ng, node);
    expect(info.csp.toLowerCase(), 'Node Info CSP').toContain(c.code.toLowerCase().replace('nhncloud', 'nhn'));
    expect(info.region, 'Node Info Region').not.toBe('');
    expect(info.spec, 'Node Info Node Spec').not.toBe('');
    expect(info.status, 'Detail Node Status').toMatch(/^Running/i);

    // 5~6. Node reboot → 요청 Completed
    const reqId = await nodeMenuAction(page, node, 'Reboot');
    expect(reqId, '비동기 요청 ID(mcwc-...) 발급').toMatch(/^mcwc-/);
    await waitAsyncRequest(page, reqId);

    // 7. Running 확인. AWS EC2 reboot 은 인스턴스 상태가 running 으로 유지되어 전이가 보이지 않을 수 있다(기록만)
    const trail = await watchInfraStatus(page, name, /^Running/);
    const after = await infraRowText(page, name);
    test.info().annotations.push({ type: 'list-after', description: after });
    if (trail.length <= 1) test.info().annotations.push({ type: 'no-transition-seen', description: '3~10초 주기 관찰에서 Running 외 상태 없음(AWS reboot 은 running 유지가 정상 동작일 수 있음)' });
    expect(after).toMatch(/^Running/);
    await openInfraDetail(page, name);
    expect((await readNodeInfo(page, ng, node)).status, 'reboot 후 Node Status').toMatch(/^Running/i);
    await page.waitForTimeout(3000); // 녹화 마무리
  });
}

// IV4_S02: [K8s] K8s NodeGroup(K8s node) Scale out (1→2) [정상, CSP별]  (Scale in 은 IV4_S16 으로 분리, 사용자 지시 2026-10-07)
// 대상: K8s NodeGroup / K8s node (Infra 아님 — Infra NodeGroup scale out 은 IV4_S07)
// 사용자 지시(2026-10-05): IV3 K8s 직접 생성으로 만든 k1d / g1d 대상. 2026-10-07 시나리오를 Scale out(S02) / Scale in(S16)으로 분리 — Scale out 이 성공하면 Scale in 을 진행한다.
// 화면: K8s Workloads(p1) → k1d 선택 → NodeGroup List 에서 g1d 선택 → ⌄ Edit Scaling(#nodegroup-scaling-modal: Desired Node Count -/+, Enable autoscaling, min/max, Apply)
//   → NodeGroup Info(Desired Node Size, Min/Max) / Node List(i-… node 카드) 로 확인
// 대상 변경: K8S_CLUSTER / K8S_NG 환경변수(g1d 가 삭제된 뒤 재검증은 다른 NodeGroup 으로)

import { test, expect } from '../../lib/fixtures';
import { activeCsps, k8sProject } from '../../lib/data';
import { loginAsAdmin } from '../../lib/ui';
import { editScaling, gotoK8s, selectNodeGroup } from '../../lib/iv3-k8s';

const INPUT: Record<string, { cluster: string; ng: string } | undefined> = {
  AWS: { cluster: process.env.K8S_CLUSTER ?? 'k1d', ng: process.env.K8S_NG ?? 'g1d' },
  GCP: { cluster: process.env.K8S_CLUSTER ?? 'k4s', ng: process.env.K8S_NG ?? 'g4s' }, // K8s CSP 사이클(p4, 2026-10-15)
};

async function scaleTo(page: import('@playwright/test').Page, prj: string, cluster: string, ng: string, target: number) {
  await loginAsAdmin(page);
  await gotoK8s(page, prj);
  const before = await selectNodeGroup(page, cluster, ng);
  test.info().annotations.push({ type: 'before', description: `${before.info.slice(0, 400)} / nodes=${before.nodes.join(',')}` });
  expect(before.info, 'NodeGroup Active').toMatch(/Status Active/i);
  // 판단은 Node List 의 실제 node 수 기준 — scale 후 Desired/Min/Max 표시값이 한참 뒤에 갱신됨(2026-10-07: 표시 1 / 실제 2, 약 30분 뒤 2/2)
  if (before.nodes.length === target) {
    test.info().annotations.push({ type: 'preexisting', description: `node 이미 ${target}개(Desired 표시 ${before.desired}) → Apply 생략, 상태 확인만` });
  } else {
    await editScaling(page, target);
  }
  // node 수가 target 이 될 때까지 확인(최대 15분). Desired 표시값은 기록만
  let st = before;
  await expect.poll(async () => { await gotoK8s(page, prj); st = await selectNodeGroup(page, cluster, ng); return st.nodes.length; },
    { message: `${ng} node 수 ${target}`, timeout: 15 * 60_000, intervals: [30_000] }).toBe(target);
  test.info().annotations.push({ type: 'desired-display', description: `Desired Node Size 표시 ${st.desired} / node ${st.nodes.length}개` });
  test.info().annotations.push({ type: 'after', description: `${st.info.slice(0, 400)} / nodes=${st.nodes.join(',')}` });
  // GKE 는 node 수가 바뀐 뒤에도 NodeGroup 이 한동안 Updating(2026-10-15) — Active 복귀까지 최대 20분 재조회
    await expect.poll(async () => { if (/Status Active/i.test(st.info)) return 'Active'; await page.waitForTimeout(30_000); await gotoK8s(page, prj); st = await selectNodeGroup(page, cluster, ng); return st.info.match(/Status (\S+)/)?.[1] ?? '?'; },
      { message: 'NodeGroup Active 복귀', timeout: 20 * 60_000, intervals: [1000] }).toBe('Active');
}

for (const c of activeCsps(["AWS","Azure","Alibaba","GCP","Tencent","NHN Cloud","NCP","IBM","KT"])) {
  const inp = INPUT[c.code];
  const prj = k8sProject(c);
  // 제목 첫 단어 = 녹화 파일명 (대상 구분: [K8s] K8s NodeGroup(K8s node) — Infra NodeGroup scale 은 IV4_S07)
  test(`IV4_S02_K8sWorkloads_EditScaling-ScaleOut_${c.code} [K8s] K8s NodeGroup scale out 1→2 (K8s node)`, async ({ page }) => {
    test.skip(!inp, `${c.name}: 대상 미지정`);
    test.info().annotations.push({ type: 'target', description: `K8s NodeGroup (Infra 아님): cluster=${inp!.cluster}, nodegroup=${inp!.ng}` });
    await scaleTo(page, prj, inp!.cluster, inp!.ng, 2);
  });
}

// IV4_S03: 멀티 CSP Infra 제어: nodegroup별 CSP 확인 → Node reboot [정상, 공통] — TC-INFRA-049
// 화면: Infra 목록 → mc10 선택 → Infra Info / Group 탭(NodeGroup 카드) / Default 탭 Node List → node 선택(Node Info CSP) → Node List ⌄ 'Reboot' → 확인 팝업 → 종 아이콘 Requests 패널
// 시작 상태: admin(mcmp) 로그인 상태, Workspace=ws01 / Project=default 선택된 상태에서 시작. IV3_S11(TC-WF-008) 완료 — mc10 Running
// 절차: 1.Infra 목록에서 mc10 선택(Running) 2.Group 탭에서 NodeGroup 8개(g10-<csp>) 확인 3.Default 탭에서 CSP별 node g10-<csp>-1 을 하나씩 선택해 Node Info CSP 가 NodeGroup 이름의 CSP 와 같은지 확인
//   4.NodeGroup 1개(기본 g10-aws, 환경변수 IV4_S03_NG)의 node 를 체크 → Node List ⌄ Reboot → Confirm('reboot the node') 5.Requests 패널 'Node reboot' Completed 6.node·Infra Running 복귀 확인
// 입력값: Infra=mc10 / Workspace=ws01 / Project=default
// 기대결과: nodegroup별 CSP 표시, 상태 전이 후 Running 복귀
// 비고: 2026-10-16 구현(stub 대체). Drive 절차의 nodegroup 이름 g10a~g10h 는 직접 생성 계획 이름 — Workflow(IV3_S11) 생성 결과는 g10-<csp>(예 g10-aws)
//   reboot 대상은 Node List ⌄ 메뉴(node 대상 VmReboot). 목록 툴바 ⌄ Reboot 은 Infra 전체 대상이라 쓰지 않음(IV4_S01 과 같음)

import { test, expect } from '../../lib/fixtures';
import { tid, ADMIN } from '../../lib/data';
import { loginAndSettle } from '../../lib/ui';
import { gotoInfraList, infraRowText, waitInfraListed, openInfraDetail, infraInfoStatus, nodeNames, readNodeInfo, nodeMenuAction, waitAsyncRequest, watchInfraStatus } from '../../lib/iv4-infra';
import { MC10_NAME, MC10_CSPS, mc10Ng, mc10Node } from '../../lib/iv3-mc10';

test(`${tid('IV4_S03')} 멀티 CSP Infra 제어: nodegroup별 CSP 확인 → Node reboot`, async ({ page }) => {
  test.setTimeout(30 * 60_000);
  const name = MC10_NAME;
  const rebootCsp = process.env.IV4_S03_NG?.replace(/^g10-/, '') ?? 'aws';
  await loginAndSettle(page, ADMIN.id, ADMIN.pw);
  await gotoInfraList(page);

  // 1. mc10 (선행 IV3_S11)
  expect(await waitInfraListed(page, name), `선행 IV3_S11 의 ${name} 존재`).toBeTruthy();
  const before = await infraRowText(page, name);
  test.info().annotations.push({ type: 'list-before', description: before });
  expect(before, `${name} Running`).toMatch(/^Running/);
  await openInfraDetail(page, name);
  test.info().annotations.push({ type: 'infra-info', description: `Infra Info [ ${name} ] Status: ${await infraInfoStatus(page)}` });

  // 2. Group 탭 NodeGroup 카드
  await page.getByRole('tab', { name: 'Group' }).click();
  await page.waitForTimeout(1500);
  const groups = (await page.locator('#tabs-mci-group li[id^="serverGroup_status_icon_"]').allInnerTexts()).map((t) => t.trim());
  test.info().annotations.push({ type: 'nodegroups', description: groups.join(', ') || '(없음)' });
  // IV3_S11 에서 생성되지 않은 NodeGroup(2026-10-16: g10-ncp·g10-nhn — CSP VPC 쿼터)은 TC-WF-008 결과로 기록하고, 이 TC 는 있는 NodeGroup 으로 판정
  const present = MC10_CSPS.filter((c) => groups.some((g) => g.startsWith(`${mc10Ng(c)}(`)));
  const missing = MC10_CSPS.filter((c) => !present.includes(c));
  test.info().annotations.push({ type: 'nodegroups-missing', description: missing.length ? `${missing.map(mc10Ng).join(', ')} 없음(IV3_S11 미생성)` : '없음(8개 모두 존재)' });
  expect(present.length, 'NodeGroup 2개 이상(멀티 CSP)').toBeGreaterThanOrEqual(2);
  await page.getByRole('tab', { name: 'Default' }).click();

  // 3. NodeGroup별 CSP
  const nodes = await nodeNames(page);
  test.info().annotations.push({ type: 'nodes', description: nodes.join(', ') });
  const map: string[] = [];
  for (const c of present) {
    const info = await readNodeInfo(page, mc10Ng(c), mc10Node(c));
    map.push(`${mc10Ng(c)} → CSP ${info.csp} / ${info.region} / ${info.status}`);
    expect(info.csp.toLowerCase(), `${mc10Ng(c)} 의 CSP`).toContain(c);
  }
  test.info().annotations.push({ type: 'nodegroup-csp', description: map.join(' | ') });

  // 4~5. NodeGroup 1개의 node reboot
  const ng = mc10Ng(rebootCsp);
  const node = mc10Node(rebootCsp);
  const info = await readNodeInfo(page, ng, node);
  expect(info.status, `${node} Running`).toMatch(/^Running/i);
  const reqId = await nodeMenuAction(page, node, 'Reboot');
  expect(reqId, '비동기 요청 ID(mcwc-...) 발급').toMatch(/^mcwc-/);
  await waitAsyncRequest(page, reqId);

  // 6. Running 복귀
  const trail = await watchInfraStatus(page, name, /^Running/);
  const after = await infraRowText(page, name);
  test.info().annotations.push({ type: 'list-after', description: after });
  if (trail.length <= 1) test.info().annotations.push({ type: 'no-transition-seen', description: '관찰 주기 안에 Running 외 상태 없음(CSP 에 따라 reboot 중에도 Running 유지)' });
  expect(after).toMatch(/^Running/);
  await openInfraDetail(page, name);
  expect((await readNodeInfo(page, ng, node)).status, 'reboot 후 Node Status').toMatch(/^Running/i);
  await page.waitForTimeout(3000); // 녹화 마무리
});

// IV4_S04: Infra Node 라이프사이클 ②-1: Suspend → Suspended 확인 [정상, CSP별]  (Resume 은 IV4_S15 로 분리, 사용자 승인 2026-10-07)
// 대상: Infra node (K8s node 아님)
// 화면: Infra 목록 → Infra 선택 → Default 탭 Node List → node 선택(Node Info) → Node List ⌄ 메뉴 'Suspend' → 확인 팝업 → 종 아이콘 Requests 패널
// 시작 상태: admin(mcmp) 로그인 상태, Workspace=ws01 / Project=default 선택된 상태에서 시작. IV3 Infra Running
// 절차 (예: AWS 기준): 1.Infra 목록에서 mc1 선택 → Default 탭 Node List 에서 node g1-1 선택(Node Info 확인) 2.node 체크 → Node List ⌄ 메뉴 Suspend → 확인 팝업 Confirm
//   3.Requests 패널 Completed 확인 4.Node Status=Suspended 확인(Node Info) 5.목록 Suspended 열 +1 확인(목록 갱신이 node 상태보다 늦으므로 갱신될 때까지 재확인)
// 기대결과: Suspend 후 Suspended 로 전이, 목록 Suspended 열과 Node Info Node Status 갱신. **테스트는 Suspended 상태로 끝난다**(Resume 은 IV4_S15, 또는 다음 테스트 시작 시 Resume)
//
// 구현 메모: Node List ⌄ 메뉴 Suspend/Resume = node 대상(VmSuspend/VmResume, "suspend/resume the node").
//   v07(2026-10-07): 목록의 Suspended 열이 node 상태(Suspended, 23초)보다 1분 이상 늦게 갱신됨(S07 시점에 반영) → 즉시 단정하지 않고 재확인.

import { test, expect } from '../../lib/fixtures';
import { activeCsps, tid, infraName, infraNodegroups, ADMIN } from '../../lib/data';
import { loginAndSettle } from '../../lib/ui';
import { gotoInfraList, infraRowText, waitInfraListed, openInfraDetail, nodeNames, readNodeInfo, nodeMenuAction, waitAsyncRequest, waitNodeStatus, infraCounts, refreshInfraList } from '../../lib/iv4-infra';

for (const c of activeCsps(["AWS","Azure","Alibaba","GCP","Tencent","NHN Cloud","NCP","IBM","KT"])) { // 엑셀에 있는 CSP: AWS, Azure, Alibaba, GCP, Tencent, NHN Cloud, NCP, IBM, KT
  test(`${tid("IV4_S04", c)} ` + "[Infra] Infra Node 라이프사이클 ②-1: Suspend → Suspended 확인", async ({ page }) => {
    test.setTimeout(40 * 60_000);
    const name = infraName(c);
    const ng = infraNodegroups(c)[0];
    test.info().annotations.push({ type: 'target', description: `Infra node (K8s 아님): infra=${name}, nodegroup=${ng}` });

    await loginAndSettle(page, ADMIN.id, ADMIN.pw);
    await gotoInfraList(page);
    expect(await waitInfraListed(page, name), `선행 Infra ${name} 존재`).toBeTruthy();
    const c0 = await infraCounts(page, name);
    test.info().annotations.push({ type: 'list-before', description: `${await infraRowText(page, name)} / ${c0.cells}` });

    // 1. node 선택 → Node Info (Running)
    await openInfraDetail(page, name);
    const nodes = await nodeNames(page);
    const node = nodes.includes(`${ng}-1`) ? `${ng}-1` : nodes.find((n) => n.startsWith(`${ng}-`))!;
    expect(node, `nodegroup ${ng} 의 node`).toBeTruthy();
    expect((await readNodeInfo(page, ng, node)).status, '시작 Node Status(선행: Running — Suspended 이면 IV4_S15 로 먼저 Resume)').toMatch(/^Running/i);

    // 2~4. Suspend → Completed → Suspended
    const r1 = await nodeMenuAction(page, node, 'Suspend');
    expect(r1, 'Suspend 비동기 요청 ID').toMatch(/^mcwc-/);
    await waitAsyncRequest(page, r1, 15 * 60_000);
    expect(await waitNodeStatus(page, name, ng, node, /^Suspended/i), `${node} Suspended`).toMatch(/^Suspended/i);

    // 5. 목록 Suspended 열 +1 (갱신 지연 대비 최대 5분 재확인)
    let c1 = await infraCounts(page, name);
    await expect.poll(async () => { await refreshInfraList(page); c1 = await infraCounts(page, name); return c1.suspended; },
      { message: '목록 Suspended 열 +1', timeout: 5 * 60_000, intervals: [15_000] }).toBe(c0.suspended + 1);
    test.info().annotations.push({ type: 'list-suspended', description: c1.cells });
    await page.waitForTimeout(3000); // 녹화 마무리
  });
}

// IV4_S05: CSP 테스트 종료: Infra 전체 중지 (비용 방지, 녹화 선택) [정상, CSP별] — TC-INFRA-052
// 화면: Infra Workloads 목록 → Infra 행 선택(Infra Info) → 목록 카드 'List of Infra' ⌄ 메뉴 Suspend → 확인 팝업('Would you like to suspend Infra ?') Confirm → 목록 Status
// 시작 상태: admin(mcmp) 로그인 상태, Workspace=ws01 / Project=default 선택된 상태에서 시작. 해당 CSP 의 IV2~IV7 완료
//
// ■ '전체 중지' 대상 범위(2026-10-16 확정, 결과 문서 docs/drive-sync/결과_미실행_스텁_20261016.md 와 같음)
//   - Workspace ws01 / Project default (namespace default) 의 Infra 만. 다른 Project(p1~p8·ns01·system)와 K8s 클러스터는 대상 아님
//   - CSP n 별 대상 Infra: mc{n}(IV3_S02 직접 생성) 과 mw{n}(IV3_S01 Workflow 생성) — Drive 입력값 'Infra=mc1, mw1'(AWS 기준)의 CSP별 확장
//     AWS=mc1·mw1, Azure=mc2·mw2, Alibaba=mc3·mw3, GCP=mc4·mw4, Tencent=mc5·mw5, NHN=mc6·mw6, NCP=mc7·mw7, IBM=mc8·mw8, KT=mc9·mw9
//   - 멀티 CSP Infra mc10 은 대상 아님(CL_S02 로 삭제). 그 밖의 Infra(mt1 등)도 대상 아님. 환경변수 IV4_S05_INFRAS(쉼표 구분)로 바꿀 수 있음
//   - 이미 Suspended 인 Infra 는 제어하지 않고 상태만 기록, 목록에 없는 Infra 는 '없음' 기록. 대상이 하나도 없으면 SKIP
//   - 실행은 사용자/메인 세션 지시가 있을 때만(다른 세션이 만든 mc*·mw* 를 중지하므로). 2026-10-16 작성 시점에는 실행하지 않음
// 절차 (예: AWS 기준): 1.Infra 목록에서 mc1 선택 → ⌄ Suspend → Confirm 2.mw1 선택 → ⌄ Suspend → Confirm 3.둘 다 목록 Status Suspended 확인
// 기대결과: 다른 CSP 테스트 진행 중 해당 CSP VM 이 과금되지 않도록 중지(목록 Status Suspended, Running 열 0)
// 비고: 2026-10-16 구현(stub 대체). Infra 단위 Suspend 는 lib/iv3-mc10.ts infraListAction(행 클릭으로 대상 지정 + 제어 요청 본문에 Infra 이름 확인)

import { test, expect } from '../../lib/fixtures';
import { activeCsps, tid, infraName, wfInfraName } from '../../lib/data';
import { loginAsAdmin } from '../../lib/ui';
import { gotoInfraList, waitInfraListed, infraRowText, waitInfraStatus } from '../../lib/iv4-infra';
import { infraListAction } from '../../lib/iv3-mc10';

for (const c of activeCsps(["AWS","Azure","Alibaba","GCP","Tencent","NHN Cloud","NCP","IBM","KT"])) { // 엑셀에 있는 CSP: AWS, Azure, Alibaba, GCP, Tencent, NHN Cloud, NCP, IBM, KT
  test(`${tid("IV4_S05", c)} ` + "CSP 테스트 종료: Infra 전체 중지 (비용 방지, 녹화 선택)", async ({ page }) => {
    test.setTimeout(30 * 60_000);
    const targets = (process.env.IV4_S05_INFRAS ?? `${infraName(c)},${wfInfraName(c)}`).split(',').map((s) => s.trim()).filter(Boolean);
    test.info().annotations.push({ type: 'scope', description: `ws01 / default(namespace default) / Infra=${targets.join(',')} (mc10·K8s·다른 Project 제외)` });
    await loginAsAdmin(page);
    await gotoInfraList(page);
    const result: string[] = [];
    let handled = 0;
    for (const name of targets) {
      if (!(await waitInfraListed(page, name))) { result.push(`${name}: 목록에 없음`); continue; }
      handled++;
      const before = await infraRowText(page, name);
      // 목록 Status 는 Suspend 완료를 'Stopped' 로 표시(2026-10-16 확인) → Suspended/Stopped 를 중지로 본다
      if (/^(Suspended|Stopped)/i.test(before)) { result.push(`${name}: 이미 중지 (${before})`); continue; }
      await infraListAction(page, name, 'Suspend');
      await gotoInfraList(page);
      const after = await waitInfraStatus(page, name, /^(Suspended|Stopped)/i, 15 * 60_000);
      result.push(`${name}: ${before.split(' ')[0]} → ${after}`);
    }
    test.info().annotations.push({ type: 'result', description: result.join(' | ') });
    test.skip(handled === 0, `대상 Infra 없음: ${result.join(' | ')}`);
    await gotoInfraList(page);
    for (const name of targets) {
      const row = await infraRowText(page, name);
      if (row) expect(row, `${name} Suspended(Stopped)`).toMatch(/^(Suspended|Stopped)/i);
    }
    await page.waitForTimeout(3000); // 녹화 마무리
  });
}

// IV4_S06: Infra Terminal 접속 (Infra/Node) [정상, CSP별] — TC-INFRA-028
// 화면: Infra Workloads > Infra 선택 > Node Info Public IP 옆 'Terminal'(Remote Terminal xterm) / Infra Info 우상단 'Terminal'(Infra 전체 Execute Commands)
//   / Group 탭 NodeGroup 선택 → 'Terminal'(NodeGroup 전체 Execute Commands)
// 시작 상태: admin(mcmp) 로그인 상태, Workspace=ws01 / Project=default 선택된 상태에서 시작. 대상 CSP node Running
// 대상 Infra(2026-10-16 사용자 지시: 다른 세션이 만든 mc1~mc9 는 쓰지 않음, lib/iv3-mc10.ts pickNodeTarget):
//   1) IV3_S01 Workflow 결과 mw{n}(해당 CSP node Running) 2) 이 세션 IV3_S11 결과 mc10(g10-<csp>-1 Running)
//   3) Running 이 없으면 Suspended 인 mw{n} → mc{n} 을 화면에서 Resume 후 테스트하고 끝나면(실패해도) 다시 Suspend(사용자 지시 2026-10-16, lib withResumed)
//   4) 없으면 SKIP(사전 조건 없음)
//   Drive 입력값 Infra=mc1 / Node=g1-1 은 다른 세션 Infra 라 위 대상으로 대체(결과 문서 비고)
// 절차 (예: AWS 기준): 1.Infra 목록에서 대상 Infra 선택 2.Node List 에서 대상 node 선택 → Node Info 의 Public IP 옆 'Terminal' → Confirm
//   3.터미널에서 whoami(cb-user)·hostname 실행 4.Infra Info 우상단 'Terminal'(Infra 전체 대상) → Execute Commands 에 hostname → Execute → 결과 확인
//   5.Group 탭에서 대상 NodeGroup 선택 → 'Terminal'(NodeGroup 대상) → hostname → Execute → 결과 확인
// 기대결과: 터미널이 열리고 SSH 접속 성공(cb-user), 명령 응답 표시(Infra·NodeGroup 일괄 실행 결과 포함)
// 비고: 2026-10-16 구현(stub 대체). Node Terminal 헬퍼는 IV4_S12 와 같은 lib/iv4-infra.ts openNodeTerminal/termRun

import { test, expect } from '../../lib/fixtures';
import type { Page } from '@playwright/test';
import { activeCsps, tid } from '../../lib/data';
import { loginAsAdmin } from '../../lib/ui';
import { gotoInfraList, openInfraDetail, nodeNames, readNodeInfo, openNodeTerminal, termRun } from '../../lib/iv4-infra';
import { pickNodeTarget, withResumed } from '../../lib/iv3-mc10';

const note = (type: string, d: string) => test.info().annotations.push({ type, description: d.slice(0, 1500) });
const clean = (s: string) => s.replace(/\s+/g, ' ').trim();

/** Infra/NodeGroup 일괄 명령: Terminal 링크 → Confirm → #<kind>-cmdtestmodal Execute Commands → 결과 텍스트 */
async function batchCommand(page: Page, kind: 'mci' | 'nodegroup', link: string, cmd: string) {
  await page.locator(`a[onclick*="${link}"]:visible`).first().click();
  const confirm = page.locator('#commonDefaultModal');
  await expect(confirm).toBeVisible();
  note(`${kind}-confirm`, clean(await confirm.innerText()));
  await confirm.locator('#commonDefaultModal-confirm-btn').click();
  const modal = page.locator(`#${kind}-cmdtestmodal`);
  await expect(modal).toBeVisible({ timeout: 20_000 });
  await modal.locator(`#${kind}-command-input`).fill(cmd);
  await page.waitForTimeout(800); // 녹화용
  await modal.locator(`#${kind}-execute-command-btn`).click();
  // 실행 확인 모달(confirmCommandExecution)이 뜨면 확인
  // 'Confirm Remote Command'(Target … This will run on N node(s). / Run on N node(s)) — 2026-10-16 확인
  const run = page.getByRole('button', { name: /^Run on \d+ nodes?$/ }).last();
  await expect(run, `${kind} 실행 확인 팝업`).toBeVisible({ timeout: 15_000 });
  const ask = page.locator('.modal.show').filter({ hasText: 'Confirm Remote Command' }).last();
  note(`${kind}-exec-confirm`, clean(await ask.innerText().catch(() => '')).slice(0, 300));
  await page.waitForTimeout(800); // 녹화용
  await run.click();
  // 결과는 'Remote Terminal — Execution Result/Output' 모달(Execution Result Summary n/n · NODE ID/NODE IP/STATUS/RESULT 표, 5행 단위 페이지)로 표시(2026-10-16 확인)
  const res = page.locator('.modal.show').filter({ hasText: 'Execution Result Summary' }).last();
  await expect(res, `${kind} 실행 결과 표시`).toBeVisible({ timeout: 180_000 });
  await expect(res, `${kind} 실행 완료`).toContainText(/Execution Complete|Complete/i, { timeout: 180_000 });
  await page.waitForTimeout(3000);
  let out = clean(await res.innerText());
  // 2페이지 이후 결과도 읽는다(Next)
  for (let i = 0; i < 3; i++) {
    const next = res.getByText('Next', { exact: true });
    if (!(await next.isVisible().catch(() => false)) || !(await res.getByText(String(i + 2), { exact: true }).isVisible().catch(() => false))) break;
    await next.click(); await page.waitForTimeout(1000);
    out += ' || ' + clean(await res.locator('table').first().innerText().catch(() => ''));
  }
  note(`${kind}-result`, out.slice(0, 1500));
  await page.waitForTimeout(1500); // 녹화용
  await res.getByRole('button', { name: 'Close' }).last().click().catch(() => page.keyboard.press('Escape'));
  await expect(res).toBeHidden({ timeout: 10_000 }).catch(() => {});
  if (await modal.isVisible().catch(() => false)) await modal.getByRole('button', { name: 'Close' }).last().click().catch(() => page.keyboard.press('Escape'));
  return out;
}

for (const c of activeCsps(["AWS","Azure","Alibaba","GCP","Tencent","NHN Cloud","NCP","IBM","KT"])) { // 엑셀에 있는 CSP: AWS, Azure, Alibaba, GCP, Tencent, NHN Cloud, NCP, IBM, KT
  test(`${tid("IV4_S06", c)} ` + "Infra Terminal 접속 (Infra/Node)", async ({ page }) => {
    test.setTimeout(20 * 60_000);
    await loginAsAdmin(page);
    await gotoInfraList(page);
    const { target, seen } = await pickNodeTarget(page, c.n, c.code);
    note('target-candidates', seen);
    test.skip(!target, `사전 조건 없음: ${c.name} node 가 Running 인 대상 Infra(mw${c.n} 또는 mc10) 없음 — ${seen}`);
    const t = target!;
    note('target', `${t.infra} / ${t.ng} / ${t.node} (${t.why})`);
    // Suspended 대상이면 Resume → 테스트 → 다시 Suspend(사용자 지시 2026-10-16)
    await withResumed(page, t, async () => {
    // 1~2. 대상 node → Node Info Public IP 옆 Terminal
    await openInfraDetail(page, t.infra);
    expect(await nodeNames(page), `${t.node} 존재`).toContain(t.node);
    const info = await readNodeInfo(page, t.ng, t.node);
    expect(info.status, `${t.node} Running`).toMatch(/^Running/i);
    await openNodeTerminal(page);
    // 3. 접속 계정·명령 응답
    const who = await termRun(page, 'whoami');
    expect(who, '접속 계정 cb-user').toContain('cb-user');
    const host = await termRun(page, 'hostname');
    expect(host.trim(), 'hostname 응답').not.toBe('');
    const term = page.locator('#cmdtestmodal');
    await term.getByRole('button', { name: 'Close' }).last().click().catch(() => page.keyboard.press('Escape'));
    await expect(term).toBeHidden({ timeout: 10_000 }).catch(() => {});

    // 4. Infra Info 우상단 Terminal(Infra 전체)
    const infraOut = await batchCommand(page, 'mci', 'initMciRemoteCmdModal', 'hostname');
    expect(infraOut, 'Infra 일괄 실행 결과에 오류 없음').not.toMatch(/\bfail(ed)?\b|error/i);
    expect(infraOut.toLowerCase(), `Infra 일괄 결과에 대상 node(${t.node}) 또는 hostname(${host.trim()})`).toMatch(new RegExp(`${t.node}|${host.trim().split(/\s+/)[0]}`, 'i'));

    // 5. Group 탭 → NodeGroup 선택 → Terminal
    // 'Group' 탭 링크가 숨은 영역에도 있어 보이는 상세 탭(href=#tabs-mci-group)을 누른다(2026-10-16 1차 실패)
    // 결과 모달을 닫으면 상세(Infra Info)가 닫히고 목록만 남음 → 다시 연다
    if (await page.locator('.modal.show').count()) await page.keyboard.press('Escape');
    await openInfraDetail(page, t.infra);
    await page.locator('a[href="#tabs-mci-group"]:visible').first().click();
    await page.waitForTimeout(2000);
    const ngcb = page.locator(`#checkbox_vmGroup_${t.ng}`);
    if (!(await ngcb.isChecked())) await page.locator(`#serverGroup_status_icon_${t.ng}`).click();
    await expect(ngcb, `NodeGroup ${t.ng} 선택`).toBeChecked();
    await page.waitForTimeout(1500);
    const ngOut = await batchCommand(page, 'nodegroup', 'initNodeGroupRemoteCmdModal', 'hostname');
    expect(ngOut, 'NodeGroup 일괄 실행 결과에 오류 없음').not.toMatch(/\bfail(ed)?\b|error/i);
    expect(ngOut.toLowerCase(), `NodeGroup 결과에 ${t.node} 또는 hostname`).toMatch(new RegExp(`${t.node}|${host.trim().split(/\s+/)[0]}`, 'i'));
    });
  });
}

// IV4_S07: Infra NodeGroup Scale (Scale Group Size) out [정상, CSP별]
// 화면: Infra Workloads > Infra 선택 > 상세 Group 탭 > NodeGroup 카드 선택 > Scale Group Size
// 시작 상태: admin(mcmp) 로그인 상태, Workspace=ws01 / Project=default 선택된 상태에서 시작. IV3 Infra Running
// 절차 (예: AWS 기준): 1.Infra 목록에서 mc1 선택 2.Group 탭 → NodeGroup g1 선택 → Scale Group Size: node 1개 추가 (scale out) 3.Default 탭 Node List 에서 신규 node Running 확인
// 기대결과: scale out 시 node 추가 후 Running, 목록 Total Nodes 갱신
//
// 구현 메모(2026-10-02): Infra 에는 scale in 기능이 없다(사용자 확인, scale out 만). 'Scale Group Size'(#scaleGroupToggle)는 모달이 아니라
// Group 탭 안에 인라인 패널(#scaleGroupFormList: – / 읽기전용 숫자(기본 1) / + / Apply, "(Nodes to add)")을 연다 → 값은 "추가할 node 수".
// 실행할 때마다 node 가 늘어난다(되돌릴 수 없음, 과금).
//
// 대상/크기 지정(2026-10-05 사용자 요청: mc1 의 GCP nodegroup g1c 를 3 으로 scale out):
//   TC_VARIANT=<nodegroup 의 CSP>  IV4_SCALE_INFRA=<Infra>(기본 mc{n})  IV4_SCALE_NG=<nodegroup>(기본 g{n})  IV4_SCALE_TO=<목표 node 수>(기본 현재+1)
//   예) TC_VARIANT=gcp IV4_SCALE_INFRA=mc1 IV4_SCALE_NG=g1c IV4_SCALE_TO=3 → 녹화 IV4_S07_GCP_scaleout_g1c.webm
//   nodegroup 의 실제 CSP 가 TC_VARIANT 와 다르면 실패한다. 추가 수 = IV4_SCALE_ADD, 없으면 목표 - 현재
//   예) TC_VARIANT=aws IV4_SCALE_INFRA=mc1 IV4_SCALE_NG=g1b IV4_SCALE_ADD=2 → g1b 에 2개 추가
//   다른 nodegroup 이 Suspended 여도 진행한다(선행: 대상 nodegroup 에 Running node 존재). 기대: 추가된 node 만큼 Total/Running 증가.

import { test, expect } from '../../lib/fixtures';
import { activeCsps, tid, infraName, infraNodegroups, ADMIN } from '../../lib/data';
import { loginAndSettle } from '../../lib/ui';
import { gotoInfraList, waitInfraListed, openInfraDetail, infraInfoStatus, nodeNames, readNodeInfo, infraCounts, withAsyncRequest, waitAsyncRequest, refreshInfraList } from '../../lib/iv4-infra';

for (const c of activeCsps(["AWS","Azure","Alibaba","GCP","Tencent","NHN Cloud","NCP","IBM","KT"])) { // 엑셀에 있는 CSP: AWS, Azure, Alibaba, GCP, Tencent, NHN Cloud, NCP, IBM, KT
  // 녹화 파일명 = 제목 첫 단어. 대상 nodegroup 을 지정한 실행은 액션을 붙여 기본 녹화와 구분한다(사용자 지시 2026-10-05)
  //   예) IV4_SCALE_NG=g1c → results/recordings/IV4_S07_AWS_scaleout_g1c.webm
  const recId = process.env.IV4_SCALE_NG ? `${tid("IV4_S07", c)}_scaleout_${process.env.IV4_SCALE_NG}` : tid("IV4_S07", c);
  test(`${recId} ` + "Infra NodeGroup Scale (Scale Group Size) out", async ({ page }) => {
    test.setTimeout(40 * 60_000);
    const name = process.env.IV4_SCALE_INFRA || infraName(c);
    const ng = process.env.IV4_SCALE_NG || infraNodegroups(c)[0];

    await loginAndSettle(page, ADMIN.id, ADMIN.pw);
    await gotoInfraList(page);

    // 1. 목록에서 Infra 선택
    expect(await waitInfraListed(page, name), `선행 Infra ${name} 존재`).toBeTruthy();
    const c0 = await infraCounts(page, name);
    test.info().annotations.push({ type: 'list-before', description: c0.cells });
    expect(Number.isFinite(c0.total), `Total Nodes 열 읽기(${c0.cells})`).toBeTruthy();
    await openInfraDetail(page, name);
    test.info().annotations.push({ type: 'infra-info-before', description: await infraInfoStatus(page) });
    const nodesBefore = await nodeNames(page);
    const ngBefore = nodesBefore.filter((n) => n.startsWith(`${ng}-`));
    test.info().annotations.push({ type: 'nodes-before', description: nodesBefore.join(', ') });
    // 선행: 대상 nodegroup 에 Running node 존재
    const ngStatus: string[] = [];
    for (const n of ngBefore) {
      const info = await readNodeInfo(page, ng, n);
      // 녹화번호의 CSP(TC_VARIANT) 와 nodegroup 실제 CSP 가 같아야 한다(2026-10-05: mc1 의 g1c 는 GCP)
      expect(info.csp.toLowerCase(), `${ng} 의 CSP 가 ${c.code} 여야 함 → TC_VARIANT 를 nodegroup CSP 로 지정`).toContain(c.code.toLowerCase().replace('nhncloud', 'nhn'));
      ngStatus.push(`${n}=${info.status}`);
    }
    test.info().annotations.push({ type: 'nodegroup-before', description: `${ng}: ${ngStatus.join(', ')}` });
    // 기존 node 가 Suspended 여도 scale out 은 진행한다(2026-10-05 사용자 요청: g1b-1 Suspended 상태에서 +2). 상태는 기록만
    if (!ngStatus.some((s) => /=Running/i.test(s))) test.info().annotations.push({ type: 'nodegroup-no-running', description: `${ng} 에 Running node 없음 → 기록만 하고 진행` });

    // 추가 수: IV4_SCALE_ADD(추가할 node 수) 우선, 없으면 IV4_SCALE_TO(목표 node 수) - 현재, 둘 다 없으면 1
    const add = process.env.IV4_SCALE_ADD ? Number(process.env.IV4_SCALE_ADD) : Number(process.env.IV4_SCALE_TO || ngBefore.length + 1) - ngBefore.length;
    const target = ngBefore.length + add;
    test.info().annotations.push({ type: 'scale-plan', description: `${ng}: ${ngBefore.length} → ${target} (추가 ${add})` });
    expect(add, `추가 node 수(목표 ${target} - 현재 ${ngBefore.length})`).toBeGreaterThan(0);

    // 2. Group 탭 → 대상 NodeGroup 만 체크 → Scale Group Size: add 개 추가
    await page.getByRole('tab', { name: 'Group' }).click();
    const grp = page.locator('#tabs-mci-group');
    const card = grp.locator(`#serverGroup_status_icon_${ng}`);
    await expect(card).toBeVisible({ timeout: 20_000 });
    test.info().annotations.push({ type: 'nodegroup-card', description: (await card.innerText()).trim() });
    for (const other of await grp.locator('.vmgroup-checkbox').evaluateAll((els) => els.map((e) => e.id))) {
      if (other === `checkbox_vmGroup_${ng}`) continue;
      const ocb = grp.locator(`#${other}`);
      if (await ocb.isChecked()) await ocb.uncheck();
    }
    const cb = grp.locator(`#checkbox_vmGroup_${ng}`);
    if (!(await cb.isChecked())) await card.click();
    await expect(cb).toBeChecked();
    expect(await grp.locator('.vmgroup-checkbox:checked').evaluateAll((els) => els.map((e) => e.id)), `체크된 nodegroup 은 ${ng} 하나`).toEqual([`checkbox_vmGroup_${ng}`]);
    await grp.locator('#scaleGroupToggle').click();
    // 패널: #scaleGroupFormList > li [–] [input readonly(기본 1)] [+] [Apply] (Nodes to add)  → 값은 –/+ 버튼으로만 조정
    const panel = page.locator('#scaleGroupFormList li').first();
    await expect(panel).toBeVisible();
    const addInput = panel.locator('input');
    for (let i = 0; i < 20 && Number(await addInput.inputValue() || 0) > add; i++) await panel.getByRole('button', { name: '–' }).click();
    for (let i = 0; i < 20 && Number(await addInput.inputValue() || 0) < add; i++) await panel.getByRole('button', { name: '+' }).click();
    await expect(addInput).toHaveValue(String(add));
    await page.waitForTimeout(1000); // 녹화용
    const reqId = await withAsyncRequest(page, async () => {
      await panel.getByRole('button', { name: 'Apply' }).click();
      await closeAnyConfirm(page);
    });
    if (reqId) await waitAsyncRequest(page, reqId, 20 * 60_000);
    else test.info().annotations.push({ type: 'no-async-request', description: '비동기 요청 ID 미확인 → node 수로만 판정' });

    // 3. 목록 Total/Running 이 add 만큼 증가할 때까지 대기
    const wantTotal = c0.total + add;
    const wantRunning = c0.running + add;
    const end = Date.now() + 15 * 60_000;
    let n = { total: NaN, running: NaN, cells: '' } as { total: number; running: number; cells: string };
    while (Date.now() < end) {
      await refreshInfraList(page);
      if (await waitInfraListed(page, name)) {
        n = await infraCounts(page, name);
        if (n.total >= wantTotal && n.running >= wantRunning) break;
      }
      await page.waitForTimeout(15_000);
    }
    test.info().annotations.push({ type: 'list-after', description: n.cells });
    expect(n.total, `Total Nodes ${wantTotal}`).toBe(wantTotal);
    expect(n.running, `Running ${wantRunning}`).toBe(wantRunning);

    // 4. 상세: nodegroup 카드 ng(target), 신규 node Running
    await openInfraDetail(page, name);
    test.info().annotations.push({ type: 'infra-info-after', description: await infraInfoStatus(page) });
    const nodesAfter = await nodeNames(page);
    const added = nodesAfter.filter((x) => x.startsWith(`${ng}-`) && !ngBefore.includes(x));
    test.info().annotations.push({ type: 'nodes-after', description: `${nodesAfter.join(', ')} / 추가: ${added.join(', ') || '(없음)'}` });
    expect(added.length, `${ng} 에 신규 node ${add}개`).toBe(add);
    for (const a of added) expect((await readNodeInfo(page, ng, a)).status, `${a} Running`).toMatch(/^Running/i);
    await page.getByRole('tab', { name: 'Group' }).click();
    await expect(grp.locator(`#serverGroup_status_icon_${ng}`)).toContainText(`${ng}(${target})`);
    await page.waitForTimeout(3000); // 녹화 마무리
  });
}

/** Apply 뒤 확인 모달이 뜨면 Confirm (없으면 통과). 네이티브 confirm 은 fixtures 가 수락 */
async function closeAnyConfirm(page: import('@playwright/test').Page) {
  const btn = page.locator('#commonDefaultModal-confirm-btn');
  if (await btn.isVisible({ timeout: 3000 }).catch(() => false)) {
    test.info().annotations.push({ type: 'confirm-modal', description: (await page.locator('#commonDefaultModal').innerText()).replace(/\s+/g, ' ').trim() });
    await btn.click();
  }
}

// IV4_S08: Scale Policy 등록 → 확인 [정상, CSP별] — TC-INFRA-032
// 화면: Infra Workloads > Infra 선택 > 상세 Policy 탭(Scale Policy List · Add Policy → Create Policy 폼 · ⌄ Delete) / Group 탭(Check Scale Policy)
// 시작 상태: admin(mcmp) 로그인 상태, Workspace=ws01 / Project=default 선택된 상태에서 시작. 대상 CSP node 가 Running 인 Infra
// 대상 Infra(2026-10-16 사용자 지시: 다른 세션이 만든 mc1~mc9 는 쓰지 않음, lib/iv3-mc10.ts pickNodeTarget):
//   1) IV3_S01 Workflow 결과 mw{n}(해당 CSP node Running) 2) 이 세션 IV3_S11 결과 mc10(g10-<csp>-1 Running)
//   3) Running 이 없으면 Suspended 인 mw{n} → mc{n} 을 화면에서 Resume 후 테스트하고 끝나면(실패해도) 다시 Suspend(사용자 지시 2026-10-16, lib withResumed)
//   4) 없으면 SKIP(사전 조건 없음)
//   Drive 입력값 Infra=mc1 / NG=g1 은 다른 세션 Infra 라 위 대상으로 대체(결과 문서 비고)
// 절차 (예: AWS 기준): 1.Infra 목록에서 대상 Infra 선택 → Policy 탭(기존 Policy 없음 확인)
//   2.'Add Policy' → Create Policy: Policy name=sp{n}, Metric=CPU Usage, Operator='>', Operand=99, Node Name=sp{n},
//     Spec/Image = 검색 팝업(Node/Image Recommendation)으로 CSP 별 Add Infra 와 같은 값(lib/infra.ts INFRA_INPUT), NodeGroup Size=1 → Deploy
//   3.Scale Policy List(Infra Name, Infra ID, NodeGroup Size, Condition, Period(s), Action, Status)에 대상 Infra 행 표시 확인
//   4.Group 탭 → NodeGroup 선택 → 'Check Scale Policy' → Policy 탭으로 이동해 같은 정책 표시 확인
//   5.정책 행 선택 → ⌄ Delete → Confirm → 목록에서 제거 확인
// 입력값: 조건 cpu > 99(실제 Scale Out 이 일어나지 않게 — 과금 방지), 주기 기본값(10초, 폼에 입력란 없음), 동작 ScaleOut(고정)
// 기대결과: 정책이 목록에 등록·표시되고 Check Scale Policy 로 확인, 삭제 시 목록에서 제거
// 비고: 2026-10-16 구현(stub 대체). 화면에 NodeGroup 지정란이 없음 — Scale Policy 는 Infra 단위(Tumblebug Infra Policy), Node Name 은 Scale Out 때 만들 NodeGroup 이름

import { test, expect } from '../../lib/fixtures';
import type { Page } from '@playwright/test';
import { activeCsps, tid } from '../../lib/data';
import { loginAsAdmin } from '../../lib/ui';
import { INFRA_INPUT } from '../../lib/infra';
import { gotoInfraList, openInfraDetail } from '../../lib/iv4-infra';
import { pickNodeTarget, withResumed } from '../../lib/iv3-mc10';

// mc10 은 CSP 가 같은 Infra 를 공유(Infra 당 Policy 1개) → 순차 실행 전제(playwright.config workers: 1). 각 CSP 테스트가 끝에 Policy 를 지운다

const note = (type: string, d: string) => test.info().annotations.push({ type, description: d.slice(0, 1500) });
const clean = (s: string) => s.replace(/\s+/g, ' ').trim();

async function policyRows(page: Page, infra: string) {
  const rows = page.locator('#policy-table .tabulator-row').filter({ has: page.locator('[tabulator-field="mciId"]', { hasText: new RegExp(`^\\s*${infra}\\s*$`) }) });
  const out: Record<string, string>[] = [];
  for (let i = 0; i < (await rows.count()); i++) {
    out.push(await rows.nth(i).locator('[tabulator-field]').evaluateAll((els) => Object.fromEntries(els.map((e) => [e.getAttribute('tabulator-field') ?? '', (e.textContent ?? '').trim()]))));
  }
  return { rows, out };
}

async function showPolicyTab(page: Page) {
  await page.locator('a[href="#tabs-mci-policy"]:visible').first().click();
  await page.locator('#policy-table').waitFor({ timeout: 20_000 });
  await page.waitForTimeout(3000); // GetAllInfraPolicy 응답
}

for (const c of activeCsps(["AWS","Azure","Alibaba","GCP","Tencent","NHN Cloud","NCP","IBM","KT"])) { // 엑셀에 있는 CSP: AWS, Azure, Alibaba, GCP, Tencent, NHN Cloud, NCP, IBM, KT
  test(`${tid("IV4_S08", c)} ` + "Scale Policy 등록 → 확인", async ({ page, dialogs }) => {
    test.setTimeout(20 * 60_000);
    const inp = INFRA_INPUT[c.code];
    test.skip(!inp, `${c.name}: Spec/Image 검색 입력값 미확정`);
    await loginAsAdmin(page);
    await gotoInfraList(page);
    const { target, seen } = await pickNodeTarget(page, c.n, c.code);
    note('target-candidates', seen);
    test.skip(!target, `사전 조건 없음: ${c.name} node 가 Running 인 대상 Infra(mw${c.n} 또는 mc10) 없음 — ${seen}`);
    const t = target!;
    note('target', `${t.infra} / ${t.ng} / ${t.node} (${t.why})`);
    const name = `sp${c.n}`;
    // Suspended 대상이면 Resume → 테스트 → 다시 Suspend(사용자 지시 2026-10-16)
    await withResumed(page, t, async () => {
    // 1. 대상 Infra → Policy 탭
    await openInfraDetail(page, t.infra);
    await showPolicyTab(page);
    const before = await policyRows(page, t.infra);
    note('policy-before', JSON.stringify(before.out));
    test.skip(before.out.length > 0, `${t.infra} 에 기존 Policy 있음(다른 실행 잔여 가능) → 손대지 않음: ${JSON.stringify(before.out)}`);

    // 2. Add Policy → Create Policy
    await page.locator('#tabs-mci-policy a[href="#addpolicy"]').first().click();
    const form = page.locator('#addpolicy');
    await expect(form.locator('#policy_name')).toBeVisible({ timeout: 15_000 });
    await form.locator('#policy_name').fill(name);
    await form.locator('#policy_desc').fill(`IV4_S08 ${c.code} e2e`);
    await form.locator('#policy_ep_metric').selectOption('cpu');
    await form.locator('#policy_ep_operator').selectOption('>');
    await form.locator('#policy_ep_operand').fill('99');
    await form.locator('#policy_ep_name').fill(name);
    // Spec: Node Recommendation(#spec-search) — Add Infra 와 같은 팝업, Apply 시 policy_ep_* 에 채워짐(2026-10-16 탐색)
    await form.locator('#policy_ep_specId').locator('xpath=following::a[1]').click();
    const sm = page.locator('#spec-search');
    await expect(sm).toBeVisible();
    if (inp!.priority) await sm.locator('#assistRecommendSpecConnectionName').selectOption(inp!.priority);
    await sm.locator(`#spec-provider-${inp!.provider}`).check();
    await sm.locator('#assist_min_memory').fill(String(Math.floor(inp!.mem)));
    await sm.locator('#assist_max_memory').fill(String(Math.ceil(inp!.mem)));
    await sm.locator('#assist_min_cpu').fill(String(Math.floor(inp!.cpu)));
    await sm.locator('#assist_max_cpu').fill(String(Math.ceil(inp!.cpu)));
    await sm.locator('a[onclick*="getRecommendVmInfo"]').click();
    const specRow = sm.locator('.tabulator-row')
      .filter({ has: page.locator('[tabulator-field="connectionName"]', { hasText: `${inp!.provider}-${inp!.region}` }) })
      .filter({ hasText: inp!.spec }).first();
    await expect(specRow, `Spec 추천 결과에 ${inp!.spec}(${inp!.region})`).toBeVisible({ timeout: 60_000 });
    await specRow.click();
    await sm.getByRole('button', { name: 'Apply' }).click();
    await expect(form.locator('#policy_ep_specId')).toHaveValue(inp!.spec);
    // Image: Image Recommendation(#image-search)
    await form.locator('a[onclick*="validateAndOpenImageModal"]').first().click();
    const im = page.locator('#image-search');
    await expect(im).toBeVisible();
    await im.locator('#assist_os_type').fill(inp!.os);
    await im.locator('a[onclick*="getRecommendImageInfo"]').click();
    await im.locator('.tabulator-row').first().waitFor({ timeout: 60_000 });
    const wanted = inp!.image ? im.locator('.tabulator-row').filter({ hasText: inp!.image }) : im.locator('.tabulator-row').filter({ hasNot: page.locator('[tabulator-field="isGPUImage"]', { hasText: '✓' }) });
    const imgRow = (await wanted.count()) ? wanted.first() : im.locator('.tabulator-row').first();
    note('image-row', clean(await imgRow.innerText()).slice(0, 200));
    await imgRow.click();
    const cb = imgRow.locator('input[type="checkbox"]').first();
    if ((await cb.count()) && !(await cb.isChecked())) await cb.check();
    await im.getByRole('button', { name: 'Apply' }).click();
    await expect(form.locator('#policy_ep_imageId_input')).not.toHaveValue('', { timeout: 10_000 });
    const vals = await form.locator('input:not([type=hidden]), select, input[type=hidden]').evaluateAll((els) => els.filter((e) => e.id).map((e) => `${e.id}=${(e as HTMLInputElement).value}`));
    note('policy-form', vals.join(', '));
    await page.waitForTimeout(1500); // 녹화용

    // Deploy → CreateInfraPolicy 응답 기록
    const api: string[] = [];
    const onResp = async (r: import('@playwright/test').Response) => { if (/Policy/i.test(r.url())) api.push(`${r.status()} ${r.url().split('/api/')[1]} ${(await r.text().catch(() => '')).replace(/\s+/g, ' ').slice(0, 300)}`); };
    page.on('response', onResp);
    await form.locator('button[onclick*="deployPolicy"]').click();
    await expect.poll(() => dialogs.join(' | '), { timeout: 60_000, message: 'Policy 생성 결과 알림' }).toMatch(/Policy creation|Error|required|Failed/i);
    await page.waitForTimeout(4000);
    note('deploy', `알림: ${dialogs.join(' | ')} / API: ${api.join(' || ')}`);
    expect(dialogs.join(' '), 'Policy creation completed.').toMatch(/Policy creation completed/i);

    // 3. Scale Policy List
    await showPolicyTab(page);
    let after = await policyRows(page, t.infra);
    for (let i = 0; i < 3 && !after.out.length; i++) { await openInfraDetail(page, t.infra); await showPolicyTab(page); after = await policyRows(page, t.infra); }
    note('policy-list', JSON.stringify(after.out));
    expect(after.out.length, `Scale Policy List 에 ${t.infra} 행`).toBeGreaterThan(0);
    const row = after.out[0];
    expect(row.mciName || row.mciId, 'Infra Name/ID').toContain(t.infra);
    expect(row.condition ?? '', 'Condition(cpu > 99)').toMatch(/cpu.*>.*99/i);
    expect(row.actionType ?? '', 'Action ScaleOut').toMatch(/ScaleOut/i);

    // 4. Group 탭 → NodeGroup 선택 → Check Scale Policy
    await page.locator('a[href="#tabs-mci-group"]:visible').first().click();
    await page.waitForTimeout(2000);
    const ngcb = page.locator(`#checkbox_vmGroup_${t.ng}`);
    if (await ngcb.count()) { if (!(await ngcb.isChecked())) await page.locator(`#serverGroup_status_icon_${t.ng}`).click(); }
    note('group-tab', clean(await page.locator('#tabs-mci-group .card-header').first().innerText()).slice(0, 200) + ` / NodeGroup ${t.ng} 선택=${await ngcb.isChecked().catch(() => false)}`);
    await page.waitForTimeout(1500);
    await page.locator('#checkScalePolicy').click();
    await expect(page.locator('#tabs-mci-policy')).toBeVisible({ timeout: 10_000 });
    await page.waitForTimeout(3000);
    const viaCheck = await policyRows(page, t.infra);
    note('check-scale-policy', `Policy 탭으로 이동, ${t.infra} 행 ${viaCheck.out.length}개: ${JSON.stringify(viaCheck.out)}`);
    expect(viaCheck.out.length, 'Check Scale Policy 결과에 정책 표시').toBeGreaterThan(0);
    // 행 클릭 → 상세(policy_info)
    await viaCheck.rows.first().locator('[tabulator-field="mciId"]').click();
    await page.waitForTimeout(2000);
    const info = page.locator('#policy_info');
    if (await info.isVisible().catch(() => false)) note('policy-detail', clean(await info.innerText()).slice(0, 600));

    // 5. 삭제: 행 선택 → ⌄ Delete → Confirm
    await showPolicyTab(page);
    const del = await policyRows(page, t.infra);
    const sel = del.rows.first().locator('.tabulator-cell').first();
    await sel.click();
    await page.waitForTimeout(800);
    const n0 = dialogs.length;
    await page.locator('#tabs-mci-policy .dropdown').filter({ hasText: 'Delete' }).locator('[data-bs-toggle="dropdown"]').first().click();
    await page.locator('#tabs-mci-policy .dropdown-menu.show .dropdown-item', { hasText: 'Delete' }).first().click();
    const modal = page.locator('#commonDefaultModal');
    await expect(modal).toBeVisible();
    note('delete-modal', clean(await modal.innerText()).slice(0, 200));
    await modal.locator('#commonDefaultModal-confirm-btn').click();
    await expect.poll(() => dialogs.slice(n0).join(' | '), { timeout: 60_000, message: 'Policy 삭제 결과 알림' }).toMatch(/deletion|delete|select/i);
    note('delete', `알림: ${dialogs.slice(n0).join(' | ')}`);
    expect(dialogs.slice(n0).join(' '), 'Policy deletion completed.').toMatch(/Policy deletion completed/i);
    await openInfraDetail(page, t.infra);
    await showPolicyTab(page);
    const gone = await policyRows(page, t.infra);
    note('policy-after-delete', JSON.stringify(gone.out));
    expect(gone.out.length, '삭제 후 목록에서 제거').toBe(0);
    page.off('response', onResp);
    });
  });
}