import requests
import json
from typing import List, Dict, Optional
from datetime import datetime

class AmazonKeywordMonitor:
    """亚马逊关键词排名监控器"""
    
    def __init__(self, email: str, password: str):
        """
        初始化监控器
        
        Args:
            email: Pangolin账号邮箱
            password: 账号密码
        """
        self.base_url = "https://scrapeapi.pangolinfo.com"
        self.email = email
        self.password = password
        self.token = None
        
    def authenticate(self) -> bool:
        """执行API认证"""
        auth_url = f"{self.base_url}/api/v1/auth"
        
        payload = {
            "email": self.email,
            "password": self.password
        }
        
        try:
            response = requests.post(
                auth_url,
                json=payload,
                headers={"Content-Type": "application/json"},
                timeout=10
            )
            
            result = response.json()
            
            if result.get("code") == 0:
                self.token = result.get("data")
                print(f"✓ 认证成功！")
                return True
            else:
                print(f"✗ 认证失败：{result.get('message')}")
                return False
                
        except Exception as e:
            print(f"✗ 认证异常：{str(e)}")
            return False
    
    def get_headers(self) -> dict:
        """获取请求头"""
        if not self.token:
            raise ValueError("请先调用authenticate()进行认证")
        
        return {
            "Content-Type": "application/json",
            "Authorization": f"Bearer {self.token}"
        }

# 使用示例
monitor = AmazonKeywordMonitor(
    email="[email protected]",
    password="your_password"
)

if monitor.authenticate():
    print("监控器初始化完成！")

def search_keyword(self, keyword: str, page: int = 1, zipcode: str = "10041") -> List[Dict]:
    """
    搜索关键词获取产品列表
    
    Args:
        keyword: 搜索关键词
        page: 页码（1-3）
        zipcode: 邮编（用于获取特定地区的搜索结果）
        
    Returns:
        List[Dict]: 产品列表
    """
    # 构建搜索URL
    search_url = f"https://www.amazon.com/s?k={keyword}&page={page}"
    
    scrape_url = f"{self.base_url}/api/v1/scrape"
    
    payload = {
        "url": search_url,
        "parserName": "amzKeyword",
        "format": "json",
        "bizContext": {
            "zipcode": zipcode
        }
    }
    
    try:
        response = requests.post(
            scrape_url,
            json=payload,
            headers=self.get_headers(),
            timeout=30
        )
        
        result = response.json()
        
        if result.get("code") == 0:
            data = result.get("data", {})
            json_data = data.get("json", [{}])[0]
            
            if json_data.get("code") == 0:
                products = json_data.get("data", {}).get("results", [])
                print(f"✓ 成功获取关键词'{keyword}'第{page}页的{len(products)}个产品")
                return products
        
        return []
        
    except Exception as e:
        print(f"✗ 搜索失败：{str(e)}")
        return []

# 使用示例
products = monitor.search_keyword("wireless earbuds", page=1)
for idx, product in enumerate(products[:5], 1):
    print(f"{idx}. {product.get('title')[:50]}... - ASIN: {product.get('asin')}")

def find_asin_rank(
    self, 
    keyword: str, 
    target_asin: str, 
    max_pages: int = 3,
    include_sponsored: bool = False
) -> Optional[Dict]:
    """
    查找指定ASIN在关键词下的排名
    
    Args:
        keyword: 搜索关键词
        target_asin: 目标ASIN
        max_pages: 最多搜索页数
        include_sponsored: 是否包含广告位
        
    Returns:
        Optional[Dict]: 排名信息
    """
    organic_rank = None
    sponsored_rank = None
    
    for page in range(1, max_pages + 1):
        products = self.search_keyword(keyword, page)
        
        if not products:
            continue
        
        for idx, product in enumerate(products):
            asin = product.get('asin')
            is_sponsored = product.get('is_sponsored', False)
            
            if asin == target_asin:
                # 计算排名位置
                position = (page - 1) * 48 + idx + 1
                
                if is_sponsored and include_sponsored:
                    sponsored_rank = position
                elif not is_sponsored:
                    organic_rank = position
                    
                # 如果找到自然排名，可以提前返回
                if organic_rank:
                    break
        
        if organic_rank:
            break
    
    if organic_rank or sponsored_rank:
        return {
            'keyword': keyword,
            'asin': target_asin,
            'organic_rank': organic_rank,
            'sponsored_rank': sponsored_rank,
            'timestamp': datetime.now().isoformat(),
            'found': True
        }
    
    return {
        'keyword': keyword,
        'asin': target_asin,
        'organic_rank': None,
        'sponsored_rank': None,
        'timestamp': datetime.now().isoformat(),
        'found': False
    }

# 使用示例
rank_info = monitor.find_asin_rank(
    keyword="wireless earbuds",
    target_asin="B08N5WRWNW",
    max_pages=3
)

if rank_info['found']:
    print(f"✓ 找到排名！")
    print(f"  自然排名：第{rank_info['organic_rank']}位")
    if rank_info['sponsored_rank']:
        print(f"  广告排名：第{rank_info['sponsored_rank']}位")
else:
    print(f"✗ 未找到排名（前{3*48}位）")

import pandas as pd
from concurrent.futures import ThreadPoolExecutor, as_completed
import time

def batch_monitor_keywords(
    self,
    keyword_asin_pairs: List[Dict],
    max_workers: int = 3
) -> pd.DataFrame:
    """
    批量监控关键词排名
    
    Args:
        keyword_asin_pairs: 关键词-ASIN对列表
            格式: [{'keyword': 'xxx', 'asin': 'xxx'}, ...]
        max_workers: 最大并发数
        
    Returns:
        pd.DataFrame: 排名数据
    """
    results = []
    
    print(f"开始批量监控 {len(keyword_asin_pairs)} 个关键词...")
    start_time = time.time()
    
    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        # 提交任务
        future_to_pair = {
            executor.submit(
                self.find_asin_rank,
                pair['keyword'],
                pair['asin']
            ): pair
            for pair in keyword_asin_pairs
        }
        
        # 收集结果
        for future in as_completed(future_to_pair):
            pair = future_to_pair[future]
            try:
                rank_info = future.result()
                results.append(rank_info)
            except Exception as e:
                print(f"✗ 处理 {pair['keyword']} 时出错：{str(e)}")
    
    elapsed_time = time.time() - start_time
    
    # 转换为DataFrame
    df = pd.DataFrame(results)
    
    # 保存到CSV
    timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
    filename = f"data/ranking_{timestamp}.csv"
    df.to_csv(filename, index=False, encoding='utf-8-sig')
    
    print(f"\n✓ 批量监控完成！")
    print(f"  总数：{len(results)} 个")
    print(f"  找到排名：{df['found'].sum()} 个")
    print(f"  耗时：{elapsed_time:.2f} 秒")
    print(f"  数据已保存到：{filename}")
    
    return df

# 使用示例
keyword_asin_pairs = [
    {'keyword': 'wireless earbuds', 'asin': 'B08N5WRWNW'},
    {'keyword': 'bluetooth headphones', 'asin': 'B08N5WRWNW'},
    {'keyword': 'noise cancelling earbuds', 'asin': 'B08N5WRWNW'},
    {'keyword': 'sports earbuds', 'asin': 'B08N5WRWNW'},
    {'keyword': 'waterproof earbuds', 'asin': 'B08N5WRWNW'}
]

df_results = monitor.batch_monitor_keywords(keyword_asin_pairs, max_workers=3)

def detect_ranking_changes(
    self,
    current_file: str,
    previous_file: str,
    threshold: int = 5
) -> pd.DataFrame:
    """
    检测排名变化
    
    Args:
        current_file: 当前排名数据文件
        previous_file: 历史排名数据文件
        threshold: 预警阈值（排名变化超过此值触发预警）
        
    Returns:
        pd.DataFrame: 变化分析结果
    """
    # 加载数据
    current_df = pd.read_csv(current_file)
    previous_df = pd.read_csv(previous_file)
    
    # 合并数据
    merged = current_df.merge(
        previous_df,
        on=['keyword', 'asin'],
        suffixes=('_current', '_previous')
    )
    
    # 计算排名变化
    merged['rank_change'] = merged['organic_rank_previous'] - merged['organic_rank_current']
    merged['rank_change_percent'] = (
        merged['rank_change'] / merged['organic_rank_previous'] * 100
    ).round(2)
    
    # 识别显著变化
    merged['alert'] = abs(merged['rank_change']) >= threshold
    
    # 分类
    merged['status'] = merged.apply(
        lambda row: '📈 上升' if row['rank_change'] > 0 
        else ('📉 下降' if row['rank_change'] < 0 else '➡️ 不变'),
        axis=1
    )
    
    # 生成报告
    print("\n" + "="*60)
    print("关键词排名变化报告")
    print(f"对比时间：{previous_df['timestamp'].iloc[0]} vs {current_df['timestamp'].iloc[0]}")
    print("="*60)
    
    # 显著上升
    rank_up = merged[merged['rank_change'] >= threshold].sort_values('rank_change', ascending=False)
    if len(rank_up) > 0:
        print(f"\n📈 排名显著上升 ({len(rank_up)}个)：")
        for _, row in rank_up.head(5).iterrows():
            print(f"  • {row['keyword']}")
            print(f"    {row['organic_rank_previous']} → {row['organic_rank_current']} (↑{row['rank_change']}位)")
    
    # 显著下降
    rank_down = merged[merged['rank_change'] <= -threshold].sort_values('rank_change')
    if len(rank_down) > 0:
        print(f"\n📉 排名显著下降 ({len(rank_down)}个) - ⚠️ 需要关注：")
        for _, row in rank_down.head(5).iterrows():
            print(f"  • {row['keyword']}")
            print(f"    {row['organic_rank_previous']} → {row['organic_rank_current']} (↓{abs(row['rank_change'])}位)")
    
    # 保存分析结果
    timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
    report_file = f"data/ranking_changes_{timestamp}.csv"
    merged.to_csv(report_file, index=False, encoding='utf-8-sig')
    
    print(f"\n✓ 分析报告已保存到：{report_file}")
    
    return merged

# 使用示例
changes = monitor.detect_ranking_changes(
    current_file="data/ranking_20260106_100000.csv",
    previous_file="data/ranking_20260105_100000.csv",
    threshold=5
)

# 监控配置
keyword_asin_pairs = [
    # 核心关键词
    {'keyword': 'wireless earbuds', 'asin': 'B08N5WRWNW'},
    {'keyword': 'bluetooth headphones', 'asin': 'B08N5WRWNW'},
    {'keyword': 'noise cancelling earbuds', 'asin': 'B08N5WRWNW'},
    # ... 更多关键词
]

# 每天早上8点和晚上8点执行
import schedule

def job():
    df = monitor.batch_monitor_keywords(keyword_asin_pairs)
    # 检测变化并发送预警
    if previous_file_exists():
        changes = monitor.detect_ranking_changes(current_file, previous_file)
        send_alert_if_needed(changes)

schedule.every().day.at("08:00").do(job)
schedule.every().day.at("20:00").do(job)

while True:
    schedule.run_pending()
    time.sleep(60)