Activity Push

{
  "skill_name": "activity-push",
  "evals": [
    {
      "id": 1,
      "prompt": "读取当前目录 feeds.md 和 ~/.aj-skills/.env，把最近 24 小时公众号文章里的活动提取出来；如果有活动地址，用高德地理编码补全 WGS84 经纬度并生成静态地图 URL；再基于 activity-structured-geo.json 用 PIL 渲染一张活动汇总图；保存 raw.json、activity.json、activity-structured.json、activity-structured-geo.json、activity-summary.png、activity-structured.md、activity-push.txt，并通过企业微信客户群 API 推送到外部群。activity-structured.json 里的活动需要打分，并按价值高低排序。",
      "expected_output": "Skill 应使用 bash + curl + jq 完成抓取与落盘，并用 bundled Python CLI 封装高德地理编码、静态地图 URL 生成、PIL 图片渲染和客户联系/客户群 API 推送；模型仍需按文章语义判断是否为活动，并在 activity-structured.json 中给每条活动打分、按价值降序排序，最终产出 8 个以上输出文件并创建群发任务。",
      "files": []
    },
    {
      "id": 2,
      "prompt": "帮我把公众号 feed 里的活动类文章筛出来，结构化为活动信息；如果有地址，用高德地理编码转成 WGS84，并生成静态地图 URL；再基于 activity-structured-geo.json 用 PIL 渲染一张活动汇总图，最后生成审阅 Markdown 和客户群 API 用的纯文本，但先不要推送。activity-structured.json 里的活动需要打分，并按价值高低排序；主题不明确的活动、招聘会、有奖征集不要保留。",
      "expected_output": "Skill 应至少完成 feed 抓取、语义筛选、结构化提取、活动价值评分与排序、地址地理编码、静态地图 URL 生成、PIL 汇总图渲染、Markdown 生成和纯文本生成，并明确排除主题不明确的活动、招聘会和有奖征集，并保留 bundled Python CLI 推送为可选最后一步。",
      "files": []
    },
    {
      "id": 4,
      "prompt": "读取 feeds.md 提取活动，生成结构化结果和推送文本，但当前没有配置企业微信参数，所以不要执行推送。activity-structured.json 里的活动需要打分，并按价值高低排序。",
      "expected_output": "Skill 应正常完成抓取、提取、活动价值评分与排序、坐标与静态地图 URL 补全、PIL 汇总图渲染和文本生成，并明确跳过第 6 步推送，不把缺失的企业微信参数视为整体失败。",
      "files": []
    },
    {
      "id": 3,
      "prompt": "根据 feeds.md 批量抓文章，如果今天没有活动也要生成空结果文件，并把结果通过企业微信客户群 API 发到外部群。",
      "expected_output": "Skill 应在空结果情况下仍产出空 JSON、空结果图片、Markdown 和纯文本文件，并继续通过 bundled Python CLI 执行客户群群发任务创建。",
      "files": []
    }
  ]
}

#!/usr/bin/env python3
from __future__ import annotations

import argparse
import json
import math
import re
import sys
from pathlib import Path
from typing import Any, Dict, List, Optional
from urllib import parse, request


AMAP_GEOCODE_URL = "https://restapi.amap.com/v3/geocode/geo"
AMAP_STATICMAP_URL = "https://restapi.amap.com/v3/staticmap"
VAGUE_ADDRESS_PATTERNS = (
    "线上",
    "直播间",
    "腾讯会议",
    "会议号",
    "待定",
    "待通知",
    "另行通知",
    "报名后通知",
    "群内通知",
    "详见原文",
    "详见海报",
    "见海报",
    "见文内",
    "以通知为准",
    "地点另行",
    "活动现场",
    "附近",
    "周边",
    "某地",
    "门店",
    "各门店",
    "全国",
    "全市",
    "全省",
)
PRECISE_ADDRESS_RE = re.compile(
    r"(\d|路|街|道|巷|弄|号|栋|幢|座|楼|层|室|单元|大厦|广场|中心|酒店|剧院|体育馆|会展中心|会议中心|大学|学院|校区|图书馆|美术馆|博物馆|科技馆|产业园|写字楼)"
)


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="Geocode activity addresses with AMap and convert GCJ-02 to WGS84.")
    parser.add_argument("--input", required=True, help="Path to activity-structured.json.")
    parser.add_argument("--output", required=True, help="Path to geo-enriched JSON output.")
    parser.add_argument("--amap-key", default="", help="AMap Web Service key.")
    parser.add_argument("--city-hint-field", default="", help="Optional field name to use as city hint.")
    parser.add_argument("--fixture-file", default="", help="Optional fixture JSON for offline tests.")
    return parser.parse_args()


def write_json(path: Path, data: Any) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")


def read_json(path: Path) -> Any:
    return json.loads(path.read_text(encoding="utf-8"))


def is_precise_address(address: str) -> bool:
    normalized = re.sub(r"\s+", "", address)
    if not normalized or len(normalized) < 6:
        return False
    if any(pattern in normalized for pattern in VAGUE_ADDRESS_PATTERNS):
        return False
    return bool(PRECISE_ADDRESS_RE.search(normalized))


def build_static_map_url(
    amap_key: str,
    lng: float,
    lat: float,
    *,
    zoom: int = 15,
    size: str = "750*300",
    scale: int = 2,
) -> str:
    if not amap_key:
        return ""
    query = {
        "key": amap_key,
        "location": f"{lng:.6f},{lat:.6f}",
        "zoom": str(zoom),
        "size": size,
        "scale": str(scale),
    }
    return f"{AMAP_STATICMAP_URL}?{parse.urlencode(query)}"


def out_of_china(lng: float, lat: float) -> bool:
    return not (73.66 < lng < 135.05 and 3.86 < lat < 53.55)


def transform_lat(lng: float, lat: float) -> float:
    ret = -100.0 + 2.0 * lng + 3.0 * lat + 0.2 * lat * lat + 0.1 * lng * lat + 0.2 * math.sqrt(abs(lng))
    ret += (20.0 * math.sin(6.0 * lng * math.pi) + 20.0 * math.sin(2.0 * lng * math.pi)) * 2.0 / 3.0
    ret += (20.0 * math.sin(lat * math.pi) + 40.0 * math.sin(lat / 3.0 * math.pi)) * 2.0 / 3.0
    ret += (160.0 * math.sin(lat / 12.0 * math.pi) + 320 * math.sin(lat * math.pi / 30.0)) * 2.0 / 3.0
    return ret


def transform_lng(lng: float, lat: float) -> float:
    ret = 300.0 + lng + 2.0 * lat + 0.1 * lng * lng + 0.1 * lng * lat + 0.1 * math.sqrt(abs(lng))
    ret += (20.0 * math.sin(6.0 * lng * math.pi) + 20.0 * math.sin(2.0 * lng * math.pi)) * 2.0 / 3.0
    ret += (20.0 * math.sin(lng * math.pi) + 40.0 * math.sin(lng / 3.0 * math.pi)) * 2.0 / 3.0
    ret += (150.0 * math.sin(lng / 12.0 * math.pi) + 300.0 * math.sin(lng / 30.0 * math.pi)) * 2.0 / 3.0
    return ret


def gcj02_to_wgs84(lng: float, lat: float) -> tuple[float, float]:
    if out_of_china(lng, lat):
        return lng, lat
    a = 6378245.0
    ee = 0.00669342162296594323
    dlat = transform_lat(lng - 105.0, lat - 35.0)
    dlng = transform_lng(lng - 105.0, lat - 35.0)
    radlat = lat / 180.0 * math.pi
    magic = math.sin(radlat)
    magic = 1 - ee * magic * magic
    sqrt_magic = math.sqrt(magic)
    dlat = (dlat * 180.0) / ((a * (1 - ee)) / (magic * sqrt_magic) * math.pi)
    dlng = (dlng * 180.0) / (a / sqrt_magic * math.cos(radlat) * math.pi)
    mg_lat = lat + dlat
    mg_lng = lng + dlng
    return lng * 2 - mg_lng, lat * 2 - mg_lat


class AMapClient:
    def __init__(self, amap_key: str, fixture_file: Optional[Path] = None) -> None:
        self.amap_key = amap_key
        self.fixture_file = fixture_file
        self.fixture_map = read_json(fixture_file) if fixture_file else {}

    def geocode(self, address: str, city_hint: str = "") -> Dict[str, Any]:
        if self.fixture_file:
            return self.fixture_map.get(address, {"status": "0", "count": "0", "geocodes": []})
        if not self.amap_key:
            raise RuntimeError("amap key is required unless fixture-file is provided")

        query = {"key": self.amap_key, "address": address, "output": "JSON"}
        if city_hint:
            query["city"] = city_hint
        url = f"{AMAP_GEOCODE_URL}?{parse.urlencode(query)}"
        req = request.Request(url, headers={"Accept": "application/json", "User-Agent": "activity-push/1.0"})
        with request.urlopen(req, timeout=30) as resp:
            return json.loads(resp.read().decode("utf-8"))


def enrich_record(record: Dict[str, Any], client: AMapClient, city_hint_field: str = "") -> Dict[str, Any]:
    item = dict(record)
    address = str(item.get("activityAddress", "")).strip()
    if not address:
        item.update(
            {
                "activityLongitudeGCJ02": "",
                "activityLatitudeGCJ02": "",
                "activityLongitudeWGS84": "",
                "activityLatitudeWGS84": "",
                "activityGeoProvider": "amap",
                "activityGeoStatus": "skipped",
                "activityStaticMapUrl": "",
                "activityStaticMapStatus": "skipped",
            }
        )
        return item
    if not is_precise_address(address):
        item.update(
            {
                "activityLongitudeGCJ02": "",
                "activityLatitudeGCJ02": "",
                "activityLongitudeWGS84": "",
                "activityLatitudeWGS84": "",
                "activityGeoProvider": "amap",
                "activityGeoStatus": "skipped_vague",
                "activityStaticMapUrl": "",
                "activityStaticMapStatus": "skipped_vague",
            }
        )
        return item

    city_hint = str(item.get(city_hint_field, "")).strip() if city_hint_field else ""
    payload = client.geocode(address, city_hint=city_hint)
    geocodes = payload.get("geocodes", []) if isinstance(payload, dict) else []
    if not geocodes:
        item.update(
            {
                "activityLongitudeGCJ02": "",
                "activityLatitudeGCJ02": "",
                "activityLongitudeWGS84": "",
                "activityLatitudeWGS84": "",
                "activityGeoProvider": "amap",
                "activityGeoStatus": "not_found",
                "activityStaticMapUrl": "",
                "activityStaticMapStatus": "not_found",
            }
        )
        return item

    location = str(geocodes[0].get("location", ""))
    try:
        gcj_lng_str, gcj_lat_str = location.split(",", 1)
        gcj_lng = float(gcj_lng_str)
        gcj_lat = float(gcj_lat_str)
    except ValueError as exc:
        raise RuntimeError(f"invalid geocode location: {location}") from exc

    wgs_lng, wgs_lat = gcj02_to_wgs84(gcj_lng, gcj_lat)
    static_map_url = build_static_map_url(client.amap_key, gcj_lng, gcj_lat)
    item.update(
        {
            "activityLongitudeGCJ02": round(gcj_lng, 6),
            "activityLatitudeGCJ02": round(gcj_lat, 6),
            "activityLongitudeWGS84": round(wgs_lng, 6),
            "activityLatitudeWGS84": round(wgs_lat, 6),
            "activityGeoProvider": "amap",
            "activityGeoStatus": "ok",
            "activityStaticMapUrl": static_map_url,
            "activityStaticMapStatus": "ok" if static_map_url else "missing_key",
        }
    )
    return item


def run_geocode(args: argparse.Namespace) -> List[Dict[str, Any]]:
    input_path = Path(args.input).expanduser().resolve()
    output_path = Path(args.output).expanduser().resolve()
    fixture_path = Path(args.fixture_file).expanduser().resolve() if args.fixture_file else None
    data = read_json(input_path)
    if not isinstance(data, list):
        raise RuntimeError("input must be a JSON array")

    client = AMapClient(amap_key=args.amap_key, fixture_file=fixture_path)
    enriched = [enrich_record(item, client, city_hint_field=args.city_hint_field) for item in data]
    write_json(output_path, enriched)
    return enriched


def main() -> int:
    args = parse_args()
    run_geocode(args)
    return 0


if __name__ == "__main__":
    try:
        raise SystemExit(main())
    except Exception as exc:  # noqa: BLE001
        print(json.dumps({"error": str(exc)}, ensure_ascii=False), file=sys.stderr)
        raise SystemExit(1)

#!/usr/bin/env bash

set -euo pipefail

usage() {
  cat <<'EOF'
Usage:
  bash fetch_recent_feeds.sh \
    --feeds-file /path/to/feeds.md \
    --output-file /path/to/raw.json \
    --api-host https://example.com \
    [--api-key secret] \
    [--hours 24]
EOF
}

FEEDS_FILE=""
OUTPUT_FILE=""
MP_API_HOST=""
MP_API_KEY="${MP_API_KEY:-}"
HOURS=24
SEEN_IDS_FILE=""

while [ "$#" -gt 0 ]; do
  case "$1" in
    --feeds-file)
      FEEDS_FILE="${2:-}"
      shift 2
      ;;
    --output-file)
      OUTPUT_FILE="${2:-}"
      shift 2
      ;;
    --api-host)
      MP_API_HOST="${2:-}"
      shift 2
      ;;
    --api-key)
      MP_API_KEY="${2:-}"
      shift 2
      ;;
    --hours)
      HOURS="${2:-}"
      shift 2
      ;;
    -h|--help)
      usage
      exit 0
      ;;
    *)
      echo "unknown argument: $1" >&2
      usage >&2
      exit 1
      ;;
  esac
done

test -n "${FEEDS_FILE}" || { echo "missing --feeds-file" >&2; exit 1; }
test -n "${OUTPUT_FILE}" || { echo "missing --output-file" >&2; exit 1; }
test -n "${MP_API_HOST}" || { echo "missing --api-host" >&2; exit 1; }
test -f "${FEEDS_FILE}" || { echo "feeds file not found: ${FEEDS_FILE}" >&2; exit 1; }
command -v curl >/dev/null || { echo "missing curl" >&2; exit 1; }
command -v jq >/dev/null || { echo "missing jq" >&2; exit 1; }

mkdir -p "$(dirname "${OUTPUT_FILE}")"

CUTOFF_EPOCH="$(date -v-"${HOURS}"H +%s 2>/dev/null || date -d "${HOURS} hours ago" +%s)"
RAW_TMP_DIR="$(mktemp -d)"
trap 'rm -rf "${RAW_TMP_DIR}"' EXIT
SEEN_IDS_FILE="${RAW_TMP_DIR}/seen-mp-ids.txt"
: > "${SEEN_IDS_FILE}"

parse_epoch() {
  local raw="${1:-}"
  local normalized=""
  local epoch=""

  test -n "${raw}" || { echo 0; return; }

  normalized="$(printf '%s' "${raw}" | sed -E 's/([+-][0-9]{2}):([0-9]{2})$/\1\2/')"

  for fmt in \
    "%Y-%m-%dT%H:%M:%S%z" \
    "%Y-%m-%dT%H:%M%z" \
    "%Y-%m-%d %H:%M:%S%z" \
    "%Y-%m-%d %H:%M%z" \
    "%Y-%m-%dT%H:%M:%SZ" \
    "%Y-%m-%dT%H:%MZ" \
    "%Y-%m-%d %H:%M:%S" \
    "%Y-%m-%d %H:%M" \
    "%Y/%m/%d %H:%M:%S" \
    "%Y/%m/%d %H:%M" \
    "%Y-%m-%d" \
    "%Y/%m/%d"
  do
    epoch="$(date -j -f "${fmt}" "${normalized}" +%s 2>/dev/null)" && {
      echo "${epoch}"
      return
    }
  done

  epoch="$(date -d "${raw}" +%s 2>/dev/null)" && {
    echo "${epoch}"
    return
  }
  epoch="$(date -d "${normalized}" +%s 2>/dev/null)" && {
    echo "${epoch}"
    return
  }

  echo 0
}

# Read feeds from a dedicated descriptor so loop body commands cannot consume it.
exec 3< "${FEEDS_FILE}"
while IFS= read -r line <&3 || [ -n "${line}" ]; do
  case "${line}" in
    ""|\#*) continue ;;
  esac

  MP_ID="$(printf '%s\n' "${line}" | awk '{print $1}')"
  MP_ID="${MP_ID%,}"
  test -n "${MP_ID}" || continue

  MP_NAME="$(printf '%s\n' "${line}" | sed -E 's/^[^[:space:]]+[[:space:]]*//')"
  if [ "${MP_NAME}" = "${line}" ]; then
    MP_NAME=""
  fi
  MP_NAME="$(printf '%s' "${MP_NAME}" | sed -E 's/^[[:space:]]+//; s/[[:space:]]+$//')"

  if grep -Fqx "${MP_ID}" "${SEEN_IDS_FILE}"; then
    continue
  fi
  printf '%s\n' "${MP_ID}" >> "${SEEN_IDS_FILE}"

  FEED_URL="${MP_API_HOST%/}/feed/${MP_ID}.json"
  OUT_FILE="${RAW_TMP_DIR}/${MP_ID}.json"
  JSONL_FILE="${RAW_TMP_DIR}/${MP_ID}.jsonl"
  FILTERED_FILE="${RAW_TMP_DIR}/${MP_ID}.filtered"

  CURL_ARGS=(-fsSL -H "Accept: application/json")
  if [ -n "${MP_API_KEY}" ]; then
    CURL_ARGS+=(
      -H "Authorization: Bearer ${MP_API_KEY}"
      -H "X-API-Key: ${MP_API_KEY}"
    )
  fi

  if ! curl "${CURL_ARGS[@]}" "${FEED_URL}" -o "${OUT_FILE}"; then
    echo "warning: 拉取失败 ${MP_ID} ${MP_NAME}" >&2
    continue
  fi

  jq -c \
    --arg mpId "${MP_ID}" \
    --arg mpName "${MP_NAME}" \
    --arg feedUrl "${FEED_URL}" '
      def article_list:
        if type == "array" then .
        elif .items? then .items
        elif .articles? then .articles
        elif .entries? then .entries
        elif (.data? | type) == "array" then .data
        elif (.data? | type) == "object" then (.data.items // .data.articles // .data.entries // [])
        else []
        end;

      [
        article_list[]
        | . + {
            mpId: $mpId,
            mpName: $mpName,
            feedUrl: $feedUrl,
            sourceUpdated: (.updated // .publish_time // .published // .pubDate // ""),
            sourceUrl: (.url // .link // .permalink // ""),
            sourceTitle: (.title // .name // ""),
            sourceSummary: (.summary // .description // .excerpt // .digest // "")
          }
      ][]
    ' "${OUT_FILE}" > "${JSONL_FILE}"

  : > "${FILTERED_FILE}"
  while IFS= read -r article_json; do
    UPDATED_RAW="$(printf '%s' "${article_json}" | jq -r '.sourceUpdated // empty')"
    UPDATED_EPOCH="$(parse_epoch "${UPDATED_RAW}")"
    if [ "${UPDATED_EPOCH}" -ge "${CUTOFF_EPOCH}" ] 2>/dev/null; then
      printf '%s\n' "${article_json}" >> "${FILTERED_FILE}"
    fi
  done < "${JSONL_FILE}"
done
exec 3<&-

FILTERED_FILES=()
while IFS= read -r filtered_file; do
  FILTERED_FILES+=("${filtered_file}")
done < <(find "${RAW_TMP_DIR}" -type f -name '*.filtered' | sort)

if [ "${#FILTERED_FILES[@]}" -gt 0 ]; then
  jq -s '.' "${FILTERED_FILES[@]}" > "${OUTPUT_FILE}"
else
  printf '[]\n' > "${OUTPUT_FILE}"
fi

#!/usr/bin/env python3
from __future__ import annotations

import argparse
import json
import math
import os
import platform
import shutil
import subprocess
from io import BytesIO
from functools import lru_cache
from pathlib import Path
from typing import Any, Dict, List, Optional, Sequence, Tuple
from urllib import request

from PIL import Image, ImageDraw, ImageFont, ImageOps
import qrcode


DEFAULT_WIDTH = 1280
PAGE_PADDING = 56
CARD_PADDING = 36
CARD_GAP = 32
MAP_WIDTH = 340
MAP_HEIGHT = 200
QR_SIZE = 100

# 活泼年轻配色方案
BACKGROUND = "#FFF9F0"  # 温暖的奶油白
CARD_BG = "#FFFFFF"  # 纯白卡片
TEXT = "#1A1A2E"  # 深蓝黑，更年轻
MUTED = "#6B7280"  # 现代灰
ACCENT = "#FF6B6B"  # 珊瑚红，活力强调色
ACCENT_SECONDARY = "#4ECDC4"  # 青绿色，辅助强调
ACCENT_TERTIARY = "#FFE66D"  # 明亮黄，装饰用
BORDER = "#E8E8E8"  # 浅灰边框
PLACEHOLDER_BG = "#F3F4F6"

# 类型标签配色
TYPE_COLORS = {
    "讲座": ("#FF6B6B", "#FFE8E8"),
    "分享会": ("#4ECDC4", "#E0F7F5"),
    "工作坊": ("#95E1D3", "#E8FAF7"),
    "训练营": ("#F38181", "#FFE8E8"),
    "路演": ("#AA96DA", "#F0EBF8"),
    "直播": ("#FCBAD3", "#FEF0F5"),
    "闭门会": ("#A8D8EA", "#E8F6FC"),
    "线上": ("#6C5CE7", "#E8E6F9"),
}

# 图标颜色
ICON_COLORS = {
    "time": "#FF6B6B",
    "location": "#4ECDC4",
    "people": "#F9CA24",
    "description": "#6C5CE7",
}


def hex_to_rgb(hex_color: str) -> tuple:
    """将十六进制颜色转换为 RGB 元组"""
    hex_color = hex_color.lstrip('#')
    return tuple(int(hex_color[i:i+2], 16) for i in (0, 2, 4))


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="Render activity summary image from activity-structured-geo.json.")
    parser.add_argument("--input", required=True, help="Path to activity-structured-geo.json.")
    parser.add_argument("--output", required=True, help="Path to output PNG.")
    parser.add_argument("--title", default="活动情报速递", help="Poster title.")
    parser.add_argument("--subtitle", default="", help="Optional subtitle.")
    parser.add_argument("--watermark", default="潮匠里", help="Watermark text shown at top-right.")
    parser.add_argument("--width", type=int, default=DEFAULT_WIDTH, help="Canvas width in pixels.")
    parser.add_argument("--download-timeout", type=float, default=10.0, help="Timeout for remote images.")
    return parser.parse_args()


def read_json(path: Path) -> Any:
    return json.loads(path.read_text(encoding="utf-8"))


def _existing_paths(paths: Sequence[str]) -> List[str]:
    result: List[str] = []
    seen = set()
    for item in paths:
        expanded = str(Path(item).expanduser())
        if expanded in seen:
            continue
        if Path(expanded).exists():
            result.append(expanded)
            seen.add(expanded)
    return result


def _fc_match_font(family: str) -> str:
    if not shutil.which("fc-match"):
        return ""
    try:
        result = subprocess.run(
            ["fc-match", "-f", "%{file}\n", family],
            capture_output=True,
            check=True,
            text=True,
        )
    except (OSError, subprocess.SubprocessError):
        return ""
    path = result.stdout.strip().splitlines()[0] if result.stdout.strip() else ""
    return path if path and Path(path).exists() else ""


@lru_cache(maxsize=4)
def font_candidates(bold: bool = False) -> Tuple[str, ...]:
    candidates: List[str] = []

    env_keys = ["ACTIVITY_PUSH_FONT_PATH"]
    env_keys.append("ACTIVITY_PUSH_FONT_BOLD_PATH" if bold else "ACTIVITY_PUSH_FONT_REGULAR_PATH")
    for key in env_keys:
        value = os.environ.get(key, "").strip()
        if value:
            candidates.append(value)

    system = platform.system().lower()
    if system == "darwin":
        candidates.extend(
            [
                "/System/Library/Fonts/Supplemental/PingFang.ttc",
                "/System/Library/Fonts/PingFang.ttc",
                "/System/Library/Fonts/Hiragino Sans GB.ttc",
                "/System/Library/Fonts/Supplemental/Songti.ttc",
                "/System/Library/Fonts/Supplemental/Arial Unicode.ttf",
            ]
        )
    else:
        candidates.extend(
            [
                "/usr/share/fonts/opentype/noto/NotoSansCJK-Bold.ttc" if bold else "/usr/share/fonts/opentype/noto/NotoSansCJK-Regular.ttc",
                "/usr/share/fonts/opentype/noto/NotoSansCJKsc-Bold.otf" if bold else "/usr/share/fonts/opentype/noto/NotoSansCJKsc-Regular.otf",
                "/usr/share/fonts/opentype/noto/NotoSansSC-Bold.otf" if bold else "/usr/share/fonts/opentype/noto/NotoSansSC-Regular.otf",
                "/usr/share/fonts/truetype/noto/NotoSansCJK-Bold.ttc" if bold else "/usr/share/fonts/truetype/noto/NotoSansCJK-Regular.ttc",
                "/usr/share/fonts/truetype/noto/NotoSansSC-Bold.ttf" if bold else "/usr/share/fonts/truetype/noto/NotoSansSC-Regular.ttf",
                "/usr/share/fonts/truetype/wqy/wqy-zenhei.ttc",
                "/usr/share/fonts/truetype/arphic/uming.ttc",
                "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf" if bold else "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
            ]
        )
        family_names = [
            "Noto Sans CJK SC:bold" if bold else "Noto Sans CJK SC",
            "Noto Sans SC:bold" if bold else "Noto Sans SC",
            "Source Han Sans SC Bold" if bold else "Source Han Sans SC",
            "WenQuanYi Zen Hei",
            "DejaVu Sans:style=Bold" if bold else "DejaVu Sans",
            "sans-serif:style=Bold" if bold else "sans-serif",
        ]
        candidates.extend(path for path in (_fc_match_font(name) for name in family_names) if path)

    return tuple(_existing_paths(candidates))


def load_font(size: int, bold: bool = False) -> ImageFont.FreeTypeFont | ImageFont.ImageFont:
    for candidate in font_candidates(bold):
        try:
            return ImageFont.truetype(candidate, size=size)
        except OSError:
            continue
    return ImageFont.load_default()


def text_height(draw: ImageDraw.ImageDraw, text: str, font: ImageFont.FreeTypeFont | ImageFont.ImageFont) -> int:
    if not text:
        return 0
    box = draw.multiline_textbbox((0, 0), text, font=font, spacing=6)
    return int(math.ceil(box[3] - box[1]))


def wrap_text(
    draw: ImageDraw.ImageDraw,
    text: str,
    font: ImageFont.FreeTypeFont | ImageFont.ImageFont,
    max_width: int,
) -> List[str]:
    if not text:
        return []
    lines: List[str] = []
    current = ""
    for char in text:
        candidate = current + char
        box = draw.textbbox((0, 0), candidate, font=font)
        if box[2] - box[0] <= max_width or not current:
            current = candidate
            continue
        lines.append(current)
        current = char
    if current:
        lines.append(current)
    return lines


def wrap_labeled_text(
    draw: ImageDraw.ImageDraw,
    label: str,
    value: str,
    font: ImageFont.FreeTypeFont | ImageFont.ImageFont,
    max_width: int,
) -> str:
    prefix = f"{label}："
    if not value:
        return ""
    lines = wrap_text(draw, value, font, max_width - int(draw.textbbox((0, 0), prefix, font=font)[2]))
    if not lines:
        return ""
    wrapped = [f"{prefix}{lines[0]}"]
    indent = " " * len(prefix)
    wrapped.extend(f"{indent}{line}" for line in lines[1:])
    return "\n".join(wrapped)


def build_meta_lines(
    activity: Dict[str, Any],
    draw: ImageDraw.ImageDraw,
    body_font: ImageFont.FreeTypeFont | ImageFont.ImageFont,
    content_width: int,
) -> List[str]:
    time_value = build_time_text(activity)
    fields = [
        ("类型", str(activity.get("activityType", "")).strip()),
        ("时间", time_value),
        ("地点", str(activity.get("activityAddress", "")).strip()),
        ("人数", str(activity.get("activityLimitNum", "")).strip()),
        ("说明", str(activity.get("activityDescription", "")).strip()),
    ]
    lines = [wrap_labeled_text(draw, label, value, body_font, content_width) for label, value in fields if value]
    return [line for line in lines if line]


def build_time_text(activity: Dict[str, Any]) -> str:
    start = str(activity.get("activityStartTime", "")).strip()
    end = str(activity.get("activityEndTime", "")).strip()
    if start and end:
        return f"{start} - {end}"
    if start:
        return start
    if end:
        return end
    return ""

def build_qr_image(content: str, size: int = QR_SIZE) -> Optional[Image.Image]:
    if not content:
        return None
    qr = qrcode.QRCode(
        version=None,
        error_correction=qrcode.constants.ERROR_CORRECT_M,
        box_size=10,
        border=2,
    )
    qr.add_data(content)
    qr.make(fit=True)
    image = qr.make_image(fill_color=TEXT, back_color="white").convert("RGB")
    return ImageOps.fit(image, (size, size), method=Image.Resampling.NEAREST)


def load_image(source: str, timeout: float) -> Optional[Image.Image]:
    if not source:
        return None
    try:
        if source.startswith("file://"):
            return Image.open(source[7:]).convert("RGB")
        local_path = Path(source)
        if local_path.exists():
            return Image.open(local_path).convert("RGB")
        with request.urlopen(source, timeout=timeout) as resp:
            return Image.open(BytesIO(resp.read())).convert("RGB")
    except Exception:
        return None


def has_coordinates(activity: Dict[str, Any]) -> bool:
    lng = str(activity.get("activityLongitudeGCJ02", "")).strip()
    lat = str(activity.get("activityLatitudeGCJ02", "")).strip()
    if not lng or not lat:
        return False
    try:
        float(lng)
        float(lat)
    except ValueError:
        return False
    return True


def require_source_url(activity: Dict[str, Any], index: int) -> str:
    source_url = str(activity.get("sourceUrl", "")).strip()
    if source_url:
        return source_url
    activity_name = str(activity.get("activityName", "")).strip() or f"第 {index} 条活动"
    raise RuntimeError(f"activity {index} missing sourceUrl, cannot render required QR code: {activity_name}")


def draw_qr_block(
    image: Image.Image,
    draw: ImageDraw.ImageDraw,
    link_url: str,
    left: int,
    top: int,
    fonts: Dict[str, ImageFont.FreeTypeFont | ImageFont.ImageFont],
) -> int:
    """绘制更年轻的二维码区块"""
    qr = build_qr_image(link_url, QR_SIZE)
    if qr is None:
        return 0

    # 绘制装饰性背景圆
    bg_size = QR_SIZE + 16
    bg_left = left - 8
    bg_top = top - 8
    draw.ellipse(
        (bg_left, bg_top, bg_left + bg_size, bg_top + bg_size),
        fill="#F3F4F6", outline=BORDER, width=1
    )

    # 粘贴二维码
    qr_box = (left, top, left + QR_SIZE, top + QR_SIZE)
    image.paste(qr, (left, top))

    # 绘制小装饰点
    dot_color = ACCENT_SECONDARY
    draw.ellipse((bg_left - 4, bg_top + bg_size // 2 - 4, bg_left + 4, bg_top + bg_size // 2 + 4), fill=dot_color)
    draw.ellipse((bg_left + bg_size - 4, bg_top + 8, bg_left + bg_size + 4, bg_top + 16), fill=ACCENT_TERTIARY)

    return QR_SIZE + 16


def draw_decorative_elements(
    draw: ImageDraw.ImageDraw,
    width: int,
    top: int,
) -> None:
    """绘制装饰性元素（圆点、线条等）"""
    # 左上角装饰圆点
    draw.ellipse((PAGE_PADDING - 20, top - 10, PAGE_PADDING, top + 10), fill=ACCENT)
    draw.ellipse((PAGE_PADDING + 8, top + 5, PAGE_PADDING + 16, top + 13), fill=ACCENT_SECONDARY)
    draw.ellipse((PAGE_PADDING + 22, top - 5, PAGE_PADDING + 30, top + 3), fill=ACCENT_TERTIARY)

    # 右上角装饰线条
    line_y = top + 20
    for i, color in enumerate([ACCENT, ACCENT_SECONDARY, ACCENT_TERTIARY]):
        offset = i * 12
        draw.line((width - PAGE_PADDING - 100 + offset, line_y - offset,
                  width - PAGE_PADDING - 40 + offset, line_y - offset),
                 fill=color, width=4)


def draw_watermark(
    image: Image.Image,
    width: int,
    watermark: str,
    fonts: Dict[str, ImageFont.FreeTypeFont | ImageFont.ImageFont],
) -> None:
    if not watermark.strip():
        return

    overlay = Image.new("RGBA", (200, 120), (0, 0, 0, 0))
    draw = ImageDraw.Draw(overlay)

    # 更年轻的水印设计 - 圆形徽章风格
    center_x, center_y = 100, 60
    radius = 50

    # 外圈渐变效果（用同心圆模拟）
    for i in range(3):
        alpha = 180 - i * 40
        r = radius - i * 3
        draw.ellipse((center_x - r, center_y - r, center_x + r, center_y + r),
                    outline=(*hex_to_rgb(ACCENT), alpha), width=2)

    # 背景圆形
    draw.ellipse((center_x - radius + 8, center_y - radius + 8,
                 center_x + radius - 8, center_y + radius - 8),
                fill=(*hex_to_rgb(CARD_BG), 200))

    # 文字
    text_box = draw.textbbox((0, 0), watermark, font=fonts["watermark"])
    text_x = center_x - (text_box[2] - text_box[0]) / 2
    text_y = center_y - (text_box[3] - text_box[1]) / 2
    draw.text((text_x, text_y), watermark, fill=(*hex_to_rgb(ACCENT), 220), font=fonts["watermark"])

    # 装饰小点
    draw.ellipse((center_x - radius - 5, center_y - 3, center_x - radius + 3, center_y + 5), fill=ACCENT_SECONDARY)
    draw.ellipse((center_x + radius - 3, center_y - 8, center_x + radius + 5, center_y), fill=ACCENT_TERTIARY)

    rotated = overlay.rotate(-12, resample=Image.Resampling.BICUBIC, expand=True)
    paste_left = width - PAGE_PADDING - rotated.size[0] + 20
    image.paste(rotated, (paste_left, -10), rotated)


def get_type_color(activity_type: str) -> tuple:
    """获取活动类型的颜色配置"""
    for type_key, colors in TYPE_COLORS.items():
        if type_key in activity_type:
            return colors
    return (ACCENT, "#FFE8E8")  # 默认颜色


def draw_shadow_rounded_rectangle(
    draw: ImageDraw.ImageDraw,
    bbox: tuple,
    radius: int,
    fill: str,
    shadow_color: str = "#00000010",
    shadow_offset: int = 4,
) -> None:
    """绘制带阴影的圆角矩形"""
    x1, y1, x2, y2 = bbox
    # 阴影
    shadow_bbox = (x1 + shadow_offset, y1 + shadow_offset, x2 + shadow_offset, y2 + shadow_offset)
    draw.rounded_rectangle(shadow_bbox, radius=radius, fill=shadow_color)
    # 主体
    draw.rounded_rectangle(bbox, radius=radius, fill=fill, outline=BORDER, width=1)


def draw_type_tag(
    draw: ImageDraw.ImageDraw,
    activity_type: str,
    left: int,
    top: int,
    fonts: Dict[str, ImageFont.FreeTypeFont | ImageFont.ImageFont],
) -> int:
    """绘制活动类型标签，返回标签宽度"""
    if not activity_type:
        return 0

    text_color, bg_color = get_type_color(activity_type)
    text_box = draw.textbbox((0, 0), activity_type, font=fonts["small"])
    text_width = text_box[2] - text_box[0]
    tag_width = text_width + 20
    tag_height = 28

    draw.rounded_rectangle(
        (left, top, left + tag_width, top + tag_height),
        radius=14, fill=bg_color
    )
    draw.text(
        (left + 10, top + 4),
        activity_type, fill=text_color, font=fonts["small"]
    )

    return tag_width + 8  # 返回标签宽度 + 间距


def draw_icon_and_text(
    draw: ImageDraw.ImageDraw,
    icon_type: str,
    text: str,
    left: int,
    top: int,
    max_width: int,
    fonts: Dict[str, ImageFont.FreeTypeFont | ImageFont.ImageFont],
) -> int:
    """绘制带图标的文本行，返回下一行的y坐标"""
    if not text:
        return top

    icon_color = ICON_COLORS.get(icon_type, MUTED)
    icon_size = 16

    # 绘制简单图标（圆形背景 + 符号）
    icon_center_x = left + icon_size // 2
    icon_center_y = top + icon_size // 2 + 2
    draw.ellipse(
        (icon_center_x - icon_size // 2, icon_center_y - icon_size // 2,
         icon_center_x + icon_size // 2, icon_center_y + icon_size // 2),
        fill=icon_color
    )

    # 文字区域
    text_left = left + icon_size + 8
    available_width = max_width - icon_size - 8

    # 换行处理
    lines = wrap_text(draw, text, fonts["body"], available_width)
    line_height = text_height(draw, "测试", fonts["body"]) + 8

    for i, line in enumerate(lines):
        draw.text((text_left, top + i * line_height), line, fill=TEXT, font=fonts["body"])

    return top + len(lines) * line_height + 4


def render_card(
    image: Image.Image,
    draw: ImageDraw.ImageDraw,
    activity: Dict[str, Any],
    index: int,
    top: int,
    width: int,
    timeout: float,
    fonts: Dict[str, ImageFont.FreeTypeFont | ImageFont.ImageFont],
) -> int:
    card_left = PAGE_PADDING
    card_right = width - PAGE_PADDING
    card_inner_width = card_right - card_left - CARD_PADDING * 2

    title = str(activity.get('activityName', '')).strip() or '未命名活动'
    activity_type = str(activity.get('activityType', '')).strip()
    source_url = require_source_url(activity, index)

    show_map = has_coordinates(activity) and bool(str(activity.get("activityStaticMapUrl", "")).strip())
    show_qr = True
    show_side_column = show_map or show_qr
    text_width = card_inner_width - MAP_WIDTH - 32 if show_side_column else card_inner_width

    # 计算标题高度（考虑序号圆圈）
    title_prefix_width = 36  # 序号圆圈的宽度 + 间距
    title_lines = wrap_text(draw, title, fonts["title"], text_width - title_prefix_width)
    title_height = text_height(draw, "\n".join(title_lines), fonts["title"])

    # 计算元信息高度
    meta_start_y = 0  # 稍后计算
    meta_total_height = 0

    # 收集需要显示的信息
    time_value = build_time_text(activity)
    address = str(activity.get("activityAddress", "")).strip()
    limit_num = str(activity.get("activityLimitNum", "")).strip()
    description = str(activity.get("activityDescription", "")).strip()

    # 估算元信息区域高度
    line_height = text_height(draw, "测试", fonts["body"]) + 12
    meta_items_count = sum([bool(time_value), bool(address), bool(limit_num), bool(description)])
    meta_total_height = meta_items_count * line_height + 20

    # 计算右侧区域高度
    right_column_height = 0
    if show_map:
        right_column_height += MAP_HEIGHT
    if show_qr:
        if right_column_height:
            right_column_height += 20
        right_column_height += QR_SIZE

    # 计算总高度
    type_tag_height = 32 if activity_type else 0
    content_height = max(type_tag_height + title_height + 24 + meta_total_height, right_column_height + 20)
    card_height = CARD_PADDING * 2 + content_height

    # 绘制带阴影的卡片
    card_box = (card_left, top, card_right, top + card_height)
    draw_shadow_rounded_rectangle(draw, card_box, radius=32, fill=CARD_BG)

    content_left = card_left + CARD_PADDING
    content_top = top + CARD_PADDING
    side_left = card_right - CARD_PADDING - MAP_WIDTH
    side_top = content_top + 10

    # 绘制序号圆圈
    circle_radius = 14
    circle_x = content_left + circle_radius
    circle_y = content_top + circle_radius
    draw.ellipse(
        (circle_x - circle_radius, circle_y - circle_radius,
         circle_x + circle_radius, circle_y + circle_radius),
        fill=ACCENT
    )
    index_text = str(index)
    text_box = draw.textbbox((0, 0), index_text, font=fonts["small"])
    text_width_actual = text_box[2] - text_box[0]
    text_height_actual = text_box[3] - text_box[1]
    draw.text(
        (circle_x - text_width_actual / 2, circle_y - text_height_actual / 2 - 1),
        index_text, fill="white", font=fonts["small"]
    )

    # 绘制类型标签
    current_x = content_left + 36
    if activity_type:
        tag_width = draw_type_tag(draw, activity_type, current_x, content_top + 2, fonts)
        current_x += tag_width

    # 绘制标题
    title_y = content_top + (36 if activity_type else 0)
    draw.multiline_text(
        (content_left + 36, title_y),
        "\n".join(title_lines),
        fill=TEXT,
        font=fonts["title"],
        spacing=8,
    )

    # 绘制元信息（带图标）
    meta_y = title_y + title_height + 20
    if time_value:
        meta_y = draw_icon_and_text(draw, "time", f"时间：{time_value}", content_left, meta_y, text_width, fonts)
    if address:
        meta_y = draw_icon_and_text(draw, "location", f"地点：{address}", content_left, meta_y, text_width, fonts)
    if limit_num:
        meta_y = draw_icon_and_text(draw, "people", f"人数：{limit_num}人", content_left, meta_y, text_width, fonts)
    if description:
        meta_y = draw_icon_and_text(draw, "description", description, content_left, meta_y, text_width, fonts)

    # 绘制右侧地图
    if show_map:
        map_box = (side_left, side_top, side_left + MAP_WIDTH, side_top + MAP_HEIGHT)
        static_map = load_image(str(activity.get("activityStaticMapUrl", "")).strip(), timeout)
        if static_map is not None:
            fitted = ImageOps.fit(static_map, (MAP_WIDTH, MAP_HEIGHT), method=Image.Resampling.LANCZOS)
            # 添加圆角遮罩
            mask = Image.new('L', (MAP_WIDTH, MAP_HEIGHT), 0)
            mask_draw = ImageDraw.Draw(mask)
            mask_draw.rounded_rectangle((0, 0, MAP_WIDTH, MAP_HEIGHT), radius=20, fill=255)
            image.paste(fitted, (side_left, side_top), mask)
            draw.rounded_rectangle(map_box, radius=20, outline=BORDER, width=1)

    # 绘制二维码
    if show_qr:
        qr_top = side_top + (MAP_HEIGHT + 20 if show_map else 0)
        qr_left = side_left + (MAP_WIDTH - QR_SIZE) // 2  # 居中
        draw_qr_block(image, draw, source_url, qr_left, qr_top, fonts)

    return top + card_height + CARD_GAP


def build_empty_state(
    image: Image.Image,
    draw: ImageDraw.ImageDraw,
    width: int,
    top: int,
    fonts: Dict[str, ImageFont.FreeTypeFont | ImageFont.ImageFont],
) -> int:
    card_box = (PAGE_PADDING, top, width - PAGE_PADDING, top + 240)
    draw_shadow_rounded_rectangle(draw, card_box, radius=32, fill=CARD_BG)

    # 绘制装饰图标（用圆形和线条模拟）
    icon_center_x = PAGE_PADDING + CARD_PADDING + 30
    icon_center_y = top + 70

    # 大圆背景
    draw.ellipse(
        (icon_center_x - 30, icon_center_y - 30, icon_center_x + 30, icon_center_y + 30),
        fill="#FFE8E8"
    )
    # 小圆装饰
    draw.ellipse(
        (icon_center_x - 15, icon_center_y - 15, icon_center_x + 15, icon_center_y + 15),
        fill=ACCENT
    )
    # 表情符号位置的小点
    draw.ellipse(
        (icon_center_x - 5, icon_center_y - 5, icon_center_x + 5, icon_center_y + 5),
        fill="white"
    )

    title = "最近 24 小时未发现新的活动文章"
    body = "可保留这张图作为当天空结果的归档凭证。"

    draw.text((PAGE_PADDING + CARD_PADDING + 80, top + 50), title, fill=TEXT, font=fonts["title"])
    draw.text((PAGE_PADDING + CARD_PADDING + 80, top + 100), body, fill=MUTED, font=fonts["body"])

    # 底部装饰
    decor_y = top + 180
    for i, color in enumerate([ACCENT, ACCENT_SECONDARY, ACCENT_TERTIARY]):
        x = PAGE_PADDING + CARD_PADDING + i * 40
        draw.ellipse((x, decor_y, x + 12, decor_y + 12), fill=color)

    return top + 240


def estimate_total_height(
    activities: Sequence[Dict[str, Any]],
    width: int,
    fonts: Dict[str, ImageFont.FreeTypeFont | ImageFont.ImageFont],
) -> int:
    probe = Image.new("RGB", (width, 10), BACKGROUND)
    draw = ImageDraw.Draw(probe)
    top = PAGE_PADDING + 160  # 增加顶部空间以适应新的 header 设计
    if not activities:
        return build_empty_state(probe, draw, width, top, fonts) + PAGE_PADDING

    for index, activity in enumerate(activities, start=1):
        top = render_card(probe, draw, activity, index, top, width, timeout=0, fonts=fonts)
    return top + PAGE_PADDING


def render_header(
    image: Image.Image,
    draw: ImageDraw.ImageDraw,
    width: int,
    title: str,
    subtitle: str,
    count: int,
    watermark: str,
    fonts: Dict[str, ImageFont.FreeTypeFont | ImageFont.ImageFont],
) -> None:
    # 绘制装饰元素
    draw_decorative_elements(draw, width, PAGE_PADDING + 30)

    # 标题使用渐变色效果（通过多层文字模拟）
    draw.text((PAGE_PADDING, PAGE_PADDING + 25), title, fill=TEXT, font=fonts["headline"])

    # 副标题带图标
    meta = subtitle.strip() if subtitle.strip() else f"共 {count} 条活动"
    draw.text((PAGE_PADDING, PAGE_PADDING + 85), meta, fill=MUTED, font=fonts["body"])

    # 活动数量徽章
    if count > 0:
        badge_text = f"{count}"
        badge_font = fonts["section"]
        text_box = draw.textbbox((0, 0), badge_text, font=badge_font)
        badge_width = text_box[2] - text_box[0] + 24
        badge_height = text_box[3] - text_box[1] + 12
        badge_x = PAGE_PADDING + 320
        badge_y = PAGE_PADDING + 20

        # 圆角徽章
        draw.rounded_rectangle(
            (badge_x, badge_y, badge_x + badge_width, badge_y + badge_height),
            radius=16, fill=ACCENT
        )
        draw.text(
            (badge_x + 12, badge_y + 6),
            badge_text, fill="white", font=badge_font
        )

    draw_watermark(image, width, watermark, fonts)

    # 底部装饰线 - 使用渐变效果
    line_y = PAGE_PADDING + 135
    line_colors = [ACCENT, ACCENT_SECONDARY, ACCENT_TERTIARY]
    segment_width = (width - PAGE_PADDING * 2) // len(line_colors)
    for i, color in enumerate(line_colors):
        x1 = PAGE_PADDING + i * segment_width
        x2 = x1 + segment_width - 4
        draw.line((x1, line_y, x2, line_y), fill=color, width=4)


def run_render(args: argparse.Namespace) -> Path:
    input_path = Path(args.input).expanduser().resolve()
    output_path = Path(args.output).expanduser().resolve()
    output_path.parent.mkdir(parents=True, exist_ok=True)

    data = read_json(input_path)
    if not isinstance(data, list):
        raise RuntimeError("input must be a JSON array")

    fonts = {
        "headline": load_font(48, bold=True),
        "title": load_font(28, bold=True),
        "section": load_font(22, bold=True),
        "body": load_font(18),
        "small": load_font(14),
        "watermark": load_font(32, bold=True),
    }
    height = estimate_total_height(data, args.width, fonts)
    image = Image.new("RGB", (args.width, height), BACKGROUND)
    draw = ImageDraw.Draw(image)

    render_header(
        image,
        draw,
        args.width,
        args.title,
        args.subtitle,
        len(data),
        getattr(args, "watermark", "潮匠里"),
        fonts,
    )
    top = PAGE_PADDING + 160  # 增加顶部空间以适应新的 header 设计
    if not data:
        build_empty_state(image, draw, args.width, top, fonts)
    else:
        for index, activity in enumerate(data, start=1):
            top = render_card(image, draw, activity, index, top, args.width, args.download_timeout, fonts)

    image.save(output_path, format="PNG")
    return output_path


def main() -> int:
    args = parse_args()
    run_render(args)
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

{
  "上海市徐汇区漕溪北路398号": {
    "status": "1",
    "info": "OK",
    "infocode": "10000",
    "count": "1",
    "geocodes": [
      {
        "formatted_address": "上海市徐汇区漕溪北路398号",
        "location": "121.436525,31.194729",
        "level": "门址"
      }
    ]
  }
}

from __future__ import annotations

import json
import sys
import tempfile
import unittest
from argparse import Namespace
from pathlib import Path

SKILL_ROOT = Path(__file__).resolve().parents[1]
if str(SKILL_ROOT) not in sys.path:
    sys.path.insert(0, str(SKILL_ROOT))

from scripts.amap_geocode_wgs84 import build_static_map_url, gcj02_to_wgs84, is_precise_address, run_geocode


FIXTURE_FILE = Path(__file__).parent / "fixtures" / "amap-geocode" / "responses.json"


class AMapGeocodeWgs84Tests(unittest.TestCase):
    def test_build_static_map_url_returns_v3_staticmap_url(self) -> None:
        url = build_static_map_url("test-key", 121.436525, 31.194729)
        self.assertIn("https://restapi.amap.com/v3/staticmap?", url)
        self.assertIn("key=test-key", url)
        self.assertIn("location=121.436525%2C31.194729", url)
        self.assertNotIn("markers=", url)

    def test_gcj02_to_wgs84_returns_reasonable_offset(self) -> None:
        lng, lat = gcj02_to_wgs84(121.473701, 31.230416)
        self.assertAlmostEqual(lng, 121.469177, places=3)
        self.assertAlmostEqual(lat, 31.232342, places=3)

    def test_is_precise_address_rejects_vague_locations(self) -> None:
        self.assertFalse(is_precise_address(""))
        self.assertFalse(is_precise_address("线上"))
        self.assertFalse(is_precise_address("上海市徐汇区，报名后通知具体地点"))
        self.assertFalse(is_precise_address("浦东新区某地"))
        self.assertTrue(is_precise_address("上海市徐汇区漕溪北路398号"))
        self.assertTrue(is_precise_address("上海中心大厦"))

    def test_run_geocode_with_fixture(self) -> None:
        with tempfile.TemporaryDirectory() as tmpdir:
            input_path = Path(tmpdir) / "activity-structured.json"
            output_path = Path(tmpdir) / "activity-structured-geo.json"
            input_path.write_text(
                json.dumps(
                    [
                        {
                            "activityName": "AI 工作坊",
                            "activityAddress": "上海市徐汇区漕溪北路398号",
                        },
                        {
                            "activityName": "线上分享会",
                            "activityAddress": "",
                        },
                        {
                            "activityName": "模糊地址活动",
                            "activityAddress": "上海市徐汇区，报名后通知具体地点",
                        },
                    ],
                    ensure_ascii=False,
                ),
                encoding="utf-8",
            )

            args = Namespace(
                input=str(input_path),
                output=str(output_path),
                amap_key="test-key",
                city_hint_field="",
                fixture_file=str(FIXTURE_FILE),
            )

            result = run_geocode(args)
            self.assertEqual(result[0]["activityGeoStatus"], "ok")
            self.assertEqual(result[1]["activityGeoStatus"], "skipped")
            self.assertEqual(result[2]["activityGeoStatus"], "skipped_vague")
            self.assertIn("activityLongitudeWGS84", result[0])
            self.assertEqual(result[0]["activityStaticMapStatus"], "ok")
            self.assertIn("restapi.amap.com/v3/staticmap", result[0]["activityStaticMapUrl"])
            self.assertEqual(result[1]["activityStaticMapStatus"], "skipped")
            self.assertEqual(result[2]["activityStaticMapStatus"], "skipped_vague")
            self.assertTrue(output_path.exists())


if __name__ == "__main__":
    unittest.main()