import type { JsonValue } from '@geo/shared-types'
import type { Page } from 'playwright-core'

import {
  WANGYIHAO_DRAFT_SAVE_PARAMETER_MESSAGE,
  WANGYIHAO_PUBLISH_CLICK_MESSAGE,
  WANGYIHAO_TOKEN_MISSING_MESSAGE,
} from '../../shared/publisher-errors'
import type { PublishAdapter, PublishAdapterContext } from './base'
import {
  extractImageSources,
  sessionCookieHeader,
  sessionFetchJson,
  uploadHtmlImages,
} from './common'
import { fetchImageAssetBlob } from './media-image'
import { prepareWangyihaoArticleHtml } from './wangyihao-content'
import { wangyihaoPublicArticleUrl } from './wangyihao-links'

type WangyiInfoResponse = {
  data?: {
    mediaInfo?: {
      userId?: string | number
      wemediaId?: string | number
      tname?: string
      icon?: string
    }
  }
}

type WangyiUploadResponse = {
  code?: number
  message?: string
  data?: {
    url?: string
  }
}

type WangyiDraftResponse = {
  code?: number | string
  message?: string
  msg?: string
  errMsg?: string
  errorMsg?: string
  data?: string
}

type WangyiPublishDetailResponse = {
  code?: number | string
  data?: {
    wemediaId?: string | number
    onlineState?: string | number
    hasRecommRight?: boolean | number
    allowedRepost?: boolean | number
    newProminentFlag?: string | number
  }
}

type WangyiAccount = {
  realUserId: string
  wemediaId: string
  name: string
}

type WangyiPublishDetail = {
  wemediaId: string
  onlineState: string
  hasRecommRight: boolean
  allowedRepost: boolean
  newProminentFlag: string
}

const WANGYI_API_ORIGIN = 'https://mp.163.com'
const WANGYI_CONSOLE_ORIGIN = 'http://mp.163.com'
const WANGYI_API_REFERER = `${WANGYI_API_ORIGIN}/subscribe_v4/index.html`
const WANGYI_HOME_URL = `${WANGYI_CONSOLE_ORIGIN}/subscribe_v4/index.html`
const WANGYI_MANAGE_URL = `${WANGYI_CONSOLE_ORIGIN}/subscribe_v4/index.html#/article-manage`
const WANGYI_CREATIVE_STATEMENT = '个人原创，仅供参考'
const WANGYI_PUBLISH_DELAY_MS = 2_000
const WANGYI_TOKEN_WAIT_MS = 12_000
const WANGYI_GUARDIAN_APP_ID = 'YD00250021379271'
const WANGYI_GUARDIAN_SCRIPT_URL =
  'https://static.ws.126.net/163/mp/main/static/YiDunProtector-Web-2.0.7.js'
const WANGYI_TOKEN_ATTR = 'data-geo-wangyihao-token'
const WANGYI_TOKEN_STATUS_ATTR = 'data-geo-wangyihao-token-status'
const WANGYI_TOKEN_ERROR_ATTR = 'data-geo-wangyihao-token-error'
const WANGYI_RESPONSE_CODE_MESSAGES: Record<string, string> = {
  '100001': '参数为空',
  '100002': '参数错误',
  '100003': '数据不存在',
  '100004': '参数超出范围',
  '100005': '数据已存在',
  '100006': '请选择上传文件',
}

function stringId(value: unknown): string {
  if (typeof value === 'number') {
    return Number.isFinite(value) ? String(value) : ''
  }
  if (typeof value !== 'string') {
    return ''
  }
  return value.trim()
}

function parseFormString(value: string): Record<string, string> {
  return Object.fromEntries(new URLSearchParams(value))
}

function wangyiResponseMessage(
  response:
    | {
        message?: string
        msg?: string
        errMsg?: string
        errorMsg?: string
        code?: number | string
        data?: unknown
      }
    | null
    | undefined,
): string {
  return (
    response?.message ||
    response?.msg ||
    response?.errMsg ||
    response?.errorMsg ||
    (typeof response?.data === 'string' && !response.data.includes('=') ? response.data : '') ||
    WANGYI_RESPONSE_CODE_MESSAGES[String(response?.code ?? '')] ||
    `wangyihao_error_${response?.code ?? 'unknown'}`
  )
}

function isWangyiChallengeMessage(message: string): boolean {
  return /(验证码|滑块|人机验证|安全验证|请完成验证|短信验证|扫码验证|captcha|challenge|verification required|风险|风控)/i.test(
    message,
  )
}

function sleep(ms: number, signal?: AbortSignal): Promise<void> {
  if (signal?.aborted) {
    return Promise.reject(new Error('adapter_aborted'))
  }
  return new Promise((resolve, reject) => {
    const cleanup = () => signal?.removeEventListener('abort', onAbort)
    const timeout = setTimeout(() => {
      cleanup()
      resolve()
    }, ms)
    const onAbort = () => {
      clearTimeout(timeout)
      cleanup()
      reject(new Error('adapter_aborted'))
    }
    signal?.addEventListener('abort', onAbort, { once: true })
  })
}

async function wangyiHeaders(
  context: PublishAdapterContext,
  extra: Record<string, string> = {},
): Promise<Record<string, string>> {
  const cookie =
    (await sessionCookieHeader(context.session, 'mp.163.com').catch(() => '')) ||
    (await sessionCookieHeader(context.session, '163.com').catch(() => ''))
  return {
    accept: 'application/json, text/plain, */*',
    origin: WANGYI_API_ORIGIN,
    referer: WANGYI_API_REFERER,
    ...(cookie ? { cookie } : {}),
    ...extra,
  }
}

async function fetchAccount(context: PublishAdapterContext): Promise<WangyiAccount | null> {
  const response = await sessionFetchJson<WangyiInfoResponse>(
    context.session,
    `${WANGYI_API_ORIGIN}/wemedia/info.do`,
    {
      credentials: 'include',
      headers: await wangyiHeaders(context),
    },
  ).catch(() => null)

  const media = response?.data?.mediaInfo
  const realUserId = stringId(media?.userId)
  const wemediaId = stringId(media?.wemediaId)
  const name = media?.tname?.trim() || ''
  return realUserId && wemediaId && name ? { realUserId, wemediaId, name } : null
}

async function fetchPublishDetail(
  context: PublishAdapterContext,
  account: WangyiAccount,
): Promise<WangyiPublishDetail> {
  const fallback: WangyiPublishDetail = {
    wemediaId: account.wemediaId,
    onlineState: '',
    hasRecommRight: false,
    allowedRepost: false,
    newProminentFlag: '',
  }

  const url = new URL(`${WANGYI_API_ORIGIN}/wemedia/article/postpage.do`)
  url.searchParams.set('_', String(Date.now()))
  url.searchParams.set('wemediaId', account.wemediaId)
  url.searchParams.set('mediaId', account.wemediaId)

  const response = await sessionFetchJson<WangyiPublishDetailResponse>(
    context.session,
    url.toString(),
    {
      credentials: 'include',
      headers: await wangyiHeaders(context),
    },
  ).catch(() => null)

  if (String(response?.code) !== '1' || !response?.data) {
    return fallback
  }

  return {
    wemediaId: stringId(response.data.wemediaId) || account.wemediaId,
    onlineState: stringId(response.data.onlineState),
    hasRecommRight: response.data.hasRecommRight === true || response.data.hasRecommRight === 1,
    allowedRepost: response.data.allowedRepost === true || response.data.allowedRepost === 1,
    newProminentFlag: stringId(response.data.newProminentFlag),
  }
}

async function getPublishToken(context: PublishAdapterContext): Promise<string> {
  const page = context.playwright?.page
  if (!page) {
    throw new Error('wangyihao_playwright_missing')
  }

  for (let attempt = 0; attempt < 2; attempt += 1) {
    await page
      .goto(WANGYI_HOME_URL, {
        waitUntil: attempt === 0 ? 'domcontentloaded' : 'load',
        timeout: 20_000,
      })
      .catch(() => null)
    await page.waitForLoadState('networkidle', { timeout: 3_000 }).catch(() => null)
    if (attempt > 0) {
      await sleep(800, context.signal)
    }

    // 网易号的 neg 有时是顶层绑定，不一定挂在 window 上；这里保持和旧版插件一致的读取方式。
    const token = (await readPublishTokenFromPage(page)).trim()
    if (token) {
      return token
    }
  }

  return ''
}

async function readPublishTokenFromPage(page: Page): Promise<string> {
  await page
    .evaluate(
      (attrs) => {
        document.documentElement.removeAttribute(attrs.token)
        document.documentElement.removeAttribute(attrs.status)
        document.documentElement.removeAttribute(attrs.error)
      },
      {
        token: WANGYI_TOKEN_ATTR,
        status: WANGYI_TOKEN_STATUS_ATTR,
        error: WANGYI_TOKEN_ERROR_ATTR,
      },
    )
    .catch(() => null)

  await page
    .addScriptTag({
      content: `
      (() => {
        const tokenAttr = ${JSON.stringify(WANGYI_TOKEN_ATTR)};
        const statusAttr = ${JSON.stringify(WANGYI_TOKEN_STATUS_ATTR)};
        const errorAttr = ${JSON.stringify(WANGYI_TOKEN_ERROR_ATTR)};
        const guardianScriptUrl = ${JSON.stringify(WANGYI_GUARDIAN_SCRIPT_URL)};
        const guardianAppId = ${JSON.stringify(WANGYI_GUARDIAN_APP_ID)};
        const timeoutMs = ${WANGYI_TOKEN_WAIT_MS};
        const retryMs = 250;
        const scriptLoadTimeoutMs = 6_000;

        const root = document.documentElement;
        const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
        const setStatus = (status, error = "") => {
          root.setAttribute(statusAttr, status);
          if (error) {
            root.setAttribute(errorAttr, String(error).slice(0, 240));
          }
        };
        const readTopLevelNeg = () => {
          try {
            return typeof neg !== "undefined" ? neg : null;
          } catch (_error) {
            return null;
          }
        };
        const readGuardianFactory = () => {
          try {
            return typeof createNEGuardian === "function" ? createNEGuardian : null;
          } catch (_error) {
            return null;
          }
        };
        const readGuardian = () => {
          const topLevelNeg = readTopLevelNeg();
          if (topLevelNeg && typeof topLevelNeg.getToken === "function") {
            return topLevelNeg;
          }
          if (window.neg && typeof window.neg.getToken === "function") {
            return window.neg;
          }
          if (window.__geoWangyihaoNeg && typeof window.__geoWangyihaoNeg.getToken === "function") {
            return window.__geoWangyihaoNeg;
          }
          const createGuardian = readGuardianFactory();
          if (createGuardian) {
            window.__geoWangyihaoNeg = createGuardian({ appId: guardianAppId, timeout: 6_000 });
            return window.__geoWangyihaoNeg;
          }
          return null;
        };
        const loadGuardianScript = () => new Promise((resolve) => {
          if (readGuardianFactory()) {
            resolve(true);
            return;
          }
          const script = document.createElement("script");
          let done = false;
          const finish = (loaded) => {
            if (done) {
              return;
            }
            done = true;
            resolve(loaded);
          };
          script.src = guardianScriptUrl;
          script.async = false;
          script.onload = () => finish(true);
          script.onerror = () => finish(false);
          setTimeout(() => finish(false), scriptLoadTimeoutMs);
          document.head.appendChild(script);
        });
        const requestToken = async (client) => {
          const result = await Promise.resolve(client.getToken());
          return typeof result?.token === "string" ? result.token.trim() : "";
        };

        window.__geoWangyihaoTokenPromise = (async () => {
          const deadline = Date.now() + timeoutMs;
          setStatus("waiting");

          if (document.readyState === "loading") {
            await new Promise((resolve) => {
              document.addEventListener("DOMContentLoaded", resolve, { once: true });
            });
          }

          if (!readGuardian()) {
            setStatus("loading_guardian");
            await loadGuardianScript();
          }

          while (Date.now() <= deadline) {
            const client = readGuardian();
            if (!client) {
              setStatus("missing_client");
              await sleep(retryMs);
              continue;
            }

            try {
              setStatus("requesting");
              const token = await requestToken(client);
              if (token) {
                root.setAttribute(tokenAttr, token);
                setStatus("ready");
                return token;
              }
              setStatus("empty_token");
            } catch (error) {
              setStatus("retrying", error && error.message ? error.message : error);
            }

            await sleep(retryMs);
          }

          setStatus("missing");
          return "";
        })().catch((error) => {
          setStatus("failed", error && error.message ? error.message : error);
          return "";
        });
      })();
    `,
    })
    .catch(() => null)

  await page
    .waitForFunction(
      ({ token, status }) => {
        const root = document.documentElement
        const statusValue = root.getAttribute(status)
        return (
          Boolean(root.getAttribute(token)) || statusValue === 'missing' || statusValue === 'failed'
        )
      },
      {
        token: WANGYI_TOKEN_ATTR,
        status: WANGYI_TOKEN_STATUS_ATTR,
      },
      { timeout: WANGYI_TOKEN_WAIT_MS + 2_000 },
    )
    .catch(() => null)

  const token = await page
    .evaluate((attr) => document.documentElement.getAttribute(attr) ?? '', WANGYI_TOKEN_ATTR)
    .catch(() => '')

  await page
    .evaluate(
      (attrs) => {
        document.documentElement.removeAttribute(attrs.token)
        document.documentElement.removeAttribute(attrs.status)
        document.documentElement.removeAttribute(attrs.error)
      },
      {
        token: WANGYI_TOKEN_ATTR,
        status: WANGYI_TOKEN_STATUS_ATTR,
        error: WANGYI_TOKEN_ERROR_ATTR,
      },
    )
    .catch(() => null)

  return token
}

async function uploadImage(
  context: PublishAdapterContext,
  account: WangyiAccount,
  sourceUrl: string,
): Promise<string | null> {
  const image = await fetchImageAssetBlob(sourceUrl)
  if (!image) {
    return null
  }

  const form = new FormData()
  form.append('file', image.blob, image.fileName)
  form.append('from', 'neteasecode_mp')
  form.append('logotext', account.name)

  const url = new URL(`${WANGYI_API_ORIGIN}/api/v3/upload/picupload`)
  url.searchParams.set('_', String(Date.now()))
  url.searchParams.set('wemediaId', account.wemediaId)
  url.searchParams.set('realUserId', account.realUserId)

  const response = await sessionFetchJson<WangyiUploadResponse>(context.session, url.toString(), {
    method: 'POST',
    credentials: 'include',
    headers: await wangyiHeaders(context, {
      'x-b3-sampled': '1',
      'x-b3-spanid': '0',
    }),
    body: form,
  }).catch(() => null)

  return response?.data?.url?.trim() || null
}

async function saveDraft(
  context: PublishAdapterContext,
  account: WangyiAccount,
  detail: WangyiPublishDetail,
  html: string,
  token: string,
): Promise<string> {
  const url = new URL(`${WANGYI_API_ORIGIN}/wemedia/article/status/api/publishV2.do`)
  url.searchParams.set('_', String(Date.now()))

  const body = buildDraftBody(context, account, detail, html, token)
  const response =
    (await saveDraftWithPage(context, url.toString(), body).catch(() => null)) ??
    (await saveDraftWithSession(context, url.toString(), body))

  if (String(response.code) !== '1' || !response.data) {
    const message = wangyiResponseMessage(response)
    if (isWangyiChallengeMessage(message)) {
      throw new Error(`wangyihao_challenge_required:${message}`)
    }
    throw new Error(`wangyihao_draft_save_failed:${message}`)
  }

  const draftId = parseFormString(response.data).docId ?? ''
  if (!draftId.trim()) {
    throw new Error('wangyihao_draft_id_missing')
  }
  return draftId.trim()
}

function buildDraftBody(
  context: PublishAdapterContext,
  account: WangyiAccount,
  detail: WangyiPublishDetail,
  html: string,
  token: string,
): URLSearchParams {
  const body = new URLSearchParams()
  body.set('wemediaId', detail.wemediaId || account.wemediaId)
  body.set('articleId', '-1')
  body.set('title', context.article.title?.trim() || '未命名文章')
  body.set('content', html)
  body.set('cover', 'auto')
  body.set('operation', 'saveDraft')
  body.set('scheduled', '0')
  body.set('ursToken', token)
  body.set('picUrl', '')
  body.set('original', '0')
  body.set('creativeStatement', WANGYI_CREATIVE_STATEMENT)

  if (detail.onlineState) {
    body.set('onlineState', detail.onlineState)
  }
  if (detail.hasRecommRight) {
    body.set('recommendState', '0')
  }
  if (detail.allowedRepost) {
    body.set('allowedRepost', '1')
  }
  if (detail.newProminentFlag === '1') {
    body.set('newProminentState', '0')
  }

  return body
}

async function saveDraftWithSession(
  context: PublishAdapterContext,
  url: string,
  body: URLSearchParams,
): Promise<WangyiDraftResponse> {
  return await sessionFetchJson<WangyiDraftResponse>(context.session, url, {
    method: 'POST',
    credentials: 'include',
    headers: await wangyiHeaders(context, {
      'content-type': 'application/x-www-form-urlencoded',
      'x-b3-sampled': '1',
      'x-b3-spanid': '0',
    }),
    body,
  }).catch(
    (error): WangyiDraftResponse => ({
      code: -1,
      message: error instanceof Error ? error.message : 'wangyihao_draft_save_failed',
    }),
  )
}

async function saveDraftWithPage(
  context: PublishAdapterContext,
  url: string,
  body: URLSearchParams,
): Promise<WangyiDraftResponse | null> {
  const page = context.playwright?.page
  if (!page) {
    return null
  }

  const serialized = await page.evaluate(
    async ({ requestUrl, requestBody }) => {
      const response = await fetch(requestUrl, {
        method: 'POST',
        credentials: 'include',
        headers: {
          'content-type': 'application/x-www-form-urlencoded',
          'x-b3-sampled': '1',
          'x-b3-spanid': '0',
        },
        body: requestBody,
      })
      return await response.text()
    },
    {
      requestUrl: url,
      requestBody: body.toString(),
    },
  )

  if (!serialized) {
    return null
  }
  return JSON.parse(serialized) as WangyiDraftResponse
}

type WangyiPublishNetworkResult = {
  success: boolean
  code: string
  message: string
}

function compactText(value: string): string {
  return value.trim().replace(/\s+/g, '')
}

function isPublishRequestBody(postData: string): boolean {
  if (!postData) {
    return false
  }
  const decoded = (() => {
    try {
      return decodeURIComponent(postData)
    } catch {
      return postData
    }
  })()
  return /(?:^|&)operation=publish(?:&|$)/.test(decoded)
}

async function clickFirstVisibleAction(
  page: Page,
  texts: string[],
  timeoutMs = 10_000,
): Promise<boolean> {
  const selectors = [
    '.ant-modal button',
    '.ant-popover button',
    'button',
    "[role='button']",
    '.ant-btn',
    'a',
  ]
  const targets = texts.map(compactText)
  const startedAt = Date.now()

  while (Date.now() - startedAt < timeoutMs) {
    for (const selector of selectors) {
      const locator = page.locator(selector)
      const count = await locator.count().catch(() => 0)
      for (let index = 0; index < count; index += 1) {
        const candidate = locator.nth(index)
        const text = await candidate
          .innerText({ timeout: 300 })
          .catch(async () => await candidate.textContent({ timeout: 300 }).catch(() => ''))
        if (!targets.includes(compactText(text || ''))) {
          continue
        }
        const visible = await candidate.isVisible().catch(() => false)
        const enabled = await candidate.isEnabled().catch(() => false)
        if (!visible || !enabled) {
          continue
        }
        await candidate.scrollIntoViewIfNeeded({ timeout: 1_000 }).catch(() => undefined)
        await candidate.click({ timeout: 5_000 })
        return true
      }
    }

    const clicked = await page
      .evaluate((targetTexts) => {
        const compact = (value: string) => value.trim().replace(/\s+/g, '')
        const isVisible = (element: Element) => {
          const rect = element.getBoundingClientRect()
          if (rect.width <= 0 || rect.height <= 0) {
            return false
          }
          const style = window.getComputedStyle(element)
          return style.display !== 'none' && style.visibility !== 'hidden' && style.opacity !== '0'
        }
        const isDisabled = (element: Element) => {
          const htmlElement = element as HTMLElement & { disabled?: boolean }
          return (
            Boolean(htmlElement.disabled) ||
            element.getAttribute('aria-disabled') === 'true' ||
            /\b(disabled|is-disabled|ant-btn-disabled)\b/i.test(element.className?.toString() || '')
          )
        }

        const candidates = Array.from(
          document.querySelectorAll<HTMLElement>(
            ".ant-modal button, .ant-popover button, button, [role='button'], .ant-btn, a",
          ),
        )
        for (const candidate of candidates) {
          if (!targetTexts.includes(compact(candidate.innerText || candidate.textContent || ''))) {
            continue
          }
          const clickable =
            candidate.closest<HTMLElement>("button, [role='button'], a, .ant-btn") ?? candidate
          if (!isVisible(clickable) || isDisabled(clickable)) {
            continue
          }
          clickable.scrollIntoView({ block: 'center', inline: 'center' })
          clickable.click()
          return true
        }
        return false
      }, targets)
      .catch(() => false)

    if (clicked) {
      return true
    }

    await page.waitForTimeout(150).catch(() => undefined)
  }

  return false
}

async function waitForWangyiEditorReady(page: Page): Promise<void> {
  await page
    .waitForFunction(
      () => {
        if (document.readyState === 'loading') {
          return false
        }
        const actions = Array.from(
          document.querySelectorAll("button, [role='button'], .ant-btn, a"),
        )
        return actions.some(
          (element) => (element.textContent || '').trim().replace(/\s+/g, '') === '发布',
        )
      },
      undefined,
      { timeout: 20_000 },
    )
    .catch(() => undefined)
}

async function waitForPublishNetworkResponse(
  page: Page,
  timeoutMs: number,
): Promise<WangyiPublishNetworkResult | null> {
  const response = await page
    .waitForResponse(
      (candidate) => {
        if (!candidate.url().includes('/wemedia/article/status/api/publishV2.do')) {
          return false
        }
        if (candidate.request().method().toUpperCase() !== 'POST') {
          return false
        }
        return isPublishRequestBody(candidate.request().postData() || '')
      },
      { timeout: timeoutMs },
    )
    .catch(() => null)

  if (!response) {
    return null
  }

  const text = await response.text().catch(() => '')
  let parsed: WangyiDraftResponse | null = null
  try {
    parsed = text ? (JSON.parse(text) as WangyiDraftResponse) : null
  } catch {
    parsed = {
      code: response.status(),
      message: text || `http_${response.status()}`,
    }
  }

  return {
    success: String(parsed?.code) === '1',
    code: String(parsed?.code ?? response.status()),
    message: wangyiResponseMessage(parsed),
  }
}

async function readWangyiPageMessage(page: Page): Promise<string> {
  return await page
    .evaluate(() => {
      const text = document.body?.innerText || ''
      return text
        .split('\n')
        .map((line) => line.trim())
        .filter((line) => /(发布|发表|提交|审核|成功|失败|错误|验证|登录|确认)/.test(line))
        .slice(-8)
        .join(' / ')
        .slice(0, 300)
    })
    .catch(() => '')
}

async function waitForPublishCompletion(
  page: Page,
  oldUrl: string,
  responsePromise: Promise<WangyiPublishNetworkResult | null>,
  timeoutMs: number,
): Promise<boolean> {
  const result = await Promise.race([
    responsePromise.then((response) => (response ? { kind: 'network' as const, response } : null)),
    page
      .waitForURL((url) => url.toString() !== oldUrl, { timeout: timeoutMs })
      .then(() => ({ kind: 'navigation' as const }))
      .catch(() => null),
    page
      .waitForFunction(
        () =>
          /(发布成功|发表成功|提交成功|已提交审核|已进入审核|审核中)/.test(
            document.body?.innerText || '',
          ),
        undefined,
        { timeout: timeoutMs },
      )
      .then(() => ({ kind: 'page' as const }))
      .catch(() => null),
    page.waitForTimeout(timeoutMs).then(() => null),
  ])

  if (!result) {
    return false
  }

  if (result.kind === 'network') {
    if (result.response.success) {
      return true
    }
    throw new Error(`wangyihao_publish_failed:${result.response.message || result.response.code}`)
  }

  return true
}

async function publishDraft(context: PublishAdapterContext, draftId: string): Promise<boolean> {
  const page = context.playwright?.page
  if (!page) {
    throw new Error('wangyihao_playwright_missing')
  }

  const draftUrl = `${WANGYI_CONSOLE_ORIGIN}/subscribe_v4/index.html#/article-publish/${encodeURIComponent(draftId)}?option=editDraft`
  await page.goto(draftUrl, {
    waitUntil: 'domcontentloaded',
  })
  await page.waitForLoadState('networkidle', { timeout: 8_000 }).catch(() => null)
  await waitForWangyiEditorReady(page)

  const oldUrl = page.url()
  const publishResponsePromise = waitForPublishNetworkResponse(page, 22_000)
  const firstClicked = await clickFirstVisibleAction(page, ['发布'], 12_000)
  if (!firstClicked) {
    const message = await readWangyiPageMessage(page)
    throw new Error(`wangyihao_publish_click_failed${message ? `:${message}` : ''}`)
  }
  await sleep(WANGYI_PUBLISH_DELAY_MS, context.signal)

  if (await waitForPublishCompletion(page, oldUrl, publishResponsePromise, 2_500)) {
    return true
  }

  const confirmed = await clickFirstVisibleAction(
    page,
    ['确认发布', '确定发布', '确认', '确定'],
    8_000,
  )
  if (!confirmed) {
    return await waitForPublishCompletion(page, oldUrl, publishResponsePromise, 4_000)
  }

  return (
    (await waitForPublishCompletion(page, oldUrl, publishResponsePromise, 10_000)) ||
    page.url() !== oldUrl
  )
}

function buildResultPayload(articleId: string, mediaName: string): Record<string, JsonValue> {
  return {
    platform: 'wangyihao',
    media_name: mediaName,
    external_article_id: articleId,
    external_manage_url: WANGYI_MANAGE_URL,
    external_article_url: wangyihaoPublicArticleUrl(articleId),
    publish_type: 'publish',
  }
}

function failureResult(
  error: unknown,
): ReturnType<PublishAdapter['publish']> extends Promise<infer T> ? T : never {
  const message = error instanceof Error ? error.message : String(error)

  if (message === 'wangyihao_not_logged_in') {
    return {
      status: 'failed',
      summary: '网易号登录态失效，无法执行发布。',
      error: {
        code: 'wangyihao_not_logged_in',
        message,
      },
    }
  }

  if (message === 'article_content_empty') {
    return {
      status: 'failed',
      summary: '文章内容为空，无法推送到网易号。',
      error: {
        code: 'article_content_empty',
        message,
      },
    }
  }

  if (message === 'wangyihao_token_missing') {
    return {
      status: 'failed',
      summary: WANGYIHAO_TOKEN_MISSING_MESSAGE,
      error: {
        code: 'wangyihao_token_missing',
        message: WANGYIHAO_TOKEN_MISSING_MESSAGE,
      },
    }
  }

  if (message.startsWith('wangyihao_challenge_required') || isWangyiChallengeMessage(message)) {
    return {
      status: 'failed',
      summary: '网易号触发平台验证，请在网易号后台完成验证后重试。',
      error: {
        code: 'wangyihao_challenge_required',
        message,
      },
    }
  }

  if (
    message.startsWith('wangyihao_draft_save_failed') ||
    message === 'wangyihao_draft_id_missing'
  ) {
    const isParameterError = /(?:wangyihao_error_)?100002|参数错误/.test(message)
    return {
      status: 'failed',
      summary: isParameterError
        ? WANGYIHAO_DRAFT_SAVE_PARAMETER_MESSAGE
        : '网易号草稿保存失败，请稍后重试或打开网易号后台确认内容状态。',
      error: {
        code: 'wangyihao_draft_save_failed',
        message: isParameterError ? WANGYIHAO_DRAFT_SAVE_PARAMETER_MESSAGE : message,
      },
    }
  }

  if (message.startsWith('wangyihao_publish_click_failed')) {
    return {
      status: 'failed',
      summary: WANGYIHAO_PUBLISH_CLICK_MESSAGE,
      error: {
        code: 'wangyihao_publish_click_failed',
        message: WANGYIHAO_PUBLISH_CLICK_MESSAGE,
      },
    }
  }

  return {
    status: 'failed',
    summary: '网易号发布失败。',
    error: {
      code: 'wangyihao_publish_failed',
      message,
    },
  }
}

export const wangyihaoAdapter: PublishAdapter = {
  platform: 'wangyihao',
  executionMode: 'playwright',
  async publish(context) {
    try {
      context.reportProgress('wangyihao.detect_login')
      const account = await fetchAccount(context)
      if (!account) {
        throw new Error('wangyihao_not_logged_in')
      }
      const detail = await fetchPublishDetail(context, account)

      context.reportProgress('wangyihao.normalize_html')
      let html = prepareWangyihaoArticleHtml(context.article)
      if (!html) {
        throw new Error('article_content_empty')
      }

      const coverAssetUrl = context.article.cover_asset_url?.trim() || ''
      if (coverAssetUrl && extractImageSources(html).length === 0) {
        html = `<img src="${coverAssetUrl}" />${html}`
      }

      context.reportProgress('wangyihao.get_token')
      const token = await getPublishToken(context)
      if (!token) {
        throw new Error('wangyihao_token_missing')
      }

      context.reportProgress('wangyihao.upload_content_images')
      const processed = await uploadHtmlImages(html, async (sourceUrl) =>
        uploadImage(context, account, sourceUrl),
      )

      context.reportProgress('wangyihao.save_draft')
      const draftId = await saveDraft(context, account, detail, processed.html, token)

      context.reportProgress('wangyihao.publish_draft')
      const published = await publishDraft(context, draftId)
      if (!published) {
        throw new Error('wangyihao_publish_click_failed')
      }

      return {
        status: 'succeeded',
        summary: '网易号发布成功，已记录公开链接。',
        payload: buildResultPayload(draftId, account.name),
      }
    } catch (error) {
      return failureResult(error)
    }
  },
}