import { mkdirSync } from 'node:fs';
import { execFileSync } from 'node:child_process';
import { dirname } from 'node:path';
import { chromium } from 'playwright';
import { desktopBrowserContextOptions } from './desktop-browser-viewport.mjs';

const targetUrl = withQaParams(process.env.PUBLIC_QA_URL ?? 'https://comtropy.synology.me/heros_web/');
const screenshotPath = process.env.PUBLIC_QA_SCREENSHOT ?? 'dist/public-deploy-qa.png';
const expectedQaVersion = process.env.PUBLIC_QA_VERSION;
const expectedCommit = process.env.PUBLIC_QA_COMMIT ?? currentGitCommit();
const expectedTitle = '\uC0BC\uAD6D\uC9C0: \uC138 \uD615\uC81C\uC758 \uB9F9\uC138';
const relevantLogPattern = /asset|audio|cannot|failed|map|missing|portrait|sprite|story|texture|unit/i;

mkdirSync(dirname(screenshotPath), { recursive: true });

const browser = await chromium.launch({ headless: true });

try {
  const page = await browser.newPage(desktopBrowserContextOptions);
  const consoleMessages = [];
  const pageErrors = [];
  const requestFailures = [];
  page.on('console', (message) => {
    consoleMessages.push({ type: message.type(), text: message.text() });
  });
  page.on('pageerror', (error) => {
    pageErrors.push(error.message);
  });
  page.on('requestfailed', (request) => {
    requestFailures.push({
      url: request.url(),
      type: request.resourceType(),
      failure: request.failure()?.errorText ?? 'unknown'
    });
  });

  await page.goto(targetUrl, { waitUntil: 'domcontentloaded', timeout: 90000 });
  await page.waitForFunction(() => document.querySelector('canvas') !== null, undefined, { timeout: 90000 });
  await page.waitForFunction(() => {
    const canvas = document.querySelector('canvas');
    return Boolean(canvas && canvas.width === 1920 && canvas.height === 1080);
  }, undefined, { timeout: 90000 });
  await page.waitForTimeout(3000);
  await page.screenshot({ path: screenshotPath, fullPage: true });

  const state = await page.evaluate(() => {
    const canvas = document.querySelector('canvas');
    return {
      title: document.title,
      canvasCount: document.querySelectorAll('canvas').length,
      debugApiPresent: Boolean(window.__HEROS_DEBUG__),
      gameApiPresent: Boolean(window.__HEROS_GAME__),
      canvas: canvas
        ? {
            width: canvas.width,
            height: canvas.height,
            clientWidth: canvas.clientWidth,
            clientHeight: canvas.clientHeight,
            pixelProbe: sampleCanvasPixels(canvas)
          }
        : undefined
    };

    function sampleCanvasPixels(canvas) {
      const context = canvas.getContext('2d', { willReadFrequently: true });
      if (!context) {
        return { readable: false, sampleCount: 0, nonTransparentRatio: 0, distinctColorBuckets: 0 };
      }

      const stepX = Math.max(1, Math.floor(canvas.width / 64));
      const stepY = Math.max(1, Math.floor(canvas.height / 64));
      const colorBuckets = new Set();
      let sampleCount = 0;
      let nonTransparentCount = 0;

      for (let y = Math.floor(stepY / 2); y < canvas.height; y += stepY) {
        for (let x = Math.floor(stepX / 2); x < canvas.width; x += stepX) {
          const [r, g, b, a] = context.getImageData(x, y, 1, 1).data;
          sampleCount += 1;
          if (a > 8) {
            nonTransparentCount += 1;
          }
          colorBuckets.add(`${r >> 4},${g >> 4},${b >> 4},${a >> 5}`);
        }
      }

      return {
        readable: true,
        sampleCount,
        nonTransparentRatio: sampleCount > 0 ? nonTransparentCount / sampleCount : 0,
        distinctColorBuckets: colorBuckets.size
      };
    }
  });

  assert(state.title === expectedTitle, `Expected deployed page title "${expectedTitle}": ${JSON.stringify(state)}`);
  assert(state.canvasCount === 1, `Expected exactly one game canvas: ${JSON.stringify(state)}`);
  assert(state.debugApiPresent === false, `Expected public deploy to keep debug API disabled: ${JSON.stringify(state)}`);
  assert(state.gameApiPresent === false, `Expected public deploy to keep game handle disabled: ${JSON.stringify(state)}`);
  assert(state.canvas?.width === 1920 && state.canvas?.height === 1080, `Expected FHD game canvas: ${JSON.stringify(state)}`);
  assert(state.canvas?.pixelProbe?.readable === true, `Expected readable canvas pixels: ${JSON.stringify(state)}`);
  assert(state.canvas.pixelProbe.sampleCount >= 500, `Expected enough canvas pixel samples: ${JSON.stringify(state)}`);
  assert(state.canvas.pixelProbe.nonTransparentRatio > 0.5, `Expected non-empty canvas pixels: ${JSON.stringify(state)}`);
  assert(state.canvas.pixelProbe.distinctColorBuckets >= 12, `Expected visually varied canvas pixels: ${JSON.stringify(state)}`);

  const releaseManifest = await readReleaseManifest(targetUrl);
  assert(releaseManifest.app === 'heros_web', `Expected deployed release manifest app id: ${JSON.stringify(releaseManifest)}`);
  assert(typeof releaseManifest.commit === 'string' && releaseManifest.commit.length >= 7, `Expected deployed release manifest commit: ${JSON.stringify(releaseManifest)}`);
  assert(typeof releaseManifest.generatedAt === 'string' && releaseManifest.generatedAt.length > 0, `Expected deployed release manifest timestamp: ${JSON.stringify(releaseManifest)}`);
  if (expectedQaVersion) {
    assert(
      releaseManifest.qaVersion === expectedQaVersion,
      `Expected deployed release manifest qaVersion ${expectedQaVersion}: ${JSON.stringify(releaseManifest)}`
    );
  }
  if (expectedCommit) {
    assert(
      releaseManifest.commit === expectedCommit,
      `Expected deployed release manifest commit ${expectedCommit}: ${JSON.stringify(releaseManifest)}`
    );
  }
  if (releaseManifest.qaReport) {
    const qaReport = await readJsonAsset(targetUrl, releaseManifest.qaReport);
    assert(qaReport.app === 'heros_web', `Expected deployed QA report app id: ${JSON.stringify(qaReport)}`);
    assert(Array.isArray(qaReport.results) && qaReport.results.length > 0, `Expected deployed QA report results: ${JSON.stringify(qaReport)}`);
    assert(typeof qaReport.generatedAt === 'string' && qaReport.generatedAt.length > 0, `Expected deployed QA report timestamp: ${JSON.stringify(qaReport)}`);
    console.log(`Verified QA report ${releaseManifest.qaReport} with ${qaReport.results.length} battles`);
  }
  let deployedQaRepeatReport;
  if (releaseManifest.qaRepeatReport) {
    const qaRepeatReport = await readJsonAsset(targetUrl, releaseManifest.qaRepeatReport);
    deployedQaRepeatReport = qaRepeatReport;
    assert(qaRepeatReport.app === 'heros_web', `Expected deployed QA repeat report app id: ${JSON.stringify(qaRepeatReport)}`);
    assert(Array.isArray(qaRepeatReport.runs) && qaRepeatReport.runs.length > 0, `Expected deployed QA repeat report runs: ${JSON.stringify(qaRepeatReport)}`);
    assert(
      typeof qaRepeatReport.summary?.runs === 'number' && qaRepeatReport.summary.runs === qaRepeatReport.runs.length,
      `Expected deployed QA repeat report run summary: ${JSON.stringify(qaRepeatReport)}`
    );
    for (const run of qaRepeatReport.runs) {
      const runReportAsset = distAssetPath(run.path);
      assert(runReportAsset, `Expected repeat QA run ${run.run} to include a report path: ${JSON.stringify(run)}`);
      const runReport = await readJsonAsset(targetUrl, runReportAsset);
      assert(runReport.app === 'heros_web', `Expected deployed QA repeat run report app id at ${runReportAsset}: ${JSON.stringify(runReport)}`);
      assert(Array.isArray(runReport.results) && runReport.results.length > 0, `Expected deployed QA repeat run results at ${runReportAsset}: ${JSON.stringify(runReport)}`);
      assert(
        typeof runReport.summary?.victories === 'number' && typeof runReport.summary?.failures === 'number',
        `Expected deployed QA repeat run summary at ${runReportAsset}: ${JSON.stringify(runReport)}`
      );
    }
    console.log(`Verified QA repeat report ${releaseManifest.qaRepeatReport} with ${qaRepeatReport.runs.length} runs`);
  }
  if (releaseManifest.releaseDashboard) {
    const dashboard = await readTextAsset(targetUrl, releaseManifest.releaseDashboard);
    const dashboardText = visibleText(dashboard);
    assert(dashboard.includes('Heros Web Release QA'), `Expected deployed release dashboard title: ${dashboard.slice(0, 200)}`);
    assert(dashboard.includes(releaseManifest.shortCommit ?? releaseManifest.commit), `Expected deployed release dashboard commit: ${dashboard.slice(0, 400)}`);
    assert(dashboard.includes('Repeated Battle Outcomes'), `Expected deployed release dashboard battle outcomes section: ${dashboard.slice(0, 800)}`);
    assert(dashboard.includes('Process Failures'), `Expected deployed release dashboard process failure metric: ${dashboard.slice(0, 800)}`);
    assert(dashboard.includes('Objective Misses'), `Expected deployed release dashboard objective miss metric: ${dashboard.slice(0, 800)}`);
    assert(dashboard.includes('Repeated Objective Misses'), `Expected deployed release dashboard objective miss section: ${dashboard.slice(0, 1200)}`);
    assert(dashboard.includes('Repeat Runs'), `Expected deployed release dashboard repeat runs section: ${dashboard.slice(0, 800)}`);
    if (typeof deployedQaRepeatReport?.summary?.totalMissedObjectives === 'number') {
      assert(
        dashboardText.includes(`Objective Misses ${deployedQaRepeatReport.summary.totalMissedObjectives}`),
        `Expected deployed release dashboard objective miss total ${deployedQaRepeatReport.summary.totalMissedObjectives}: ${dashboard.slice(0, 1200)}`
      );
    }
    for (const miss of deployedQaRepeatReport?.missedObjectives ?? []) {
      const latest = miss.examples?.at(-1);
      assert(
        dashboardText.includes(`${miss.battleNo}`) && dashboardText.includes(miss.objectiveId),
        `Expected deployed release dashboard missed objective ${miss.battleNo}/${miss.objectiveId}: ${dashboard.slice(0, 1600)}`
      );
      if (latest?.failureReason || miss.failureReason) {
        const reason = latest?.failureReason ?? miss.failureReason;
        assert(
          dashboardText.includes(reason),
          `Expected deployed release dashboard missed objective reason "${reason}": ${dashboard.slice(0, 1600)}`
        );
      }
    }
    if (deployedQaRepeatReport && (deployedQaRepeatReport.missedObjectives ?? []).length === 0) {
      assert(
        dashboard.includes('No missed objectives recorded.'),
        `Expected deployed release dashboard empty objective miss state: ${dashboard.slice(0, 1600)}`
      );
    }
    for (const run of deployedQaRepeatReport?.runs ?? []) {
      const runReportAsset = distAssetPath(run.path);
      assert(dashboard.includes(runReportAsset), `Expected deployed release dashboard to link repeat run report ${runReportAsset}: ${dashboard.slice(0, 1200)}`);
    }
    console.log(`Verified release dashboard ${releaseManifest.releaseDashboard}`);
  }

  const relevantLogs = consoleMessages.filter(
    (message) => message.type === 'error' || (isWarning(message.type) && relevantLogPattern.test(message.text))
  );
  const blockingRequestFailures = requestFailures.filter((request) => request.failure !== 'net::ERR_ABORTED');
  assert(relevantLogs.length === 0, `Unexpected public deploy console issues: ${JSON.stringify(relevantLogs, null, 2)}`);
  assert(pageErrors.length === 0, `Unexpected public deploy page errors: ${JSON.stringify(pageErrors, null, 2)}`);
  assert(blockingRequestFailures.length === 0, `Unexpected public deploy request failures: ${JSON.stringify(blockingRequestFailures, null, 2)}`);

  console.log(`Verified public deploy at ${targetUrl}`);
  console.log(`Verified release manifest ${releaseManifest.shortCommit ?? releaseManifest.commit} (${releaseManifest.qaVersion ?? 'no qaVersion'})`);
  console.log(`Captured ${screenshotPath}`);
} finally {
  await browser.close();
}

function withQaParams(url) {
  const parsed = new URL(url);
  parsed.searchParams.set('renderer', 'canvas');
  parsed.searchParams.set('v', process.env.PUBLIC_QA_VERSION ?? String(Date.now()));
  return parsed.toString();
}

function isWarning(type) {
  return type === 'warning' || type === 'warn';
}

async function readReleaseManifest(pageUrl) {
  return readJsonAsset(pageUrl, 'release-manifest.json');
}

async function readJsonAsset(pageUrl, assetPath) {
  const assetUrl = new URL(assetPath, pageUrl);
  assetUrl.searchParams.set('v', expectedQaVersion ?? String(Date.now()));
  const response = await fetch(assetUrl, { signal: AbortSignal.timeout(90000) });
  assert(response.ok, `Expected deployed JSON asset at ${assetUrl.href}: ${response.status} ${response.statusText}`);
  return response.json();
}

async function readTextAsset(pageUrl, assetPath) {
  const assetUrl = new URL(assetPath, pageUrl);
  assetUrl.searchParams.set('v', expectedQaVersion ?? String(Date.now()));
  const response = await fetch(assetUrl, { signal: AbortSignal.timeout(90000) });
  assert(response.ok, `Expected deployed text asset at ${assetUrl.href}: ${response.status} ${response.statusText}`);
  return response.text();
}

function distAssetPath(filePath) {
  if (!filePath) {
    return '';
  }
  return String(filePath).replaceAll('\\', '/').replace(/^dist\//, '').replace(/^\/+/, '');
}

function visibleText(html) {
  return String(html).replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim();
}

function currentGitCommit() {
  try {
    return execFileSync('git', ['rev-parse', 'HEAD'], {
      encoding: 'utf8',
      stdio: ['ignore', 'pipe', 'ignore']
    }).trim();
  } catch {
    return undefined;
  }
}

function assert(condition, message) {
  if (!condition) {
    throw new Error(message);
  }
}