from bs4 import BeautifulSoup

def extract_feature_bullets(html: str) -> list[str]:
    """
    提取亚马逊商品五点描述（Feature Bullets）
    同时支持标准布局和新版布局两种 DOM 结构
    """
    soup = BeautifulSoup(html, "lxml")
    bullets = []
    
    # 方案 A：标准布局（大多数品类）
    container = soup.select_one("#feature-bullets")
    if container:
        items = container.select("ul li span.a-list-item")
        bullets = [item.get_text(strip=True) for item in items if item.get_text(strip=True)]
    
    # 方案 B：新版布局 fallback（服饰/食品等品类）
    if not bullets:
        container = soup.select_one("#productFactsDesktopExpander")
        if container:
            items = container.select("li span.a-list-item")
            bullets = [item.get_text(strip=True) for item in items if item.get_text(strip=True)]
    
    # 过滤掉「Show more」等 UI 文本
    bullets = [b for b in bullets if len(b) > 5 and "show more" not in b.lower()]
    
    return bullets

def extract_aplus_content(html: str) -> dict:
    """
    提取 A+ 内容：同时返回原始 HTML 和纯文本两种格式
    """
    soup = BeautifulSoup(html, "lxml")
    result = {"has_aplus": False, "html": "", "text": ""}
    
    # 尝试新版和旧版容器
    aplus = soup.select_one("#aplus3p_feature_div") or soup.select_one("#aplus")
    
    if not aplus:
        return result
    
    result["has_aplus"] = True
    
    # 返回原始 HTML（保留富文本结构，用于 AI 训练数据）
    result["html"] = str(aplus)
    
    # 提取纯文本（剔除脚本、样式和图片）
    for tag in aplus.find_all(["script", "style", "img"]):
        tag.decompose()
    result["text"] = " ".join(aplus.get_text(separator=" ", strip=True).split())
    
    return result

def extract_tech_specs(html: str) -> dict:
    """
    提取产品技术规格，支持表格和列表两种布局
    """
    soup = BeautifulSoup(html, "lxml")
    specs = {}
    
    # 布局一：表格形式（3C、家电等品类）
    for table_id in ["productDetails_techSpec_section_1", "productDetails_techSpec_section_2",
                     "productDetails_detailBullets_sections1"]:
        table = soup.find(id=table_id)
        if table:
            for row in table.select("tr"):
                th = row.find("th")
                td = row.find("td")
                if th and td:
                    key = th.get_text(strip=True)
                    val = td.get_text(strip=True)
                    if key and val:
                        specs[key] = val
            if specs:
                return specs
    
    # 布局二：列表形式（多数通用品类）
    bullets_div = soup.find(id="detailBullets_feature_div")
    if bullets_div:
        for li in bullets_div.select("ul li"):
            spans = li.find_all("span", recursive=False)
            # 通常第一个 span 含规格名（带冒号），第二个含规格值
            if len(spans) >= 2:
                key = spans[0].get_text(strip=True).rstrip(":")
                val = spans[1].get_text(strip=True)
                if key and val:
                    specs[key] = val
    
    return specs

# 克隆 Pangolinfo 开源解析仓库
git clone https://github.com/Pangolin-spg/amazon-walmart-shopify-scrape-api.git
cd amazon-walmart-shopify-scrape-api

# 安装 Go 依赖
go mod tidy

# 运行解析测试（针对本地 HTML 文件）
go test ./... -v

package parser

import (
    "strings"
    "golang.org/x/net/html"
)

// ProductDetail 亚马逊商品详情结构化数据
type ProductDetail struct {
    ASIN           string            `json:"asin"`
    Title          string            `json:"title"`
    Price          string            `json:"price"`
    Rating         string            `json:"rating"`
    ReviewCount    string            `json:"review_count"`
    FeatureBullets []string          `json:"feature_bullets"`
    TechSpecs      map[string]string `json:"tech_specs"`
    Description    string            `json:"description"`
    HasAPlus       bool              `json:"has_aplus"`
}

// ParseProductDetail 从 HTML 字符串解析商品详情
// 支持多版本 DOM 选择器，内置降级策略
func ParseProductDetail(htmlContent string) (*ProductDetail, error) {
    doc, err := html.Parse(strings.NewReader(htmlContent))
    if err != nil {
        return nil, err
    }
    
    product := &ProductDetail{
        TechSpecs:      make(map[string]string),
        FeatureBullets: []string{},
    }
    
    // 遍历 DOM 树，按 ID 精确定位各模块
    var traverse func(*html.Node)
    traverse = func(n *html.Node) {
        if n.Type == html.ElementNode {
            id := getAttr(n, "id")
            
            switch id {
            case "productTitle":
                product.Title = strings.TrimSpace(extractText(n))
            
            case "feature-bullets", "productFactsDesktopExpander":
                product.FeatureBullets = extractListItems(n)
            
            case "aplus", "aplus3p_feature_div":
                product.HasAPlus = true
                product.Description = extractText(n)
            
            case "productDescription":
                if product.Description == "" {
                    product.Description = strings.TrimSpace(extractText(n))
                }
            
            case "productDetails_techSpec_section_1",
                 "productDetails_techSpec_section_2":
                product.TechSpecs = mergeMaps(product.TechSpecs, extractTableSpecs(n))
            }
        }
        
        for c := n.FirstChild; c != nil; c = c.NextSibling {
            traverse(c)
        }
    }
    
    traverse(doc)
    return product, nil
}

// getAttr 获取 HTML 节点属性值
func getAttr(n *html.Node, key string) string {
    for _, attr := range n.Attr {
        if attr.Key == key {
            return attr.Val
        }
    }
    return ""
}

import requests
import json
from typing import Optional, Dict, Any

API_KEY = "your_pangolinfo_api_key"

def parse_amazon_product_html(asin: str, marketplace: str = "US") -> Optional[Dict[str, Any]]:
    """
    通过 Pangolinfo Scrape API 获取亚马逊商品描述的完整结构化数据。
    
    API 自动处理：
    - 多版本 DOM 结构适配（A+ 内容、标准描述、Tech Specs）
    - Feature Bullets 数组化返回
    - A+ 内容的 HTML 和纯文本双格式输出
    - 选择器失效后的自动降级策略
    
    Args:
        asin: Amazon 商品 ASIN
        marketplace: 站点代码（US/UK/DE/JP/CA 等）
    
    Returns:
        包含完整商品描述字段的字典，解析失败时返回 None
    """
    url = "https://api.pangolinfo.com/v1/amazon/product"
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    }
    
    payload = {
        "asin": asin,
        "marketplace": marketplace,
        # 指定解析模板：商品详情全量解析
        "parserName": "amzProductDetail",
        # 请求包含 HTML 格式的 A+ 内容（用于 AI 训练或富文本展示）
        "formats": ["json"],
        "fields": [
            "title",
            "feature_bullets",      # 五点描述，数组格式
            "description",          # 商品描述纯文本
            "aplus_content",        # A+ 内容（HTML + 纯文本）
            "tech_specs",           # 技术规格，键值对字典
            "has_aplus",            # 是否有 A+ 内容
            "product_overview",     # 产品概览（部分品类特有）
        ]
    }
    
    try:
        response = requests.post(url, headers=headers, json=payload, timeout=30)
        response.raise_for_status()
        data = response.json()
        
        product = data.get("data", {})
        
        # 输出结构化摘要
        print(f"ASIN: {asin}")
        print(f"标题: {product.get('title', 'N/A')[:60]}...")
        print(f"五点描述: {len(product.get('feature_bullets', []))} 条")
        print(f"A+ 内容: {'有' if product.get('has_aplus') else '无'}")
        print(f"技术规格: {len(product.get('tech_specs', {}))} 项")
        
        return product
        
    except requests.RequestException as e:
        print(f"[ERROR] {asin} 解析失败: {e}")
        return None


def batch_parse_descriptions(asins: list, marketplace: str = "US") -> list:
    """批量解析多个商品的描述字段"""
    import time
    results = []
    
    for i, asin in enumerate(asins, 1):
        print(f"\n[{i}/{len(asins)}] 解析 {asin}...")
        product = parse_amazon_product_html(asin, marketplace)
        if product:
            results.append({"asin": asin, **product})
        time.sleep(0.3)  # 控制请求频率
    
    return results


# 使用示例
if __name__ == "__main__":
    # 单商品解析
    product_data = parse_amazon_product_html("B08N5WRWNW", marketplace="US")
    
    if product_data:
        # 保存结果
        with open("parsed_product.json", "w", encoding="utf-8") as f:
            json.dump(product_data, f, ensure_ascii=False, indent=2)
        
        # 打印 Feature Bullets
        print("\nFeature Bullets:")
        for i, bullet in enumerate(product_data.get("feature_bullets", []), 1):
            print(f"  {i}. {bullet[:80]}...")
        
        # 打印 Tech Specs（前5项）
        print("\nTech Specs (前5项):")
        for k, v in list(product_data.get("tech_specs", {}).items())[:5]:
            print(f"  {k}: {v}")