"""
sp_api_client.py — SP-API 基础客户端封装
"""
import requests
import time
from datetime import datetime, timedelta

class SPAPIClient:
    """亚马逊 SP-API 统一客户端，自动处理 Token 刷新"""

    TOKEN_ENDPOINT = "https://api.amazon.com/auth/o2/token"
    BASE_URL = "https://sellingpartnerapi-na.amazon.com"  # 北美区

    def __init__(self, client_id: str, client_secret: str, refresh_token: str):
        self.client_id = client_id
        self.client_secret = client_secret
        self.refresh_token = refresh_token
        self._access_token = None
        self._token_expires_at = None

    def _refresh_access_token(self):
        """刷新 Access Token（有效期 1 小时）"""
        resp = requests.post(self.TOKEN_ENDPOINT, data={
            "grant_type": "refresh_token",
            "refresh_token": self.refresh_token,
            "client_id": self.client_id,
            "client_secret": self.client_secret,
        })
        resp.raise_for_status()
        data = resp.json()
        self._access_token = data["access_token"]
        # 提前 60 秒刷新，避免临界过期问题
        self._token_expires_at = datetime.utcnow() + timedelta(seconds=data["expires_in"] - 60)

    @property
    def access_token(self) -> str:
        if not self._access_token or datetime.utcnow() >= self._token_expires_at:
            self._refresh_access_token()
        return self._access_token

    def get(self, path: str, params: dict = None) -> dict:
        """发送 GET 请求，自动附加认证头，自动重试（最多 3 次）"""
        headers = {
            "x-amz-access-token": self.access_token,
            "Content-Type": "application/json",
        }
        for attempt in range(3):
            try:
                resp = requests.get(
                    f"{self.BASE_URL}{path}",
                    headers=headers,
                    params=params,
                    timeout=15
                )
                if resp.status_code == 429:
                    # 触发限流，等待后重试
                    wait = int(resp.headers.get("Retry-After", 5))
                    time.sleep(wait)
                    continue
                resp.raise_for_status()
                return resp.json()
            except requests.RequestException as e:
                if attempt == 2:
                    raise
                time.sleep(2 ** attempt)
        raise RuntimeError("SP-API 请求失败，已超过最大重试次数")


# ── 使用示例 ──────────────────────────────────────────
if __name__ == "__main__":
    client = SPAPIClient(
        client_id="amzn1.application-oa2-client.xxx",
        client_secret="your_client_secret",
        refresh_token="Atzr|xxx"
    )

    # 获取最近 7 天销售数据
    sales = client.get(
        path="/sales/v1/orderMetrics",
        params={
            "marketplaceIds": "ATVPDKIKX0DER",  # 美国站 ID
            "interval": f"{(datetime.utcnow() - timedelta(days=7)).strftime('%Y-%m-%dT00:00:00Z')}"
                        f"--{datetime.utcnow().strftime('%Y-%m-%dT00:00:00Z')}",
            "granularity": "Day",
        }
    )
    print(f"近7天订单数据：{sales}")

"""
pangolinfo_data_collector.py
将 Pangolinfo Scrape API 集成进亚马逊运营智能体的数据采集模块
"""
import requests
import json
import time
from datetime import datetime, timezone
from dataclasses import dataclass
from typing import Optional

PANGOLINFO_API_KEY = "your_pangolinfo_api_key"
API_BASE = "https://api.pangolinfo.com/v1/amazon"

HEADERS = {
    "Authorization": f"Bearer {PANGOLINFO_API_KEY}",
    "Content-Type": "application/json"
}


@dataclass
class CompetitorSnapshot:
    """竞品监控快照数据模型"""
    asin: str
    marketplace: str
    title: str
    price: float
    currency: str
    rating: float
    review_count: int
    bsr_rank: Optional[int]
    bsr_category: Optional[str]
    availability: str
    fetched_at: str


def fetch_competitor_detail(asin: str, marketplace: str = "amazon.com") -> Optional[CompetitorSnapshot]:
    """
    获取竞品 ASIN 的实时详情数据
    用于竞品监控智能体的感知层
    """
    payload = {
        "marketplace": marketplace,
        "type": "product_detail",
        "asin": asin
    }

    for attempt in range(3):
        try:
            resp = requests.post(
                f"{API_BASE}/product",
                headers=HEADERS,
                json=payload,
                timeout=30
            )
            resp.raise_for_status()
            data = resp.json()

            product = data.get("product", {})
            bsr = product.get("bestseller_ranks", [{}])[0] if product.get("bestseller_ranks") else {}

            return CompetitorSnapshot(
                asin=asin,
                marketplace=marketplace,
                title=product.get("title", "")[:120],
                price=float(product.get("price", 0) or 0),
                currency=product.get("currency", "USD"),
                rating=float(product.get("rating", 0) or 0),
                review_count=int(product.get("review_count", 0) or 0),
                bsr_rank=bsr.get("rank"),
                bsr_category=bsr.get("category"),
                availability=product.get("availability", "unknown"),
                fetched_at=datetime.now(timezone.utc).isoformat()
            )

        except requests.HTTPError as e:
            if e.response.status_code == 429:
                time.sleep(2 ** attempt + 1)
            else:
                print(f"[ERROR] HTTP {e.response.status_code} for ASIN {asin}: {e}")
                return None
        except Exception as e:
            print(f"[ERROR] {type(e).__name__} for {asin}: {e}")
            return None

    return None


def fetch_category_bsr_top20(category_node: str, marketplace: str = "amazon.com") -> list[dict]:
    """
    获取类目 BSR Top 20 数据
    用于选品智能体的市场扫描
    """
    payload = {
        "marketplace": marketplace,
        "type": "bestsellers",
        "category_id": category_node,
        "limit": 20
    }
    try:
        resp = requests.post(
            f"{API_BASE}/category/bestsellers",
            headers=HEADERS,
            json=payload,
            timeout=30
        )
        resp.raise_for_status()
        return resp.json().get("products", [])
    except Exception as e:
        print(f"[ERROR] BSR fetch failed: {e}")
        return []


def monitor_competitor_price_change(
    asin: str,
    previous_price: float,
    threshold_pct: float = 0.05,
    marketplace: str = "amazon.com"
) -> dict:
    """
    竞品价格异动检测
    如果价格变化超过阈值，触发预警

    Returns:
        dict 包含 is_alert, change_pct, current_price, action_suggestion
    """
    snapshot = fetch_competitor_detail(asin, marketplace)
    if not snapshot:
        return {"is_alert": False, "error": "数据获取失败"}

    if previous_price <= 0:
        return {"is_alert": False, "current_price": snapshot.price, "message": "首次采集，无变化基准"}

    change_pct = (snapshot.price - previous_price) / previous_price

    result = {
        "asin": asin,
        "marketplace": marketplace,
        "previous_price": previous_price,
        "current_price": snapshot.price,
        "change_pct": round(change_pct * 100, 2),
        "review_count": snapshot.review_count,
        "rating": snapshot.rating,
        "bsr_rank": snapshot.bsr_rank,
        "is_alert": abs(change_pct) >= threshold_pct,
        "fetched_at": snapshot.fetched_at
    }

    if result["is_alert"]:
        direction = "降价" if change_pct < 0 else "涨价"
        result["action_suggestion"] = (
            f"竞品 {asin} {direction} {abs(result['change_pct'])}%，"
            f"当前价格 ${snapshot.price:.2f}。"
            f"建议评估自身定价策略，必要时启动价格调整流程。"
        )

    return result


# ── 批量竞品监控入口 ─────────────────────────────────────────────
def run_competitor_monitoring(watchlist: list[dict]) -> list[dict]:
    """
    批量处理竞品监控列表
    watchlist: [{"asin": "B08XY1234", "last_price": 29.99, "marketplace": "amazon.com"}, ...]
    """
    alerts = []
    for item in watchlist:
        result = monitor_competitor_price_change(
            asin=item["asin"],
            previous_price=item.get("last_price", 0),
            marketplace=item.get("marketplace", "amazon.com")
        )
        if result.get("is_alert"):
            alerts.append(result)
            print(f"⚠️  价格预警：{result['action_suggestion']}")
        else:
            print(f"✅  {item['asin']} 价格稳定（当前 ${result.get('current_price', 'N/A')}）")

        time.sleep(0.5)  # 避免请求过于密集

    return alerts


if __name__ == "__main__":
    # 示例：监控 3 个核心竞品
    COMPETITOR_WATCHLIST = [
        {"asin": "B08XY12345", "last_price": 29.99, "marketplace": "amazon.com"},
        {"asin": "B09AB67890", "last_price": 34.50, "marketplace": "amazon.com"},
        {"asin": "B07CD24680", "last_price": 27.00, "marketplace": "amazon.co.uk"},
    ]

    print("=== 开始竞品监控巡检 ===")
    alerts = run_competitor_monitoring(COMPETITOR_WATCHLIST)
    print(f"\n本次巡检触发预警 {len(alerts)} 条，已写入告警队列。")

-- 竞品价格历史表
CREATE TABLE competitor_price_history (
    id              BIGSERIAL PRIMARY KEY,
    asin            VARCHAR(20) NOT NULL,
    marketplace     VARCHAR(20) NOT NULL,
    price           NUMERIC(10,2),
    rating          NUMERIC(3,2),
    review_count    INTEGER,
    bsr_rank        INTEGER,
    fetched_at      TIMESTAMPTZ NOT NULL DEFAULT NOW()
);
CREATE INDEX idx_competitor_asin_time ON competitor_price_history(asin, fetched_at DESC);

-- 广告操作日志表（智能体审计核心）
CREATE TABLE ad_agent_operation_log (
    id              BIGSERIAL PRIMARY KEY,
    operation_type  VARCHAR(50) NOT NULL,  -- bid_adjust / pause_keyword / budget_change
    campaign_id     VARCHAR(50),
    ad_group_id     VARCHAR(50),
    keyword_id      VARCHAR(50),
    before_value    JSONB,
    after_value     JSONB,
    trigger_reason  TEXT,
    llm_reasoning   TEXT,              -- LLM 的决策推理过程（可审计）
    execution_mode  VARCHAR(20),       -- auto / human_required
    executed_by     VARCHAR(50),       -- agent_v1 / human:alice
    executed_at     TIMESTAMPTZ DEFAULT NOW(),
    result_acos     NUMERIC(5,2),      -- 72小时后回填，用于效果评估
    result_checked_at TIMESTAMPTZ
);

-- 智能体任务调度表
CREATE TABLE agent_task_queue (
    id              BIGSERIAL PRIMARY KEY,
    agent_type      VARCHAR(50) NOT NULL,
    task_params     JSONB,
    priority        SMALLINT DEFAULT 5,
    status          VARCHAR(20) DEFAULT 'pending',
    created_at      TIMESTAMPTZ DEFAULT NOW(),
    started_at      TIMESTAMPTZ,
    finished_at     TIMESTAMPTZ,
    error_message   TEXT
);

"""
ad_acos_agent.py — 广告 ACoS 监控智能体 MVP 版本
功能：每小时获取广告数据 → 计算 ACoS → LLM 生成优化策略 → 自动执行或推送人工审核
"""
import os, json
from datetime import datetime, timezone
import anthropic

ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY")
ACOS_ALERT_THRESHOLD = 0.20
ACOS_TARGET = 0.15


def compute_keyword_acos(ad_data: list[dict]) -> list[dict]:
    analyzed = []
    for kw in ad_data:
        spend = float(kw.get("spend") or 0)
        sales = float(kw.get("attributedSales30d") or 0)
        clicks = int(kw.get("clicks") or 0)
        impressions = int(kw.get("impressions") or 0)
        acos = (spend / sales) if sales > 0 else 99.0
        analyzed.append({
            "keyword": kw.get("keywordText"),
            "keyword_id": kw.get("keywordId"),
            "spend": spend, "sales": sales,
            "acos": round(acos, 4),
            "ctr": round(clicks / impressions, 4) if impressions else 0,
            "is_alert": acos > ACOS_ALERT_THRESHOLD and spend > 5.0,
        })
    return analyzed


def generate_optimization_strategy(keyword_data: list[dict]) -> dict:
    client = anthropic.Anthropic(api_key=ANTHROPIC_API_KEY)
    alert_items = [k for k in keyword_data if k["is_alert"]]
    if not alert_items:
        return {"actions": [], "summary": "所有关键词 ACoS 均在目标范围内，无需调整。"}

    prompt = f"""你是亚马逊广告优化专家。分析以下超过目标 ACoS（{ACOS_TARGET*100:.0f}%）的关键词，给出操作建议。
数据：{json.dumps(alert_items, ensure_ascii=False)}
按如下 JSON 格式输出，只输出 JSON：
{{"actions":[{{"keyword":"..","keyword_id":"..","action":"reduce_bid|pause|add_negative",
"current_bid_adjustment_pct":-15,"reasoning":"..","confidence":0.85,"risk_level":"low|medium|high"}}],
"summary":"总结"}}"""

    resp = client.messages.create(model="claude-3-5-sonnet-20241022", max_tokens=1500,
                                  messages=[{"role": "user", "content": prompt}])
    try:
        return json.loads(resp.content[0].text)
    except Exception:
        return {"actions": [], "summary": "LLM 解析失败，请人工复核。"}


def execute_ad_operations(strategy: dict, dry_run: bool = True) -> list[dict]:
    results = []
    for action in strategy.get("actions", []):
        risk = action.get("risk_level", "medium")
        confidence = action.get("confidence", 0)
        needs_human = risk == "high" or confidence < 0.70
        mode = "human_required" if needs_human else "auto"

        if needs_human:
            print(f"⚠️  [人工审核] {action['keyword']}: {action['action']} (置信度{confidence:.0%})")
        elif not dry_run:
            print(f"✅  [自动执行] {action['keyword']}: {action['action']} {action.get('current_bid_adjustment_pct',0):+d}%")
        else:
            print(f"🔍  [模拟模式] {action['keyword']}: {action['action']} {action.get('current_bid_adjustment_pct',0):+d}%")

        results.append({"keyword": action.get("keyword"), "action": action.get("action"),
                        "execution_mode": mode, "dry_run": dry_run,
                        "executed_at": datetime.now(timezone.utc).isoformat()})
    return results


def run_acos_agent_cycle(ad_report_data: list[dict]) -> dict:
    print(f"\n[{datetime.now().strftime('%H:%M')}] ACoS 智能体运行中...")
    analysis = compute_keyword_acos(ad_report_data)
    alerts = sum(1 for k in analysis if k["is_alert"])
    strategy = generate_optimization_strategy(analysis)
    exec_log = execute_ad_operations(strategy, dry_run=True)  # 上线观察2周后改为False
    return {"keywords_analyzed": len(analysis), "alerts": alerts,
            "summary": strategy.get("summary"), "execution_log": exec_log}