import { Buffer } from 'node:buffer';
import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
import path from 'node:path';
import { fileURLToPath } from 'node:url';

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);
const skillRoot = path.resolve(__dirname, '..');
const repoRoot = path.resolve(skillRoot, '..', '..', '..');
const promptsPath = path.join(
  skillRoot,
  'assets',
  'puzzle-template-prompts.json',
);
const defaultOutDir = path.join(repoRoot, 'public', 'puzzle-creation-templates');
const defaultTimeoutMs = 180000;
const pollDelayMs = 3000;

const args = new Map();
for (let index = 2; index < process.argv.length; index += 1) {
  const raw = process.argv[index];
  if (raw.startsWith('--')) {
    const next = process.argv[index + 1];
    if (next && !next.startsWith('--')) {
      args.set(raw, next);
      index += 1;
    } else {
      args.set(raw, true);
    }
  }
}

function readDotenv(fileName) {
  const filePath = path.join(repoRoot, fileName);
  if (!existsSync(filePath)) {
    return {};
  }

  const values = {};
  for (const line of readFileSync(filePath, 'utf8').split(/\r?\n/u)) {
    const trimmed = line.trim();
    if (!trimmed || trimmed.startsWith('#')) {
      continue;
    }
    const match = /^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/u.exec(trimmed);
    if (!match) {
      continue;
    }
    let value = match[2].trim();
    if (
      (value.startsWith('"') && value.endsWith('"')) ||
      (value.startsWith("'") && value.endsWith("'"))
    ) {
      value = value.slice(1, -1);
    }
    values[match[1]] = value;
  }
  return values;
}

function resolveEnv() {
  const loaded = {
    ...readDotenv('.env.example'),
    ...readDotenv('.env.local'),
    ...readDotenv('.env.secrets.local'),
    ...process.env,
  };
  return {
    baseUrl: String(loaded.APIMART_BASE_URL || '').trim().replace(/\/+$/u, ''),
    apiKey: String(loaded.APIMART_API_KEY || '').trim(),
    timeoutMs: Number.parseInt(
      String(loaded.APIMART_IMAGE_REQUEST_TIMEOUT_MS || defaultTimeoutMs),
      10,
    ),
  };
}

function buildPrompt(template) {
  return [
    '请生成一张高清 1:1 方形插画，用作拼图创作模板样例图。',
    `画面主体：${template.prompt}`,
    '要求：主体清晰集中，前中后景层次明确，边角有可辨识细节，适合切成 3x3 到 7x7 拼图。',
    '避免：文字、水印、边框、按钮、UI 元素、教程标注、低清晰度、过度模糊、杂乱构图。',
  ].join('');
}

function collectStringsByKey(value, targetKey, output) {
  if (Array.isArray(value)) {
    value.forEach((entry) => collectStringsByKey(entry, targetKey, output));
    return;
  }
  if (!value || typeof value !== 'object') {
    return;
  }

  for (const [key, nested] of Object.entries(value)) {
    if (key === targetKey) {
      if (typeof nested === 'string' && nested.trim()) {
        output.push(nested.trim());
      }
      if (Array.isArray(nested)) {
        nested.forEach((entry) => {
          if (typeof entry === 'string' && entry.trim()) {
            output.push(entry.trim());
          }
        });
      }
    }
    collectStringsByKey(nested, targetKey, output);
  }
}

function extractImageUrls(payload) {
  const urls = [];
  collectStringsByKey(payload, 'url', urls);
  collectStringsByKey(payload, 'image', urls);
  collectStringsByKey(payload, 'image_url', urls);
  return [...new Set(urls)].filter((url) => /^https?:\/\//u.test(url));
}

function extractBase64Images(payload) {
  const values = [];
  collectStringsByKey(payload, 'b64_json', values);
  return values;
}

function extractTaskId(payload) {
  const ids = [];
  collectStringsByKey(payload, 'task_id', ids);
  collectStringsByKey(payload, 'taskId', ids);
  collectStringsByKey(payload, 'id', ids);
  return ids[0] || null;
}

function inferExtensionFromContentType(contentType) {
  const normalized = contentType.split(';')[0]?.trim().toLowerCase();
  if (normalized === 'image/png') {
    return 'png';
  }
  if (normalized === 'image/webp') {
    return 'webp';
  }
  if (normalized === 'image/gif') {
    return 'gif';
  }
  return 'jpg';
}

function inferExtensionFromBytes(bytes) {
  if (bytes.subarray(0, 8).equals(Buffer.from('\x89PNG\r\n\x1A\n', 'binary'))) {
    return 'png';
  }
  if (bytes.subarray(0, 3).equals(Buffer.from([0xff, 0xd8, 0xff]))) {
    return 'jpg';
  }
  if (
    bytes.subarray(0, 4).toString('ascii') === 'RIFF' &&
    bytes.subarray(8, 12).toString('ascii') === 'WEBP'
  ) {
    return 'webp';
  }
  return 'png';
}

async function fetchJson(url, options, timeoutMs) {
  const abortController = new AbortController();
  const timer = setTimeout(() => abortController.abort(), timeoutMs);
  try {
    const response = await fetch(url, {
      ...options,
      signal: abortController.signal,
    });
    const text = await response.text();
    if (!response.ok) {
      throw new Error(`APIMart ${response.status}: ${text.slice(0, 600)}`);
    }
    return JSON.parse(text);
  } finally {
    clearTimeout(timer);
  }
}

async function downloadUrl(url, timeoutMs) {
  const abortController = new AbortController();
  const timer = setTimeout(() => abortController.abort(), timeoutMs);
  try {
    const response = await fetch(url, { signal: abortController.signal });
    if (!response.ok) {
      throw new Error(`download ${response.status}`);
    }
    const bytes = Buffer.from(await response.arrayBuffer());
    return {
      bytes,
      extension: inferExtensionFromContentType(
        response.headers.get('content-type') || 'image/jpeg',
      ),
    };
  } finally {
    clearTimeout(timer);
  }
}

async function waitForTask(env, taskId) {
  const deadline = Date.now() + env.timeoutMs;
  await new Promise((resolve) => setTimeout(resolve, 10000));

  while (Date.now() < deadline) {
    const payload = await fetchJson(
      `${env.baseUrl}/tasks/${encodeURIComponent(taskId)}`,
      {
        headers: {
          Authorization: `Bearer ${env.apiKey}`,
        },
      },
      env.timeoutMs,
    );
    const statuses = [];
    collectStringsByKey(payload, 'status', statuses);
    collectStringsByKey(payload, 'task_status', statuses);
    const status = String(statuses[0] || '').trim().toLowerCase();

    if (['completed', 'succeeded', 'success'].includes(status)) {
      return payload;
    }
    if (['failed', 'error', 'canceled', 'cancelled', 'unknown'].includes(status)) {
      throw new Error(`APIMart task ${taskId} failed: ${JSON.stringify(payload).slice(0, 600)}`);
    }

    await new Promise((resolve) => setTimeout(resolve, pollDelayMs));
  }

  throw new Error(`APIMart task ${taskId} timed out`);
}

async function generateOne(env, template, outDir) {
  const requestBody = {
    model: 'gpt-image-2',
    prompt: buildPrompt(template),
    n: 1,
    official_fallback: true,
    size: '1:1',
  };
  const payload = await fetchJson(
    `${env.baseUrl}/images/generations`,
    {
      method: 'POST',
      headers: {
        Authorization: `Bearer ${env.apiKey}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(requestBody),
    },
    env.timeoutMs,
  );

  const resolvedPayload =
    extractImageUrls(payload).length || extractBase64Images(payload).length
      ? payload
      : await waitForTask(env, extractTaskId(payload));
  const urls = extractImageUrls(resolvedPayload);
  const b64Images = extractBase64Images(resolvedPayload);

  let image;
  if (urls[0]) {
    image = await downloadUrl(urls[0], env.timeoutMs);
  } else if (b64Images[0]) {
    const bytes = Buffer.from(b64Images[0], 'base64');
    image = {
      bytes,
      extension: inferExtensionFromBytes(bytes),
    };
  } else {
    throw new Error(`APIMart returned no image for ${template.id}`);
  }

  mkdirSync(outDir, { recursive: true });
  const outputPath = path.join(outDir, `${template.id}.${image.extension}`);
  writeFileSync(outputPath, image.bytes);
  return outputPath;
}

const dryRun = args.has('--dry-run') || !args.has('--live');
const outDir = path.resolve(String(args.get('--out-dir') || defaultOutDir));
const limit = Number.parseInt(String(args.get('--limit') || '0'), 10);
const onlyIds = String(args.get('--only') || '')
  .split(',')
  .map((value) => value.trim())
  .filter(Boolean);
const templates = JSON.parse(readFileSync(promptsPath, 'utf8')).filter(
  (template) => !onlyIds.length || onlyIds.includes(template.id),
);
const selectedTemplates = limit > 0 ? templates.slice(0, limit) : templates;

if (dryRun) {
  console.log(
    JSON.stringify(
      {
        mode: 'dry-run',
        outDir,
        count: selectedTemplates.length,
        requests: selectedTemplates.map((template) => ({
          id: template.id,
          title: template.title,
          body: {
            model: 'gpt-image-2',
            prompt: buildPrompt(template),
            n: 1,
            official_fallback: true,
            size: '1:1',
          },
        })),
      },
      null,
      2,
    ),
  );
  process.exit(0);
}

const env = resolveEnv();
if (!env.baseUrl || !env.apiKey) {
  console.error(
    JSON.stringify({
      ok: false,
      error: 'Missing APIMART_BASE_URL or APIMART_API_KEY',
      hasBaseUrl: Boolean(env.baseUrl),
      hasApiKey: Boolean(env.apiKey),
    }),
  );
  process.exit(1);
}

const generated = [];
for (const template of selectedTemplates) {
  console.log(`Generating ${template.id}...`);
  generated.push(await generateOne(env, template, outDir));
}

console.log(
  JSON.stringify(
    {
      ok: true,
      count: generated.length,
      files: generated,
    },
    null,
    2,
  ),
);