Linkfox Amazon Store Pricing

"""Shared helpers for linkfox-amazon-store-pricing scripts (storeTokens + developerProxy)."""

from __future__ import annotations

import json
import os
import subprocess
import sys
from pathlib import Path
from typing import Any, Optional

from urllib.error import HTTPError, URLError
from urllib.request import Request, urlopen

REQUIRED_SKILL = "linkfox-amazon-store-auth"
DEPENDENCY_EXIT_CODE = 42

API_BASE_URL = os.environ.get("STORE_API_BASE_URL") or os.environ.get(
    "SPAPI_BASE_URL", "https://tool-gateway.linkfox.com"
)
STORE_TOKENS_ENDPOINT = f"{API_BASE_URL.rstrip('/')}/spApi/storeTokens"
DEVELOPER_PROXY_ENDPOINT = f"{API_BASE_URL.rstrip('/')}/spApi/developerProxy"


def ensure_auth_skill_available(caller_script: str) -> None:
    here = Path(__file__).resolve().parent
    checker = here / "check_auth_dependency.py"
    if not checker.exists():
        payload = {
            "missingSkill": REQUIRED_SKILL,
            "reason": f"check_auth_dependency.py not found next to {caller_script}",
        }
        print(f"DEPENDENCY_MISSING: {json.dumps(payload, ensure_ascii=False)}", file=sys.stderr)
        sys.exit(DEPENDENCY_EXIT_CODE)
    try:
        result = subprocess.run(
            [sys.executable, str(checker)],
            capture_output=True,
            text=True,
            timeout=10,
        )
    except Exception as exc:  # pragma: no cover
        payload = {"missingSkill": REQUIRED_SKILL, "reason": str(exc)}
        print(f"DEPENDENCY_MISSING: {json.dumps(payload, ensure_ascii=False)}", file=sys.stderr)
        sys.exit(DEPENDENCY_EXIT_CODE)
    if result.stderr:
        sys.stderr.write(result.stderr)
        if not result.stderr.endswith("\n"):
            sys.stderr.write("\n")
    if result.returncode != 0:
        sys.exit(DEPENDENCY_EXIT_CODE)


def get_api_key() -> str:
    key = os.environ.get("LINKFOXAGENT_API_KEY")
    if not key:
        print(
            "API Key not configured. Set:\n  export LINKFOXAGENT_API_KEY=<your-key>",
            file=sys.stderr,
        )
        sys.exit(1)
    return key


def call_api(endpoint: str, params: dict, timeout: int = 120) -> dict:
    api_key = get_api_key()
    data = json.dumps(params).encode("utf-8")
    req = Request(
        endpoint,
        data=data,
        headers={
            "Authorization": api_key,
            "Content-Type": "application/json",
            "User-Agent": "LinkFox-Skill/1.0",
        },
        method="POST",
    )
    try:
        with urlopen(req, timeout=timeout) as response:
            return json.loads(response.read().decode("utf-8"))
    except HTTPError as e:
        body = e.read().decode("utf-8") if e.fp else ""
        return {"error": f"HTTP {e.code}: {e.reason}", "details": body}
    except URLError as e:
        return {"error": f"Connection failed: {e.reason}"}


def get_store_tokens(seller_id: str, region: str) -> dict:
    return call_api(STORE_TOKENS_ENDPOINT, {"sellerId": seller_id, "region": region})


def developer_proxy_get(
    region: str,
    path: str,
    access_token: str,
    query_string: Optional[str] = None,
) -> dict:
    params: dict = {
        "region": region,
        "path": path,
        "method": "GET",
        "amzAccessToken": access_token,
    }
    if query_string:
        params["queryString"] = query_string
    return call_api(DEVELOPER_PROXY_ENDPOINT, params)


def developer_proxy_post_json(
    region: str,
    path: str,
    access_token: str,
    body_obj: dict[str, Any],
) -> dict:
    params: dict = {
        "region": region,
        "path": path,
        "method": "POST",
        "amzAccessToken": access_token,
        "body": json.dumps(body_obj, ensure_ascii=False),
        "contentType": "application/json",
    }
    return call_api(DEVELOPER_PROXY_ENDPOINT, params)


def resolve_marketplace_id(params: dict, api_name: str) -> str:
    mid = params.get("marketplaceId")
    if mid is None and params.get("marketplaceIds") is not None:
        mids = params["marketplaceIds"]
        if isinstance(mids, list) and mids:
            mid = mids[0]
            if len(mids) > 1:
                print(
                    f"⚠️  Warning: {api_name} expects a single MarketplaceId; using first marketplaceIds only.",
                    file=sys.stderr,
                )
        elif isinstance(mids, str) and mids.strip():
            mid = mids.strip()
    if mid is None or (isinstance(mid, str) and not mid.strip()):
        raise ValueError("Missing marketplaceId (or non-empty marketplaceIds)")
    return str(mid).strip()

#!/usr/bin/env python3
"""
Dependency Check - linkfox-amazon-store-pricing
================================================

本脚本用于判断当前运行环境里是否已经安装 / 加载了依赖 skill
`linkfox-amazon-store-auth`（与 `linkfox-amazon-store-report` 共用同一检查逻辑）。

用法:
    python check_auth_dependency.py            # 默认检查
    python check_auth_dependency.py --json     # 以 JSON 输出结果

退出码约定（供 agent 程序化解析）:
    0   → 依赖已满足（找到 linkfox-amazon-store-auth 的 SKILL.md）
    42  → DEPENDENCY_MISSING: 未找到依赖 skill，agent 需要触发安装流程

stderr 结构化信号:
    - 若依赖缺失，stderr 第一行会以 `DEPENDENCY_MISSING:` 开头，
      后跟 JSON payload，包含所需 skill 名与建议的安装动作。
    - 成功时 stderr 以 `DEPENDENCY_OK:` 开头。

注意:
    这是一个**不联网**的本地探测脚本。它只检查文件系统上常见的
    skill 安装路径（含 **OpenClaw**、**Hermes Agent** 的常见布局）；
    真正的"能不能调授权接口"取决于依赖 skill 的脚本是否可执行——
    这一点由 get_pricing.py 在运行时再做一次二次校验（通过尝试调用
    /spApi/storeTokens）。

    OpenClaw 参考: workspace 下 `<workspace>/skills`、`<workspace>/.agents/skills`，
    以及 `~/.openclaw/skills`、`~/.agents/skills`（与官方文档优先级一致）。

    Hermes Agent 参考: `~/.hermes/skills/<category>/<skill-name>/SKILL.md`，
    以及 `~/.hermes/plugins/<plugin>/skills/<skill-name>/SKILL.md`；
    额外目录可在 `~/.hermes/config.yaml` 的 `skills.external_dirs` 中配置，
    本脚本无法解析 YAML，请通过环境变量 `HERMES_SKILLS_EXTERNAL_DIRS`（冒号
    或分号分隔的多个路径）或通用的 `LINKFOX_SKILLS_DIR` / `SKILLS_DIR` 注入。
"""

from __future__ import annotations

import argparse
import json
import os
import sys
from pathlib import Path

REQUIRED_SKILL = "linkfox-amazon-store-auth"
# 仍兼容本机未重命名时的旧目录名（历史安装 linkfox-amazon-spapi-auth）
_AUTH_SKILL_DIR_ALIASES = ("linkfox-amazon-store-auth", "linkfox-amazon-spapi-auth")
DEPENDENCY_EXIT_CODE = 42


def _split_path_list(raw: str | None) -> list[Path]:
    """按 OS 路径分隔符拆分（Windows 为 `;`，Unix 为 `:`），避免误拆盘符。"""
    if not raw or not raw.strip():
        return []
    parts = [p.strip() for p in raw.split(os.pathsep) if p.strip()]
    return [Path(p).expanduser() for p in parts]


def candidate_skill_roots() -> list[Path]:
    """按常见的 skill 存放位置，由近到远返回候选根目录（扁平：root/<skill>/SKILL.md）。"""
    roots: list[Path] = []

    # 1) 通过环境变量显式指定（最高优先级）
    for env_var in ("LINKFOX_SKILLS_DIR", "SKILLS_DIR", "CURSOR_SKILLS_DIR"):
        p = os.environ.get(env_var)
        if p:
            roots.append(Path(p).expanduser())

    # 1b) Hermes config.yaml skills.external_dirs 等价注入（本脚本不读 YAML）
    #     例: export HERMES_SKILLS_EXTERNAL_DIRS="$HOME/.agents/skills"
    roots.extend(_split_path_list(os.environ.get("HERMES_SKILLS_EXTERNAL_DIRS")))

    # 2) OpenClaw：工作区下的 skills（与 linkfoxskill / OpenClaw 文档一致）
    for env_var in ("OPENCLAW_WORKSPACE", "OPENCLAW_ROOT", "OPENCLAW_WORKDIR"):
        ws = os.environ.get(env_var)
        if ws:
            w = Path(ws).expanduser()
            roots.append(w / "skills")
            roots.append(w / ".agents" / "skills")

    # 2b) OpenClaw 显式 skills 目录
    oc_skills = os.environ.get("OPENCLAW_SKILLS_DIR")
    if oc_skills:
        roots.append(Path(oc_skills).expanduser())

    # 2c) 当前工作目录下的 workspace skills（CLI 常在项目根执行）
    try:
        cwd = Path.cwd()
        roots.append(cwd / "skills")
        roots.append(cwd / ".agents" / "skills")
    except OSError:
        pass

    # 3) 与本脚本相邻的 skills/ 目录（仓库开发场景）
    here = Path(__file__).resolve()
    if len(here.parents) >= 3:
        roots.append(here.parents[2])

    # 4) 用户级常见安装位置（Claude / Cursor / LinkFox）
    home = Path.home()
    roots.extend([
        home / ".claude" / "skills",
        home / ".cursor" / "skills",
        home / ".cursor" / "skills-cursor",
        home / ".linkfox" / "skills",
    ])

    # 5) OpenClaw 全局与跨工具共享目录
    roots.extend([
        home / ".openclaw" / "skills",
        home / ".hermes" / "skills",
    ])

    # 去重并保留顺序
    seen: set[Path] = set()
    unique: list[Path] = []
    for r in roots:
        try:
            rr = r.resolve()
        except OSError:
            rr = r
        if rr not in seen:
            seen.add(rr)
            unique.append(r)
    return unique


def _hermes_category_skill_md(hermes_skills_root: Path, skill_dir_name: str) -> Path | None:
    """
    Hermes Agent 布局: ~/.hermes/skills/<category>/<skill-name>/SKILL.md
    跳过 .hub、点目录等非 category 项。
    """
    if not hermes_skills_root.is_dir():
        return None
    for category_dir in sorted(hermes_skills_root.iterdir()):
        if not category_dir.is_dir():
            continue
        name = category_dir.name
        if name.startswith(".") or name == ".hub":
            continue
        candidate = category_dir / skill_dir_name / "SKILL.md"
        if candidate.is_file():
            return candidate
    return None


def _hermes_plugin_skill_md(home: Path, skill_dir_name: str) -> Path | None:
    """~/.hermes/plugins/<plugin>/skills/<skill-name>/SKILL.md"""
    plugins_root = home / ".hermes" / "plugins"
    if not plugins_root.is_dir():
        return None
    for plugin_dir in sorted(plugins_root.iterdir()):
        if not plugin_dir.is_dir():
            continue
        candidate = plugin_dir / "skills" / skill_dir_name / "SKILL.md"
        if candidate.is_file():
            return candidate
    return None


def locate_dependency() -> Path | None:
    """返回依赖 skill 的 SKILL.md 路径；未找到返回 None。"""
    home = Path.home()

    for skill_dir_name in _AUTH_SKILL_DIR_ALIASES:
        # A) 扁平布局：root/<skill_dir_name>/SKILL.md
        for root in candidate_skill_roots():
            target = root / skill_dir_name / "SKILL.md"
            if target.is_file():
                return target

        # B) Hermes：~/.hermes/skills/<category>/<skill_dir_name>/SKILL.md
        hermes_default = home / ".hermes" / "skills"
        found = _hermes_category_skill_md(hermes_default, skill_dir_name)
        if found is not None:
            return found

        # C) Hermes：显式 HERMES_SKILLS_HOME（若用户把 category 根指到别处）
        hsh = os.environ.get("HERMES_SKILLS_HOME")
        if hsh:
            found = _hermes_category_skill_md(Path(hsh).expanduser(), skill_dir_name)
            if found is not None:
                return found

        # D) Hermes 插件内 skills
        found = _hermes_plugin_skill_md(home, skill_dir_name)
        if found is not None:
            return found

    return None


def searched_locations_for_report() -> list[str]:
    """供 DEPENDENCY_MISSING 调试：列出已扫描的扁平根目录 + Hermes 特化路径。"""
    home = Path.home()
    out: list[str] = [str(p) for p in candidate_skill_roots()]
    out.append(str(home / ".hermes" / "skills"))
    out.append(str(home / ".hermes" / "plugins"))
    hsh = os.environ.get("HERMES_SKILLS_HOME")
    if hsh:
        out.append(str(Path(hsh).expanduser()))
    # 去重保序
    seen: set[str] = set()
    unique: list[str] = []
    for s in out:
        if s not in seen:
            seen.add(s)
            unique.append(s)
    return unique


def emit(as_json: bool, ok: bool, payload: dict) -> None:
    """统一输出格式。"""
    prefix = "DEPENDENCY_OK:" if ok else "DEPENDENCY_MISSING:"
    body = json.dumps(payload, ensure_ascii=False)
    if as_json:
        out = dict(payload)
        out["status"] = "ok" if ok else "missing"
        print(json.dumps(out, ensure_ascii=False, indent=2))
    print(f"{prefix} {body}", file=sys.stderr)


def main() -> None:
    parser = argparse.ArgumentParser(description="Check required dependency skill availability.")
    parser.add_argument("--json", action="store_true", help="Emit machine-readable JSON on stdout.")
    args = parser.parse_args()

    found = locate_dependency()

    if found is not None:
        emit(
            as_json=args.json,
            ok=True,
            payload={
                "skill": REQUIRED_SKILL,
                "skillMdPath": str(found),
            },
        )
        sys.exit(0)

    payload = {
        "missingSkill": REQUIRED_SKILL,
        "reason": (
            f"linkfox-amazon-store-pricing 依赖 `{REQUIRED_SKILL}`，"
            "但在常见 skill 安装路径下未找到其 SKILL.md。"
        ),
        "searchedRoots": searched_locations_for_report(),
        "suggestedActions": [
            f"If a skill installer tool is available (e.g. install_skill / skill marketplace MCP), invoke it to install '{REQUIRED_SKILL}' immediately.",
            "Otherwise, ask the user to install the skill from https://skill.linkfox.com/ and retry.",
            "On OpenClaw: ensure the dependency is under <workspace>/skills, ~/.openclaw/skills, or ~/.agents/skills; set OPENCLAW_WORKSPACE or OPENCLAW_SKILLS_DIR if installs are non-default.",
            "On Hermes Agent: ensure the dependency is under ~/.hermes/skills/<category>/ or a plugin skills/ folder; for external_dirs from config.yaml, export HERMES_SKILLS_EXTERNAL_DIRS with OS path separators.",
            "Do NOT bypass the dependency by calling /spApi/authorizeUrl or /spApi/storeTokens directly from this skill.",
        ],
        "marketplaceUrl": "https://skill.linkfox.com/",
    }
    emit(as_json=args.json, ok=False, payload=payload)
    sys.exit(DEPENDENCY_EXIT_CODE)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Amazon Store — getCompetitivePricing (SP-API Product Pricing v0)
================================================================

通过 LinkFox 店铺网关 **POST /spApi/developerProxy** 转发 **GET getCompetitivePricing**，
与 `get_pricing.py` 使用同一套代理接口。

官方参考: https://developer-docs.amazon.com/sp-api/reference/getcompetitivepricing

Usage:
  python get_competitive_pricing.py '{
    "sellerId": "A1BCDEFGHIJK2",
    "region": "NA",
    "marketplaceId": "ATVPDKIKX0DER",
    "itemType": "Asin",
    "asins": ["B08N5WRWNW"]
  }'

Optional JSON fields:
  - customerType: Consumer | Business（默认 Consumer，不传则由上游决定）
  - marketplaceIds: 若提供数组则仅取第一个作为 MarketplaceId
  - skipDepCheck: boolean
"""

from __future__ import annotations

from typing import List, Optional

import json
import os
import subprocess
import sys
from pathlib import Path
from urllib.parse import quote
from urllib.request import Request, urlopen
from urllib.error import HTTPError, URLError

COMPETITIVE_PRICE_PATH = "products/pricing/v0/competitivePrice"
MAX_IDENTIFIERS = 20

API_BASE_URL = os.environ.get("STORE_API_BASE_URL") or os.environ.get(
    "SPAPI_BASE_URL", "https://tool-gateway.linkfox.com"
)
STORE_TOKENS_ENDPOINT = f"{API_BASE_URL.rstrip('/')}/spApi/storeTokens"
DEVELOPER_PROXY_ENDPOINT = f"{API_BASE_URL.rstrip('/')}/spApi/developerProxy"

REQUIRED_SKILL = "linkfox-amazon-store-auth"
DEPENDENCY_EXIT_CODE = 42


def ensure_auth_skill_available() -> None:
    here = Path(__file__).resolve().parent
    checker = here / "check_auth_dependency.py"
    if not checker.exists():
        payload = {
            "missingSkill": REQUIRED_SKILL,
            "reason": "check_auth_dependency.py not found next to get_competitive_pricing.py",
        }
        print(f"DEPENDENCY_MISSING: {json.dumps(payload, ensure_ascii=False)}", file=sys.stderr)
        sys.exit(DEPENDENCY_EXIT_CODE)
    try:
        result = subprocess.run(
            [sys.executable, str(checker)],
            capture_output=True,
            text=True,
            timeout=10,
        )
    except Exception as exc:  # pragma: no cover
        payload = {"missingSkill": REQUIRED_SKILL, "reason": str(exc)}
        print(f"DEPENDENCY_MISSING: {json.dumps(payload, ensure_ascii=False)}", file=sys.stderr)
        sys.exit(DEPENDENCY_EXIT_CODE)
    if result.stderr:
        sys.stderr.write(result.stderr)
        if not result.stderr.endswith("\n"):
            sys.stderr.write("\n")
    if result.returncode != 0:
        sys.exit(DEPENDENCY_EXIT_CODE)


def get_api_key() -> str:
    key = os.environ.get("LINKFOXAGENT_API_KEY")
    if not key:
        print(
            "API Key not configured. Set:\n  export LINKFOXAGENT_API_KEY=<your-key>",
            file=sys.stderr,
        )
        sys.exit(1)
    return key


def call_api(endpoint: str, params: dict) -> dict:
    api_key = get_api_key()
    data = json.dumps(params).encode("utf-8")
    req = Request(
        endpoint,
        data=data,
        headers={
            "Authorization": api_key,
            "Content-Type": "application/json",
            "User-Agent": "LinkFox-Skill/1.0",
        },
        method="POST",
    )
    try:
        with urlopen(req, timeout=60) as response:
            return json.loads(response.read().decode("utf-8"))
    except HTTPError as e:
        body = e.read().decode("utf-8") if e.fp else ""
        return {"error": f"HTTP {e.code}: {e.reason}", "details": body}
    except URLError as e:
        return {"error": f"Connection failed: {e.reason}"}


def get_store_tokens(seller_id: str, region: str) -> dict:
    return call_api(STORE_TOKENS_ENDPOINT, {"sellerId": seller_id, "region": region})


def developer_proxy_get(
    region: str,
    path: str,
    access_token: str,
    query_string: Optional[str] = None,
) -> dict:
    params: dict = {
        "region": region,
        "path": path,
        "method": "GET",
        "amzAccessToken": access_token,
    }
    if query_string:
        params["queryString"] = query_string
    return call_api(DEVELOPER_PROXY_ENDPOINT, params)


def _normalize_id_list(raw: object, field_name: str) -> List[str]:
    if raw is None:
        return []
    if isinstance(raw, str):
        s = raw.strip()
        return [s] if s else []
    if isinstance(raw, list):
        return [str(x).strip() for x in raw if str(x).strip()]
    print(f"{field_name} must be a string or array of strings", file=sys.stderr)
    sys.exit(1)


def _build_query_string(
    marketplace_id: str,
    item_type: str,
    asins: List[str],
    skus: List[str],
    customer_type: Optional[str],
) -> str:
    parts: list[str] = [
        f"MarketplaceId={quote(marketplace_id, safe='')}",
        f"ItemType={quote(item_type, safe='')}",
    ]
    it = item_type.strip()
    if it == "Asin":
        for a in asins[:MAX_IDENTIFIERS]:
            parts.append(f"Asins={quote(a, safe='')}")
    elif it == "Sku":
        for s in skus[:MAX_IDENTIFIERS]:
            parts.append(f"Skus={quote(s, safe='')}")
    else:
        raise ValueError('itemType must be "Asin" or "Sku" (case-sensitive per Amazon)')
    if customer_type:
        parts.append(f"CustomerType={quote(customer_type.strip(), safe='')}")
    return "&".join(parts)


def main() -> None:
    if len(sys.argv) < 2:
        print(
            "Usage: get_competitive_pricing.py '<JSON>'\n"
            "Required: sellerId, region, marketplaceId (or marketplaceIds[0]), "
            'itemType ("Asin"|"Sku"), and asins[] or skus[] (1..20 ids).\n'
            "Example: get_competitive_pricing.py "
            '\'{"sellerId":"A1...","region":"NA","marketplaceId":"ATVPDKIKX0DER",'
            '"itemType":"Asin","asins":["B0XXXXXXXX"]}\'',
            file=sys.stderr,
        )
        sys.exit(1)
    try:
        params = json.loads(sys.argv[1])
    except json.JSONDecodeError as e:
        print(f"Invalid JSON: {e}", file=sys.stderr)
        sys.exit(1)

    if not params.get("skipDepCheck"):
        ensure_auth_skill_available()

    for f in ("sellerId", "region", "itemType"):
        if f not in params:
            print(f"Missing required field: {f}", file=sys.stderr)
            sys.exit(1)

    mid = params.get("marketplaceId")
    if mid is None and params.get("marketplaceIds") is not None:
        mids = params["marketplaceIds"]
        if isinstance(mids, list) and mids:
            mid = mids[0]
            if len(mids) > 1:
                print(
                    "⚠️  Warning: getCompetitivePricing expects a single MarketplaceId; "
                    "using first marketplaceIds only.",
                    file=sys.stderr,
                )
        elif isinstance(mids, str) and mids.strip():
            mid = mids.strip()
    if mid is None or (isinstance(mid, str) and not mid.strip()):
        print("Missing marketplaceId (or non-empty marketplaceIds)", file=sys.stderr)
        sys.exit(1)
    marketplace_id = str(mid).strip()

    seller_id = str(params["sellerId"])
    region = str(params["region"])
    item_type = str(params["itemType"]).strip()

    asins = _normalize_id_list(params.get("asins"), "asins")
    skus = _normalize_id_list(params.get("skus"), "skus")

    if item_type == "Asin":
        ids = asins
        if skus:
            print(
                "When itemType is Asin, do not pass skus (prefer asins only).",
                file=sys.stderr,
            )
    elif item_type == "Sku":
        ids = skus
        if asins:
            print(
                "When itemType is Sku, do not pass asins (prefer skus only).",
                file=sys.stderr,
            )
    else:
        ids = []

    if not ids:
        print("Provide non-empty asins (for ItemType Asin) or skus (for ItemType Sku).", file=sys.stderr)
        sys.exit(1)
    if len(ids) > MAX_IDENTIFIERS:
        print(f"At most {MAX_IDENTIFIERS} Asins or Skus per request.", file=sys.stderr)
        sys.exit(1)

    customer_type = params.get("customerType")
    if customer_type is not None:
        customer_type = str(customer_type)

    try:
        query_string = _build_query_string(
            marketplace_id,
            item_type,
            asins if item_type == "Asin" else [],
            skus if item_type == "Sku" else [],
            customer_type,
        )
    except ValueError as e:
        print(str(e), file=sys.stderr)
        sys.exit(1)

    path = COMPETITIVE_PRICE_PATH

    tokens = get_store_tokens(seller_id, region)
    if "error" in tokens or "accessToken" not in tokens:
        print(json.dumps(tokens, indent=2, ensure_ascii=False))
        sys.exit(1)

    access_token = tokens["accessToken"]
    proxy = developer_proxy_get(region, path, access_token, query_string)

    out: dict = {
        "developerProxy": proxy,
        "resolvedPath": path,
        "queryString": query_string,
    }
    if proxy.get("errcode") == 200 and proxy.get("httpStatus") == 200:
        body_raw = proxy.get("body") or "{}"
        try:
            out["competitivePricing"] = json.loads(body_raw)
        except json.JSONDecodeError:
            out["competitivePricing"] = None
            out["competitivePricingRaw"] = body_raw
    print(json.dumps(out, indent=2, ensure_ascii=False))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Amazon Store — getItemOffers (SP-API Product Pricing v0)
=========================================================

GET 单个 ASIN 在指定站点、成色下的低价报价类信息（以 Amazon 响应为准）。

官方参考: https://developer-docs.amazon.com/sp-api/reference/getitemoffers

Usage:
  python get_item_offers.py '{
    "sellerId": "A1BCDEFGHIJK2",
    "region": "NA",
    "asin": "B08N5WRWNW",
    "marketplaceId": "ATVPDKIKX0DER",
    "itemCondition": "New"
  }'

Optional: customerType (Consumer|Business), marketplaceIds, skipDepCheck
"""

from __future__ import annotations

import json
import sys
from typing import Optional

from urllib.parse import quote

from _spapi_pricing_common import (
    developer_proxy_get,
    ensure_auth_skill_available,
    get_store_tokens,
    resolve_marketplace_id,
)


def _path(asin: str) -> str:
    return f"products/pricing/v0/items/{quote(asin.strip(), safe='')}/offers"


def _query(mid: str, item_condition: str, customer_type: Optional[str]) -> str:
    parts = [
        f"MarketplaceId={quote(mid, safe='')}",
        f"ItemCondition={quote(item_condition.strip(), safe='')}",
    ]
    if customer_type:
        parts.append(f"CustomerType={quote(customer_type.strip(), safe='')}")
    return "&".join(parts)


def main() -> None:
    if len(sys.argv) < 2:
        print(
            "Usage: get_item_offers.py '<JSON>'\n"
            "Required: sellerId, region, asin, marketplaceId (or marketplaceIds[0]), "
            "itemCondition.\n"
            'Example: get_item_offers.py '
            '\'{"sellerId":"A1...","region":"NA","asin":"B0...","marketplaceId":"ATVPDKIKX0DER",'
            '"itemCondition":"New"}\'',
            file=sys.stderr,
        )
        sys.exit(1)
    try:
        params = json.loads(sys.argv[1])
    except json.JSONDecodeError as e:
        print(f"Invalid JSON: {e}", file=sys.stderr)
        sys.exit(1)

    if not params.get("skipDepCheck"):
        ensure_auth_skill_available("get_item_offers.py")

    for f in ("sellerId", "region", "asin", "itemCondition"):
        if f not in params:
            print(f"Missing required field: {f}", file=sys.stderr)
            sys.exit(1)

    try:
        marketplace_id = resolve_marketplace_id(params, "getItemOffers")
    except ValueError as e:
        print(str(e), file=sys.stderr)
        sys.exit(1)

    asin = str(params["asin"]).strip()
    if not asin:
        print("asin must be non-empty", file=sys.stderr)
        sys.exit(1)

    seller_id = str(params["sellerId"])
    region = str(params["region"])
    item_condition = str(params["itemCondition"])
    ct = params.get("customerType")
    if ct is not None:
        ct = str(ct)

    path = _path(asin)
    q = _query(marketplace_id, item_condition, ct)

    tokens = get_store_tokens(seller_id, region)
    if "error" in tokens or "accessToken" not in tokens:
        print(json.dumps(tokens, indent=2, ensure_ascii=False))
        sys.exit(1)

    proxy = developer_proxy_get(region, path, tokens["accessToken"], q)
    out: dict = {"developerProxy": proxy, "resolvedPath": path, "queryString": q}
    if proxy.get("errcode") == 200 and proxy.get("httpStatus") == 200:
        raw = proxy.get("body") or "{}"
        try:
            out["itemOffers"] = json.loads(raw)
        except json.JSONDecodeError:
            out["itemOffers"] = None
            out["itemOffersRaw"] = raw
    print(json.dumps(out, indent=2, ensure_ascii=False))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Amazon Store — getListingOffers (SP-API Product Pricing v0)
===========================================================

通过 LinkFox 店铺网关 **POST /spApi/developerProxy** 转发 **GET getListingOffers**，
返回**单个**卖家 SKU 在指定站点、指定成色下的最低报价类信息（以 Amazon 响应为准）。

官方参考: https://developer-docs.amazon.com/sp-api/reference/getlistingoffers

Usage:
  python get_listing_offers.py '{
    "sellerId": "A1BCDEFGHIJK2",
    "region": "NA",
    "sku": "My-Seller-SKU-001",
    "marketplaceId": "ATVPDKIKX0DER",
    "itemCondition": "New"
  }'

Optional JSON fields:
  - customerType: Consumer | Business
  - marketplaceIds: 若提供数组则仅取第一个作为 MarketplaceId
  - skipDepCheck: boolean
"""

from __future__ import annotations

from typing import Optional

import json
import os
import subprocess
import sys
from pathlib import Path
from urllib.parse import quote
from urllib.request import Request, urlopen
from urllib.error import HTTPError, URLError

LISTING_OFFERS_PREFIX = "products/pricing/v0/listings"

API_BASE_URL = os.environ.get("STORE_API_BASE_URL") or os.environ.get(
    "SPAPI_BASE_URL", "https://tool-gateway.linkfox.com"
)
STORE_TOKENS_ENDPOINT = f"{API_BASE_URL.rstrip('/')}/spApi/storeTokens"
DEVELOPER_PROXY_ENDPOINT = f"{API_BASE_URL.rstrip('/')}/spApi/developerProxy"

REQUIRED_SKILL = "linkfox-amazon-store-auth"
DEPENDENCY_EXIT_CODE = 42


def ensure_auth_skill_available() -> None:
    here = Path(__file__).resolve().parent
    checker = here / "check_auth_dependency.py"
    if not checker.exists():
        payload = {
            "missingSkill": REQUIRED_SKILL,
            "reason": "check_auth_dependency.py not found next to get_listing_offers.py",
        }
        print(f"DEPENDENCY_MISSING: {json.dumps(payload, ensure_ascii=False)}", file=sys.stderr)
        sys.exit(DEPENDENCY_EXIT_CODE)
    try:
        result = subprocess.run(
            [sys.executable, str(checker)],
            capture_output=True,
            text=True,
            timeout=10,
        )
    except Exception as exc:  # pragma: no cover
        payload = {"missingSkill": REQUIRED_SKILL, "reason": str(exc)}
        print(f"DEPENDENCY_MISSING: {json.dumps(payload, ensure_ascii=False)}", file=sys.stderr)
        sys.exit(DEPENDENCY_EXIT_CODE)
    if result.stderr:
        sys.stderr.write(result.stderr)
        if not result.stderr.endswith("\n"):
            sys.stderr.write("\n")
    if result.returncode != 0:
        sys.exit(DEPENDENCY_EXIT_CODE)


def get_api_key() -> str:
    key = os.environ.get("LINKFOXAGENT_API_KEY")
    if not key:
        print(
            "API Key not configured. Set:\n  export LINKFOXAGENT_API_KEY=<your-key>",
            file=sys.stderr,
        )
        sys.exit(1)
    return key


def call_api(endpoint: str, params: dict) -> dict:
    api_key = get_api_key()
    data = json.dumps(params).encode("utf-8")
    req = Request(
        endpoint,
        data=data,
        headers={
            "Authorization": api_key,
            "Content-Type": "application/json",
            "User-Agent": "LinkFox-Skill/1.0",
        },
        method="POST",
    )
    try:
        with urlopen(req, timeout=60) as response:
            return json.loads(response.read().decode("utf-8"))
    except HTTPError as e:
        body = e.read().decode("utf-8") if e.fp else ""
        return {"error": f"HTTP {e.code}: {e.reason}", "details": body}
    except URLError as e:
        return {"error": f"Connection failed: {e.reason}"}


def get_store_tokens(seller_id: str, region: str) -> dict:
    return call_api(STORE_TOKENS_ENDPOINT, {"sellerId": seller_id, "region": region})


def developer_proxy_get(
    region: str,
    path: str,
    access_token: str,
    query_string: Optional[str] = None,
) -> dict:
    params: dict = {
        "region": region,
        "path": path,
        "method": "GET",
        "amzAccessToken": access_token,
    }
    if query_string:
        params["queryString"] = query_string
    return call_api(DEVELOPER_PROXY_ENDPOINT, params)


def _path_for_listing_offers(sku: str) -> str:
    enc_sku = quote(sku, safe="")
    return f"{LISTING_OFFERS_PREFIX}/{enc_sku}/offers"


def _build_query_string(
    marketplace_id: str,
    item_condition: str,
    customer_type: Optional[str],
) -> str:
    parts: list[str] = [
        f"MarketplaceId={quote(marketplace_id, safe='')}",
        f"ItemCondition={quote(item_condition.strip(), safe='')}",
    ]
    if customer_type:
        parts.append(f"CustomerType={quote(customer_type.strip(), safe='')}")
    return "&".join(parts)


def main() -> None:
    if len(sys.argv) < 2:
        print(
            "Usage: get_listing_offers.py '<JSON>'\n"
            "Required: sellerId, region, sku (seller SKU), marketplaceId (or marketplaceIds[0]), "
            "itemCondition (New|Used|Collectible|Refurbished|Club).\n"
            "Example: get_listing_offers.py "
            '\'{"sellerId":"A1...","region":"NA","sku":"MY-SKU","marketplaceId":"ATVPDKIKX0DER",'
            '"itemCondition":"New"}\'',
            file=sys.stderr,
        )
        sys.exit(1)
    try:
        params = json.loads(sys.argv[1])
    except json.JSONDecodeError as e:
        print(f"Invalid JSON: {e}", file=sys.stderr)
        sys.exit(1)

    if not params.get("skipDepCheck"):
        ensure_auth_skill_available()

    for f in ("sellerId", "region", "sku", "itemCondition"):
        if f not in params:
            print(f"Missing required field: {f}", file=sys.stderr)
            sys.exit(1)

    mid = params.get("marketplaceId")
    if mid is None and params.get("marketplaceIds") is not None:
        mids = params["marketplaceIds"]
        if isinstance(mids, list) and mids:
            mid = mids[0]
            if len(mids) > 1:
                print(
                    "⚠️  Warning: getListingOffers expects a single MarketplaceId; "
                    "using first marketplaceIds only.",
                    file=sys.stderr,
                )
        elif isinstance(mids, str) and mids.strip():
            mid = mids.strip()
    if mid is None or (isinstance(mid, str) and not mid.strip()):
        print("Missing marketplaceId (or non-empty marketplaceIds)", file=sys.stderr)
        sys.exit(1)
    marketplace_id = str(mid).strip()

    seller_id = str(params["sellerId"])
    region = str(params["region"])
    sku = str(params["sku"])
    if not sku.strip():
        print("sku must be non-empty", file=sys.stderr)
        sys.exit(1)

    item_condition = str(params["itemCondition"])
    customer_type = params.get("customerType")
    if customer_type is not None:
        customer_type = str(customer_type)

    query_string = _build_query_string(marketplace_id, item_condition, customer_type)
    path = _path_for_listing_offers(sku)

    tokens = get_store_tokens(seller_id, region)
    if "error" in tokens or "accessToken" not in tokens:
        print(json.dumps(tokens, indent=2, ensure_ascii=False))
        sys.exit(1)

    access_token = tokens["accessToken"]
    proxy = developer_proxy_get(region, path, access_token, query_string)

    out: dict = {
        "developerProxy": proxy,
        "resolvedPath": path,
        "queryString": query_string,
    }
    if proxy.get("errcode") == 200 and proxy.get("httpStatus") == 200:
        body_raw = proxy.get("body") or "{}"
        try:
            out["listingOffers"] = json.loads(body_raw)
        except json.JSONDecodeError:
            out["listingOffers"] = None
            out["listingOffersRaw"] = body_raw
    print(json.dumps(out, indent=2, ensure_ascii=False))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Amazon Store — getPricing (SP-API Product Pricing v0)
======================================================

通过 LinkFox 店铺网关 **POST /spApi/developerProxy** 转发 **GET getPricing**，
与 `linkfox-amazon-store-report` / `linkfox-amazon-store-listings` 使用同一套代理接口。

官方参考: https://developer-docs.amazon.com/sp-api/reference/getpricing

Usage:
  python get_pricing.py '{
    "sellerId": "A1BCDEFGHIJK2",
    "region": "NA",
    "marketplaceId": "ATVPDKIKX0DER",
    "itemType": "Asin",
    "asins": ["B08N5WRWNW"]
  }'

  # 按 SKU（最多 20 个）
  python get_pricing.py '{"sellerId":"...","region":"NA","marketplaceId":"ATVPDKIKX0DER","itemType":"Sku","skus":["MY-SKU-1"]}'

Optional JSON fields:
  - itemCondition: New | Used | Collectible | Refurbished | Club
  - offerType: B2C | B2B（默认 B2C，不传则由上游决定）
  - marketplaceIds: 若提供数组则仅取第一个作为 MarketplaceId（与 listing 系列脚本习惯一致）
  - skipDepCheck: boolean
"""

from __future__ import annotations

from typing import List, Optional

import json
import os
import subprocess
import sys
from pathlib import Path
from urllib.parse import quote
from urllib.request import Request, urlopen
from urllib.error import HTTPError, URLError

PRICING_PATH = "products/pricing/v0/price"
MAX_IDENTIFIERS = 20

API_BASE_URL = os.environ.get("STORE_API_BASE_URL") or os.environ.get(
    "SPAPI_BASE_URL", "https://tool-gateway.linkfox.com"
)
STORE_TOKENS_ENDPOINT = f"{API_BASE_URL.rstrip('/')}/spApi/storeTokens"
DEVELOPER_PROXY_ENDPOINT = f"{API_BASE_URL.rstrip('/')}/spApi/developerProxy"

REQUIRED_SKILL = "linkfox-amazon-store-auth"
DEPENDENCY_EXIT_CODE = 42


def ensure_auth_skill_available() -> None:
    here = Path(__file__).resolve().parent
    checker = here / "check_auth_dependency.py"
    if not checker.exists():
        payload = {
            "missingSkill": REQUIRED_SKILL,
            "reason": "check_auth_dependency.py not found next to get_pricing.py",
        }
        print(f"DEPENDENCY_MISSING: {json.dumps(payload, ensure_ascii=False)}", file=sys.stderr)
        sys.exit(DEPENDENCY_EXIT_CODE)
    try:
        result = subprocess.run(
            [sys.executable, str(checker)],
            capture_output=True,
            text=True,
            timeout=10,
        )
    except Exception as exc:  # pragma: no cover
        payload = {"missingSkill": REQUIRED_SKILL, "reason": str(exc)}
        print(f"DEPENDENCY_MISSING: {json.dumps(payload, ensure_ascii=False)}", file=sys.stderr)
        sys.exit(DEPENDENCY_EXIT_CODE)
    if result.stderr:
        sys.stderr.write(result.stderr)
        if not result.stderr.endswith("\n"):
            sys.stderr.write("\n")
    if result.returncode != 0:
        sys.exit(DEPENDENCY_EXIT_CODE)


def get_api_key() -> str:
    key = os.environ.get("LINKFOXAGENT_API_KEY")
    if not key:
        print(
            "API Key not configured. Set:\n  export LINKFOXAGENT_API_KEY=<your-key>",
            file=sys.stderr,
        )
        sys.exit(1)
    return key


def call_api(endpoint: str, params: dict) -> dict:
    api_key = get_api_key()
    data = json.dumps(params).encode("utf-8")
    req = Request(
        endpoint,
        data=data,
        headers={
            "Authorization": api_key,
            "Content-Type": "application/json",
            "User-Agent": "LinkFox-Skill/1.0",
        },
        method="POST",
    )
    try:
        with urlopen(req, timeout=60) as response:
            return json.loads(response.read().decode("utf-8"))
    except HTTPError as e:
        body = e.read().decode("utf-8") if e.fp else ""
        return {"error": f"HTTP {e.code}: {e.reason}", "details": body}
    except URLError as e:
        return {"error": f"Connection failed: {e.reason}"}


def get_store_tokens(seller_id: str, region: str) -> dict:
    return call_api(STORE_TOKENS_ENDPOINT, {"sellerId": seller_id, "region": region})


def developer_proxy_get(
    region: str,
    path: str,
    access_token: str,
    query_string: Optional[str] = None,
) -> dict:
    params: dict = {
        "region": region,
        "path": path,
        "method": "GET",
        "amzAccessToken": access_token,
    }
    if query_string:
        params["queryString"] = query_string
    return call_api(DEVELOPER_PROXY_ENDPOINT, params)


def _normalize_id_list(raw: object, field_name: str) -> List[str]:
    if raw is None:
        return []
    if isinstance(raw, str):
        s = raw.strip()
        return [s] if s else []
    if isinstance(raw, list):
        return [str(x).strip() for x in raw if str(x).strip()]
    print(f"{field_name} must be a string or array of strings", file=sys.stderr)
    sys.exit(1)


def _build_query_string(
    marketplace_id: str,
    item_type: str,
    asins: List[str],
    skus: List[str],
    item_condition: Optional[str],
    offer_type: Optional[str],
) -> str:
    parts: list[str] = [
        f"MarketplaceId={quote(marketplace_id, safe='')}",
        f"ItemType={quote(item_type, safe='')}",
    ]
    it = item_type.strip()
    if it == "Asin":
        for a in asins[:MAX_IDENTIFIERS]:
            parts.append(f"Asins={quote(a, safe='')}")
    elif it == "Sku":
        for s in skus[:MAX_IDENTIFIERS]:
            parts.append(f"Skus={quote(s, safe='')}")
    else:
        raise ValueError('itemType must be "Asin" or "Sku" (case-sensitive per Amazon)')
    if item_condition:
        parts.append(f"ItemCondition={quote(item_condition.strip(), safe='')}")
    if offer_type:
        parts.append(f"OfferType={quote(offer_type.strip(), safe='')}")
    return "&".join(parts)


def main() -> None:
    if len(sys.argv) < 2:
        print(
            "Usage: get_pricing.py '<JSON>'\n"
            "Required: sellerId, region, marketplaceId (or marketplaceIds[0]), "
            'itemType ("Asin"|"Sku"), and asins[] or skus[] (1..20 ids).\n'
            "Example: get_pricing.py "
            '\'{"sellerId":"A1...","region":"NA","marketplaceId":"ATVPDKIKX0DER",'
            '"itemType":"Asin","asins":["B0XXXXXXXX"]}\'',
            file=sys.stderr,
        )
        sys.exit(1)
    try:
        params = json.loads(sys.argv[1])
    except json.JSONDecodeError as e:
        print(f"Invalid JSON: {e}", file=sys.stderr)
        sys.exit(1)

    if not params.get("skipDepCheck"):
        ensure_auth_skill_available()

    for f in ("sellerId", "region", "itemType"):
        if f not in params:
            print(f"Missing required field: {f}", file=sys.stderr)
            sys.exit(1)

    mid = params.get("marketplaceId")
    if mid is None and params.get("marketplaceIds") is not None:
        mids = params["marketplaceIds"]
        if isinstance(mids, list) and mids:
            mid = mids[0]
            if len(mids) > 1:
                print(
                    "⚠️  Warning: getPricing expects a single MarketplaceId; using first marketplaceIds only.",
                    file=sys.stderr,
                )
        elif isinstance(mids, str) and mids.strip():
            mid = mids.strip()
    if mid is None or (isinstance(mid, str) and not mid.strip()):
        print("Missing marketplaceId (or non-empty marketplaceIds)", file=sys.stderr)
        sys.exit(1)
    marketplace_id = str(mid).strip()

    seller_id = str(params["sellerId"])
    region = str(params["region"])
    item_type = str(params["itemType"]).strip()

    asins = _normalize_id_list(params.get("asins"), "asins")
    skus = _normalize_id_list(params.get("skus"), "skus")

    if item_type == "Asin":
        ids = asins
        if skus:
            print("When itemType is Asin, do not pass skus (ignored if both set; prefer asins only).", file=sys.stderr)
    elif item_type == "Sku":
        ids = skus
        if asins:
            print("When itemType is Sku, do not pass asins (ignored if both set; prefer skus only).", file=sys.stderr)
    else:
        ids = []

    if not ids:
        print("Provide non-empty asins (for ItemType Asin) or skus (for ItemType Sku).", file=sys.stderr)
        sys.exit(1)
    if len(ids) > MAX_IDENTIFIERS:
        print(f"At most {MAX_IDENTIFIERS} Asins or Skus per request.", file=sys.stderr)
        sys.exit(1)

    item_condition = params.get("itemCondition")
    if item_condition is not None:
        item_condition = str(item_condition)
    offer_type = params.get("offerType")
    if offer_type is not None:
        offer_type = str(offer_type)

    try:
        query_string = _build_query_string(
            marketplace_id,
            item_type,
            asins if item_type == "Asin" else [],
            skus if item_type == "Sku" else [],
            item_condition,
            offer_type,
        )
    except ValueError as e:
        print(str(e), file=sys.stderr)
        sys.exit(1)

    path = PRICING_PATH

    tokens = get_store_tokens(seller_id, region)
    if "error" in tokens or "accessToken" not in tokens:
        print(json.dumps(tokens, indent=2, ensure_ascii=False))
        sys.exit(1)

    access_token = tokens["accessToken"]
    proxy = developer_proxy_get(region, path, access_token, query_string)

    out: dict = {
        "developerProxy": proxy,
        "resolvedPath": path,
        "queryString": query_string,
    }
    if proxy.get("errcode") == 200 and proxy.get("httpStatus") == 200:
        body_raw = proxy.get("body") or "{}"
        try:
            out["pricing"] = json.loads(body_raw)
        except json.JSONDecodeError:
            out["pricing"] = None
            out["pricingRaw"] = body_raw
    print(json.dumps(out, indent=2, ensure_ascii=False))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Amazon Store — getCompetitiveSummary (Product Pricing 2022-05-01)
=================================================================

POST competitiveSummary 批量接口（每批 1～20 条子请求）。

官方参考: https://developer-docs.amazon.com/sp-api/reference/getcompetitivesummary

JSON 入参（简化）:
  sellerId, region,
  requests: [
    {
      "asin", "marketplaceId",
      "includedData": ["featuredBuyingOptions", ...],
      "lowestPricedOffersInputs": [...]   // 可选，仅当 includedData 含 lowestPricedOffers 时需要
    }, ...
  ]

可选 useAmazonRequestShape: true — requests 为 Amazon 完整子请求（须含 uri、method 等）。
"""

from __future__ import annotations

import json
import sys

from _spapi_pricing_common import (
    developer_proxy_post_json,
    ensure_auth_skill_available,
    get_store_tokens,
)

PATH_BATCH = "batches/products/pricing/2022-05-01/items/competitiveSummary"
URI_SUB = "/products/pricing/2022-05-01/items/competitiveSummary"
MAX_REQUESTS = 20


def _expand_simple(req: dict) -> dict:
    asin = str(req.get("asin") or "").strip()
    mid = str(req.get("marketplaceId") or "").strip()
    if not asin or not mid:
        raise ValueError("each request needs asin and marketplaceId")
    inc = req.get("includedData")
    if not isinstance(inc, list) or not inc:
        raise ValueError("each request needs includedData (non-empty array of strings)")
    out: dict = {
        "uri": URI_SUB,
        "method": "POST",
        "asin": asin,
        "marketplaceId": mid,
        "includedData": inc,
    }
    if "lowestPricedOffersInputs" in req:
        out["lowestPricedOffersInputs"] = req["lowestPricedOffersInputs"]
    return out


def main() -> None:
    if len(sys.argv) < 2:
        print(
            "Usage: post_competitive_summary_batch.py '<JSON>'\n"
            f"Required: sellerId, region, requests (1..{MAX_REQUESTS}).\n"
            "Each item: asin, marketplaceId, includedData [, lowestPricedOffersInputs].",
            file=sys.stderr,
        )
        sys.exit(1)
    try:
        params = json.loads(sys.argv[1])
    except json.JSONDecodeError as e:
        print(f"Invalid JSON: {e}", file=sys.stderr)
        sys.exit(1)

    if not params.get("skipDepCheck"):
        ensure_auth_skill_available("post_competitive_summary_batch.py")

    for f in ("sellerId", "region", "requests"):
        if f not in params:
            print(f"Missing required field: {f}", file=sys.stderr)
            sys.exit(1)

    raw = params["requests"]
    if not isinstance(raw, list) or not raw:
        print("requests must be a non-empty array", file=sys.stderr)
        sys.exit(1)
    if len(raw) > MAX_REQUESTS:
        print(f"At most {MAX_REQUESTS} batch sub-requests.", file=sys.stderr)
        sys.exit(1)

    use_amazon = bool(params.get("useAmazonRequestShape"))
    try:
        requests_out = raw if use_amazon else [_expand_simple(r) for r in raw]
    except (KeyError, ValueError) as e:
        print(str(e), file=sys.stderr)
        sys.exit(1)

    body_obj = {"requests": requests_out}
    seller_id = str(params["sellerId"])
    region = str(params["region"])

    tokens = get_store_tokens(seller_id, region)
    if "error" in tokens or "accessToken" not in tokens:
        print(json.dumps(tokens, indent=2, ensure_ascii=False))
        sys.exit(1)

    proxy = developer_proxy_post_json(region, PATH_BATCH, tokens["accessToken"], body_obj)
    out: dict = {
        "developerProxy": proxy,
        "resolvedPath": PATH_BATCH,
        "requestBody": body_obj,
    }
    if proxy.get("errcode") == 200 and proxy.get("httpStatus") == 200:
        br = proxy.get("body") or "{}"
        try:
            out["competitiveSummary"] = json.loads(br)
        except json.JSONDecodeError:
            out["competitiveSummary"] = None
            out["competitiveSummaryRaw"] = br
    print(json.dumps(out, indent=2, ensure_ascii=False))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Amazon Store — getFeaturedOfferExpectedPriceBatch (Product Pricing 2022-05-01)
==============================================================================

POST FOEP 批量接口（单批最多 40 条子请求，以 Amazon 文档为准）。

官方参考: https://developer-docs.amazon.com/sp-api/reference/getfeaturedofferexpectedpricebatch

JSON 入参（简化）:
  sellerId, region,
  requests: [ { "marketplaceId", "sku", "segment" }, ... ]

segment 须符合 SP-API 模型（地理/配送等），见官方文档。

可选 useAmazonRequestShape: true — requests 为 Amazon 完整子请求对象（含 uri、method 等）。
"""

from __future__ import annotations

import json
import sys

from _spapi_pricing_common import (
    developer_proxy_post_json,
    ensure_auth_skill_available,
    get_store_tokens,
)

PATH_BATCH = "batches/products/pricing/2022-05-01/offer/featuredOfferExpectedPrice"
URI_SUB = "/products/pricing/2022-05-01/offer/featuredOfferExpectedPrice"
MAX_REQUESTS = 40


def _expand_simple(req: dict) -> dict:
    mid = str(req.get("marketplaceId") or "").strip()
    sku = str(req.get("sku") or "").strip()
    if not mid or not sku:
        raise ValueError("each request needs marketplaceId and sku")
    if "segment" not in req or not isinstance(req["segment"], dict):
        raise ValueError("each request needs segment (object) per Amazon schema")
    return {
        "uri": URI_SUB,
        "method": "POST",
        "marketplaceId": mid,
        "sku": sku,
        "segment": req["segment"],
    }


def main() -> None:
    if len(sys.argv) < 2:
        print(
            "Usage: post_featured_offer_expected_price_batch.py '<JSON>'\n"
            f"Required: sellerId, region, requests (1..{MAX_REQUESTS}).\n"
            "Each item: marketplaceId, sku, segment (object).",
            file=sys.stderr,
        )
        sys.exit(1)
    try:
        params = json.loads(sys.argv[1])
    except json.JSONDecodeError as e:
        print(f"Invalid JSON: {e}", file=sys.stderr)
        sys.exit(1)

    if not params.get("skipDepCheck"):
        ensure_auth_skill_available("post_featured_offer_expected_price_batch.py")

    for f in ("sellerId", "region", "requests"):
        if f not in params:
            print(f"Missing required field: {f}", file=sys.stderr)
            sys.exit(1)

    raw = params["requests"]
    if not isinstance(raw, list) or not raw:
        print("requests must be a non-empty array", file=sys.stderr)
        sys.exit(1)
    if len(raw) > MAX_REQUESTS:
        print(f"At most {MAX_REQUESTS} batch sub-requests.", file=sys.stderr)
        sys.exit(1)

    use_amazon = bool(params.get("useAmazonRequestShape"))
    try:
        requests_out = raw if use_amazon else [_expand_simple(r) for r in raw]
    except (KeyError, ValueError) as e:
        print(str(e), file=sys.stderr)
        sys.exit(1)

    body_obj = {"requests": requests_out}
    seller_id = str(params["sellerId"])
    region = str(params["region"])

    tokens = get_store_tokens(seller_id, region)
    if "error" in tokens or "accessToken" not in tokens:
        print(json.dumps(tokens, indent=2, ensure_ascii=False))
        sys.exit(1)

    proxy = developer_proxy_post_json(region, PATH_BATCH, tokens["accessToken"], body_obj)
    out: dict = {
        "developerProxy": proxy,
        "resolvedPath": PATH_BATCH,
        "requestBody": body_obj,
    }
    if proxy.get("errcode") == 200 and proxy.get("httpStatus") == 200:
        br = proxy.get("body") or "{}"
        try:
            out["featuredOfferExpectedPriceBatch"] = json.loads(br)
        except json.JSONDecodeError:
            out["featuredOfferExpectedPriceBatch"] = None
            out["featuredOfferExpectedPriceBatchRaw"] = br
    print(json.dumps(out, indent=2, ensure_ascii=False))


if __name__ == "__main__":
    main()