geo/apps/admin-web/src/lib/publish-account-cards.ts

import type { DesktopAccountInfo, MediaPlatform } from "@geo/shared-types";

import { resolveApiURL } from "@/lib/api";
import { resolveAccountCheckedAt, resolveAccountHealth } from "@/lib/desktop-account-runtime";
import {
  getPublishPlatformMeta,
  isMediaPublishAccount,
  isPublishPlatformId,
  normalizePublishPlatformId,
} from "@/lib/publish-platforms";

export type PublishState = "immediate" | "queued" | "unavailable";

export interface PublishAccountCard {
  id: string;
  platformId: string;
  platformName: string;
  platformShortName: string;
  platformAccent: string;
  platformLogoUrl: string | null;
  displayName: string;
  platformUid: string;
  avatarUrl: string | null;
  health: DesktopAccountInfo["health"];
  verifiedAt: string | null;
  clientId: string | null;
  clientOnline: boolean | null;
  clientDeviceName: string | null;
  clientLastSeenAt: string | null;
  publishState: PublishState;
  selectable: boolean;
  statusText: string;
}

const platformLogoCatalog: Record<string, string> = {
  toutiaohao: "/logos/logo_toutiao.png",
  baijiahao: "/logos/logo_baijiahao.png",
  sohuhao: "/logos/logo_souhu.png",
  qiehao: "/logos/logo_qiehao.png",
  zhihu: "/logos/logo_zhihu.png",
  wangyihao: "/logos/logo_wangyihao.png",
  jianshu: "/logos/logo_jianshu.svg",
  bilibili: "/logos/logo_bilibili.png",
  juejin: "/logos/logo_juejin.png",
  smzdm: "/logos/logo_smzdm.svg",
  weixin_gzh: "/logos/logo_weixin_gzh.svg",
  zol: "/logos/logo_zol.png",
  dongchedi: "/logos/logo_dongchedi.svg",
};

export function buildPublishPlatformMap(platforms: MediaPlatform[]): Map<string, MediaPlatform> {
  return new Map(
    platforms.map((platform) => [
      normalizePublishPlatformId(platform.platform_id),
      platform,
    ]),
  );
}

export function buildPublishAccountCards(
  accounts: DesktopAccountInfo[],
  platformMap: Map<string, MediaPlatform>,
  preferredPlatformIds: string[] = [],
): PublishAccountCard[] {
  const preferredPlatforms = new Set(preferredPlatformIds.map(normalizePublishPlatformId));

  return accounts
    .filter((account) => {
      if (!isMediaPublishAccount(account)) {
        return false;
      }
      const platformId = normalizePublishPlatformId(account.platform);
      return platformMap.has(platformId) || isPublishPlatformId(platformId);
    })
    .map((account) => buildPublishAccountCard(account, platformMap))
    .sort((left, right) => {
      const preferredGap =
        Number(preferredPlatforms.has(right.platformId)) - Number(preferredPlatforms.has(left.platformId));
      if (preferredGap !== 0) {
        return preferredGap;
      }

      const publishGap = publishRank(left.publishState) - publishRank(right.publishState);
      if (publishGap !== 0) {
        return publishGap;
      }

      const leftVerifiedAt = Date.parse(left.verifiedAt ?? "") || 0;
      const rightVerifiedAt = Date.parse(right.verifiedAt ?? "") || 0;
      return rightVerifiedAt - leftVerifiedAt;
    });
}

export function buildPublishAccountCard(
  account: DesktopAccountInfo,
  platformMap: Map<string, MediaPlatform>,
): PublishAccountCard {
  const platformId = normalizePublishPlatformId(account.platform);
  const platform = platformMap.get(platformId);
  const fallback = getPublishPlatformMeta(platformId);
  const publishState = resolvePublishState(account);
  const health = resolveAccountHealth(account);

  return {
    id: account.id,
    platformId,
    platformName: platform?.name || fallback.name,
    platformShortName: platform?.short_name || fallback.shortName,
    platformAccent: platform?.accent_color || fallback.accent,
    platformLogoUrl: resolvePlatformLogoUrl(platformId, platform?.logo_url),
    displayName: account.display_name,
    platformUid: normalizePlatformUid(account.platform_uid),
    avatarUrl: resolveApiURL(account.avatar_url),
    health,
    verifiedAt: resolveAccountCheckedAt(account),
    clientId: account.client_id,
    clientOnline: account.client_online,
    clientDeviceName: account.client_device_name,
    clientLastSeenAt: account.client_last_seen_at,
    publishState,
    selectable: publishState !== "unavailable",
    statusText: resolvePublishStatusText(account, publishState),
  };
}

export function resolvePublishState(account: DesktopAccountInfo): PublishState {
  if (resolveAccountHealth(account) !== "live") {
    return "unavailable";
  }
  if (!account.client_id) {
    return "unavailable";
  }
  return account.client_online === true ? "immediate" : "queued";
}

export function publishRank(state: PublishState): number {
  switch (state) {
    case "immediate":
      return 0;
    case "queued":
      return 1;
    default:
      return 2;
  }
}

export function publishStateLabel(state: PublishState): string {
  switch (state) {
    case "immediate":
      return "立即发布";
    case "queued":
      return "离线排队";
    default:
      return "不可发布";
  }
}

export function publishStatusShortLabel(state: PublishState): string {
  switch (state) {
    case "immediate":
      return "客户端在线";
    case "queued":
      return "离线可排队";
    default:
      return "不可发布";
  }
}

export function healthLabel(health: DesktopAccountInfo["health"]): string {
  switch (health) {
    case "live":
      return "授权正常";
    case "captcha":
      return "待处理";
    case "risk":
      return "风险观察";
    default:
      return "授权异常";
  }
}

export function healthColor(health: DesktopAccountInfo["health"]): string {
  switch (health) {
    case "live":
      return "green";
    case "captcha":
      return "orange";
    case "risk":
      return "gold";
    default:
      return "red";
  }
}

export function clientStatusLabel(card: PublishAccountCard): string {
  if (!card.clientId) {
    return "未绑定客户端";
  }
  return card.clientOnline ? "客户端在线" : "客户端离线";
}

export function clientStatusColor(card: PublishAccountCard): string {
  if (!card.clientId) {
    return "default";
  }
  return card.clientOnline ? "green" : "gold";
}

export function accountInitial(card: Pick<PublishAccountCard, "displayName" | "platformShortName">): string {
  const trimmed = card.displayName.trim();
  return trimmed ? trimmed.slice(0, 1).toUpperCase() : card.platformShortName;
}

export function resolvePlatformLogoUrl(platformId: string, remoteLogoUrl?: string | null): string | null {
  const localLogoUrl = platformLogoCatalog[platformId];
  if (localLogoUrl) {
    return localLogoUrl;
  }
  const resolvedRemoteLogoUrl = resolveApiURL(remoteLogoUrl);
  return resolvedRemoteLogoUrl || null;
}

function resolvePublishStatusText(account: DesktopAccountInfo, publishState: PublishState): string {
  if (publishState === "immediate") {
    return "客户端在线，RabbitMQ 会立即唤醒桌面端开始发布。";
  }
  if (publishState === "queued") {
    return "客户端当前离线，任务会先落库排队，等桌面端上线后自动继续发布。";
  }
  if (resolveAccountHealth(account) !== "live") {
    return "该账号授权状态异常，请先在桌面端重新校验或重新授权。";
  }
  return "该账号还没有绑定桌面客户端，当前不能进入发布队列。";
}

function normalizePlatformUid(value?: string | null): string {
  let normalized = String(value ?? "").trim();
  while (normalized.toLowerCase().startsWith("platform:")) {
    normalized = normalized.slice("platform:".length).trim();
  }
  return normalized || "--";
}