import requests
import boto3
from datetime import datetime

class AmazonSPAPI:
    def __init__(self, refresh_token, client_id, client_secret, region):
        self.refresh_token = refresh_token
        self.client_id = client_id
        self.client_secret = client_secret
        self.region = region
        self.base_url = f"https://sellingpartnerapi-{region}.amazon.com"
        
    def get_access_token(self):
        """获取访问令牌"""
        url = "https://api.amazon.com/auth/o2/token"
        payload = {
            "grant_type": "refresh_token",
            "refresh_token": self.refresh_token,
            "client_id": self.client_id,
            "client_secret": self.client_secret
        }
        response = requests.post(url, data=payload)
        return response.json().get("access_token")
        
    def get_orders(self, marketplace_ids, created_after):
        """获取订单数据"""
        access_token = self.get_access_token()
        headers = {
            "x-amz-access-token": access_token,
            "Content-Type": "application/json"
        }
        params = {
            "MarketplaceIds": marketplace_ids,
            "CreatedAfter": created_after
        }
        
        url = f"{self.base_url}/orders/v0/orders"
        response = requests.get(url, headers=headers, params=params)
        return response.json()

# 使用示例
api = AmazonSPAPI(
    refresh_token="your_refresh_token",
    client_id="your_client_id", 
    client_secret="your_client_secret",
    region="na"
)

# 获取最近30天的订单
orders = api.get_orders(
    marketplace_ids=["ATVPDKIKX0DER"],  # 美国站点
    created_after="2024-01-01T00:00:00Z"
)

import scrapy
from scrapy import Request
import json
import re

class AmazonProductSpider(scrapy.Spider):
    name = 'amazon_products'
    allowed_domains = ['amazon.com']
    
    def __init__(self, asin_list=None, *args, **kwargs):
        super(AmazonProductSpider, self).__init__(*args, **kwargs)
        self.asin_list = asin_list.split(',') if asin_list else []
        
    def start_requests(self):
        headers = {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
            'Accept-Language': 'en-US,en;q=0.9',
            'Accept-Encoding': 'gzip, deflate, br',
            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
            'Connection': 'keep-alive',
            'Upgrade-Insecure-Requests': '1'
        }
        
        for asin in self.asin_list:
            url = f'https://www.amazon.com/dp/{asin}'
            yield Request(
                url=url, 
                headers=headers,
                callback=self.parse_product,
                meta={'asin': asin}
            )
    
    def parse_product(self, response):
        asin = response.meta['asin']
        
        # 产品标题
        title = response.xpath('//span[@id="productTitle"]/text()').get()
        if title:
            title = title.strip()
            
        # 价格信息
        price = response.xpath('//span[@class="a-price-whole"]/text()').get()
        if not price:
            price = response.xpath('//span[@id="priceblock_dealprice"]/text()').get()
            
        # 评分和评论数
        rating = response.xpath('//span[@class="a-icon-alt"]/text()').re_first(r'(\d+\.?\d*)')
        review_count = response.xpath('//span[@id="acrCustomerReviewText"]/text()').re_first(r'([\d,]+)')
        
        # 产品特性
        features = response.xpath('//div[@id="feature-bullets"]//span[@class="a-list-item"]/text()').getall()
        features = [f.strip() for f in features if f.strip() and not f.strip().startswith('Make sure')]
        
        # 产品描述
        description = response.xpath('//div[@id="productDescription"]//text()').getall()
        description = ' '.join([d.strip() for d in description if d.strip()])
        
        # 图片链接
        image_urls = []
        image_data = response.xpath('//script[contains(text(), "ImageBlockATF")]/text()').get()
        if image_data:
            try:
                # 解析JavaScript中的图片数据
                match = re.search(r'"colorImages":\s*({.*?})', image_data)
                if match:
                    color_images = json.loads(match.group(1))
                    for color, images in color_images.items():
                        for img in images:
                            if 'large' in img:
                                image_urls.append(img['large'])
            except:
                pass
        
        # 库存状态
        availability = response.xpath('//div[@id="availability"]//text()').getall()
        availability = ' '.join([a.strip() for a in availability if a.strip()])
        
        yield {
            'asin': asin,
            'title': title,
            'price': price,
            'rating': rating,
            'review_count': review_count,
            'features': features,
            'description': description,
            'image_urls': image_urls,
            'availability': availability,
            'url': response.url
        }

const puppeteer = require('puppeteer');
const fs = require('fs');

class AmazonScraper {
    constructor() {
        this.browser = null;
        this.page = null;
    }
    
    async initialize() {
        this.browser = await puppeteer.launch({
            headless: true,
            args: [
                '--no-sandbox',
                '--disable-setuid-sandbox',
                '--disable-dev-shm-usage',
                '--disable-accelerated-2d-canvas',
                '--no-first-run',
                '--no-zygote',
                '--disable-gpu'
            ]
        });
        
        this.page = await this.browser.newPage();
        
        // 设置用户代理
        await this.page.setUserAgent('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36');
        
        // 设置视口大小
        await this.page.setViewport({ width: 1366, height: 768 });
        
        // 拦截请求以加快加载速度
        await this.page.setRequestInterception(true);
        this.page.on('request', (req) => {
            if(req.resourceType() == 'stylesheet' || req.resourceType() == 'font' || req.resourceType() == 'image'){
                req.abort();
            } else {
                req.continue();
            }
        });
    }
    
    async scrapeProduct(asin) {
        try {
            const url = `https://www.amazon.com/dp/${asin}`;
            await this.page.goto(url, { waitUntil: 'networkidle2', timeout: 30000 });
            
            // 等待关键元素加载
            await this.page.waitForSelector('#productTitle', { timeout: 10000 });
            
            const productData = await this.page.evaluate(() => {
                const getTextContent = (selector) => {
                    const element = document.querySelector(selector);
                    return element ? element.textContent.trim() : null;
                };
                
                const getAllTextContent = (selector) => {
                    const elements = document.querySelectorAll(selector);
                    return Array.from(elements).map(el => el.textContent.trim()).filter(text => text);
                };
                
                return {
                    title: getTextContent('#productTitle'),
                    price: getTextContent('.a-price-whole') || getTextContent('#priceblock_dealprice'),
                    rating: getTextContent('.a-icon-alt'),
                    reviewCount: getTextContent('#acrCustomerReviewText'),
                    features: getAllTextContent('#feature-bullets .a-list-item'),
                    availability: getTextContent('#availability span')
                };
            });
            
            return { asin, ...productData, success: true };
            
        } catch (error) {
            console.error(`Error scraping ${asin}:`, error);
            return { asin, success: false, error: error.message };
        }
    }
    
    async close() {
        if (this.browser) {
            await this.browser.close();
        }
    }
}

// 使用示例
async function scrapeProducts(asins) {
    const scraper = new AmazonScraper();
    await scraper.initialize();
    
    const results = [];
    for (const asin of asins) {
        const data = await scraper.scrapeProduct(asin);
        results.push(data);
        
        // 添加随机延迟避免被检测
        await new Promise(resolve => setTimeout(resolve, Math.random() * 3000 + 2000));
    }
    
    await scraper.close();
    return results;
}

import numpy as np
import pandas as pd
from sklearn.linear_model import LinearRegression
from datetime import datetime, timedelta

class DynamicPricingModel:
    def __init__(self):
        self.price_elasticity = {}
        self.competitor_weights = {}
        self.inventory_thresholds = {}
        
    def calculate_price_elasticity(self, historical_data):
        """计算价格弹性系数"""
        for asin in historical_data['asin'].unique():
            asin_data = historical_data[historical_data['asin'] == asin]
            
            # 准备特征和标签
            X = asin_data[['price', 'competitor_avg_price', 'inventory_level']].values
            y = asin_data['sales_volume'].values
            
            # 训练线性回归模型
            model = LinearRegression()
            model.fit(X, y)
            
            # 计算价格弹性
            price_coef = model.coef_[0]
            self.price_elasticity[asin] = abs(price_coef)
            
    def optimize_price(self, asin, current_price, competitor_prices, inventory_level):
        """优化产品价格"""
        if asin not in self.price_elasticity:
            return current_price
            
        # 竞争对手价格加权平均
        competitor_avg = np.mean(competitor_prices)
        
        # 库存水位调整系数
        if inventory_level > 100:
            inventory_factor = 0.95  # 高库存时降价促销
        elif inventory_level < 20:
            inventory_factor = 1.05  # 低库存时适当提价
        else:
            inventory_factor = 1.0
            
        # 价格弹性调整
        elasticity = self.price_elasticity[asin]
        if elasticity > 1:  # 高弹性商品
            price_adjustment = 0.98
        else:  # 低弹性商品
            price_adjustment = 1.02
            
        # 综合计算最优价格
        base_price = competitor_avg * 0.98  # 略低于竞争对手
        optimized_price = base_price * inventory_factor * price_adjustment
        
        # 价格变动幅度限制
        max_change = current_price * 0.1  # 最大变动10%
        if abs(optimized_price - current_price) > max_change:
            if optimized_price > current_price:
                optimized_price = current_price + max_change
            else:
                optimized_price = current_price - max_change
                
        return round(optimized_price, 2)

# 爆款生命周期预测模型
class ProductLifecyclePrediction:
    def __init__(self):
        self.seasonal_factors = {}
        self.trend_models = {}
        
    def predict_lifecycle_stage(self, asin, sales_history):
        """预测产品生命周期阶段"""
        df = pd.DataFrame(sales_history)
        df['date'] = pd.to_datetime(df['date'])
        df = df.sort_values('date')
        
        # 计算移动平均
        df['ma_7'] = df['sales'].rolling(window=7).mean()
        df['ma_30'] = df['sales'].rolling(window=30).mean()
        
        # 计算增长率
        df['growth_rate'] = df['sales'].pct_change()
        
        # 季节性调整
        df['month'] = df['date'].dt.month
        monthly_avg = df.groupby('month')['sales'].mean()
        df['seasonal_factor'] = df['month'].map(monthly_avg) / monthly_avg.mean()
        df['adjusted_sales'] = df['sales'] / df['seasonal_factor']
        
        # 生命周期阶段判断
        recent_trend = df['adjusted_sales'].tail(30).diff().mean()
        growth_acceleration = df['growth_rate'].tail(10).mean()
        
        if growth_acceleration > 0.1 and recent_trend > 0:
            stage = "Growth"
        elif abs(growth_acceleration) < 0.05 and abs(recent_trend) < df['adjusted_sales'].std() * 0.1:
            stage = "Maturity"
        elif growth_acceleration < -0.1 or recent_trend < -df['adjusted_sales'].std() * 0.2:
            stage = "Decline"
        else:
            stage = "Introduction"
            
        return {
            'stage': stage,
            'confidence': min(len(df) / 90, 1.0),  # 数据充足度评分
            'trend_direction': 'Up' if recent_trend > 0 else 'Down',
            'seasonal_impact': df['seasonal_factor'].std()
        }

import requests
import random
import time
from itertools import cycle

class ProxyRotator:
    def __init__(self, proxy_list):
        self.proxy_cycle = cycle(proxy_list)
        self.failed_proxies = set()
        self.success_count = {}
        self.failure_count = {}
        
    def get_next_proxy(self):
        """获取下一个可用代理"""
        max_attempts = len(self.proxy_list) * 2
        attempts = 0
        
        while attempts < max_attempts:
            proxy = next(self.proxy_cycle)
            
            if proxy not in self.failed_proxies:
                return proxy
                
            attempts += 1
            
        # 如果所有代理都失败，重置失败列表
        self.failed_proxies.clear()
        return next(self.proxy_cycle)
        
    def test_proxy(self, proxy, test_url="http://httpbin.org/ip"):
        """测试代理可用性"""
        try:
            response = requests.get(
                test_url,
                proxies={'http': proxy, 'https': proxy},
                timeout=10
            )
            if response.status_code == 200:
                self.success_count[proxy] = self.success_count.get(proxy, 0) + 1
                if proxy in self.failed_proxies:
                    self.failed_proxies.remove(proxy)
                return True
        except:
            pass
            
        self.failure_count[proxy] = self.failure_count.get(proxy, 0) + 1
        if self.failure_count[proxy] >= 3:
            self.failed_proxies.add(proxy)
        return False
        
    def make_request(self, url, **kwargs):
        """使用代理发送请求"""
        max_retries = 3
        
        for attempt in range(max_retries):
            proxy = self.get_next_proxy()
            
            try:
                response = requests.get(
                    url,
                    proxies={'http': proxy, 'https': proxy},
                    timeout=15,
                    **kwargs
                )
                
                if response.status_code == 200:
                    self.success_count[proxy] = self.success_count.get(proxy, 0) + 1
                    return response
                    
            except Exception as e:
                self.failure_count[proxy] = self.failure_count.get(proxy, 0) + 1
                if self.failure_count[proxy] >= 3:
                    self.failed_proxies.add(proxy)
                    
                # 添加延迟避免过于频繁的请求
                time.sleep(random.uniform(1, 3))
                
        raise Exception(f"Failed to fetch {url} after {max_retries} attempts")

import pandas as pd
import numpy as np
from scipy import stats
import re

class DataQualityValidator:
    def __init__(self):
        self.price_bounds = {'min': 0.01, 'max': 10000}
        self.rating_bounds = {'min': 1.0, 'max': 5.0}
        self.review_patterns = {
            'fake_indicators': [
                r'amazing product', r'highly recommend', r'five stars',
                r'best purchase ever', r'exceeded expectations'
            ],
            'genuine_indicators': [
                r'specific use case', r'detailed experience', r'pros and cons',
                r'comparison with other products', r'usage duration'
            ]
        }
        
    def validate_price_data(self, df):
        """价格数据验证"""
        results = {}
        
        # 价格范围检查
        price_outliers = df[
            (df['price'] < self.price_bounds['min']) | 
            (df['price'] > self.price_bounds['max'])
        ]
        results['price_outliers'] = len(price_outliers)
        
        # 价格突变检查
        df_sorted = df.sort_values(['asin', 'date'])
        df_sorted['price_change'] = df_sorted.groupby('asin')['price'].pct_change()
        
        # 识别异常价格变化（超过50%的变动）
        abnormal_changes = df_sorted[abs(df_sorted['price_change']) > 0.5]
        results['abnormal_price_changes'] = len(abnormal_changes)
        
        # 统计分析
        results['price_stats'] = {
            'mean': df['price'].mean(),
            'median': df['price'].median(),
            'std': df['price'].std(),
            'cv': df['price'].std() / df['price'].mean()  # 变异系数
        }
        
        return results
        
    def validate_review_authenticity(self, reviews):
        """评论真实性验证"""
        authenticity_scores = []
        
        for review in reviews:
            score = 0
            text_length = len(review.split())
            
            # 长度评分（适中长度更可信）
            if 20 <= text_length <= 150:
                score += 2
            elif text_length < 10:
                score -= 2
                
            # 关键词模式匹配
            fake_matches = sum(1 for pattern in self.review_patterns['fake_indicators'] 
                             if re.search(pattern, review.lower()))
            genuine_matches = sum(1 for pattern in self.review_patterns['genuine_indicators'] 
                                if re.search(pattern, review.lower()))
            
            score += genuine_matches * 2 - fake_matches
            
            # 语言复杂度（词汇丰富度）
            words = review.lower().split()
            unique_words = len(set(words))
            if len(words) > 0:
                vocabulary_richness = unique_words / len(words)
                if vocabulary_richness > 0.7:
                    score += 1
                    
            authenticity_scores.append(max(0, min(10, score)))  # 限制在0-10范围
            
        return {
            'average_authenticity': np.mean(authenticity_scores),
            'low_quality_reviews': sum(1 for s in authenticity_scores if s < 3),
            'high_quality_reviews': sum(1 for s in authenticity_scores if s > 7)
        }
        
    def detect_data_anomalies(self, df):
        """综合数据异常检测"""
        anomalies = {}
        
        for column in df.select_dtypes(include=[np.number]).columns:
            # Z-score异常检测
            z_scores = np.abs(stats.zscore(df[column].dropna()))
            outliers = df[z_scores > 3]
            anomalies[f'{column}_outliers'] = len(outliers)
            
            # IQR方法异常检测
            Q1 = df[column].quantile(0.25)
            Q3 = df[column].quantile(0.75)
            IQR = Q3 - Q1
            lower_bound = Q1 - 1.5 * IQR
            upper_bound = Q3 + 1.5 * IQR
            
            iqr_outliers = df[(df[column] < lower_bound) | (df[column] > upper_bound)]
            anomalies[f'{column}_iqr_outliers'] = len(iqr_outliers)
            
        return anomalies

import boto3
import json
from collections import defaultdict

class ReviewSentimentAnalyzer:
    def __init__(self, region_name='us-east-1'):
        self.comprehend = boto3.client('comprehend', region_name=region_name)
        self.translate = boto3.client('translate', region_name=region_name)
        
    def analyze_batch_sentiment(self, reviews, target_language='en'):
        """批量情感分析"""
        results = []
        
        # 按语言分组处理
        language_groups = self.group_by_language(reviews)
        
        for language, texts in language_groups.items():
            if language != target_language:
                # 翻译为目标语言
                translated_texts = self.translate_texts(texts, language, target_language)
                analysis_texts = translated_texts
            else:
                analysis_texts = texts
                
            # 批量情感分析（每批最多25条）
            for i in range(0, len(analysis_texts), 25):
                batch = analysis_texts[i:i+25]
                
                try:
                    response = self.comprehend.batch_detect_sentiment(
                        TextList=batch,
                        LanguageCode=target_language
                    )
                    
                    for j, result in enumerate(response['ResultList']):
                        original_index = i + j
                        results.append({
                            'text': reviews[original_index],
                            'sentiment': result['Sentiment'],
                            'confidence': max(result['SentimentScore'].values()),
                            'scores': result['SentimentScore']
                        })
                        
                except Exception as e:
                    print(f"Error processing batch {i//25 + 1}: {e}")
                    
        return results
        
    def extract_key_phrases(self, text, language='en'):
        """提取关键短语"""
        try:
            response = self.comprehend.detect_key_phrases(
                Text=text,
                LanguageCode=language
            )
            
            key_phrases = [phrase['Text'] for phrase in response['KeyPhrases']
                          if phrase['Score'] > 0.8]
            return key_phrases
            
        except Exception as e:
            print(f"Error extracting key phrases: {e}")
            return []
            
    def analyze_product_feedback(self, reviews):
        """产品反馈分析"""
        sentiment_results = self.analyze_batch_sentiment(reviews)
        
        # 统计情感分布
        sentiment_distribution = defaultdict(int)
        feature_feedback = defaultdict(list)
        
        for result in sentiment_results:
            sentiment_distribution[result['sentiment']] += 1
            
            # 提取关键短语用于特征分析
            key_phrases = self.extract_key_phrases(result['text'])
            
            for phrase in key_phrases:
                feature_feedback[phrase].append({
                    'sentiment': result['sentiment'],
                    'confidence': result['confidence']
                })
                
        # 分析特征情感倾向
        feature_analysis = {}
        for feature, feedback_list in feature_feedback.items():
            if len(feedback_list) >= 3:  # 至少3次提及才纳入分析
                positive_count = sum(1 for f in feedback_list if f['sentiment'] == 'POSITIVE')
                negative_count = sum(1 for f in feedback_list if f['sentiment'] == 'NEGATIVE')
                
                feature_analysis[feature] = {
                    'total_mentions': len(feedback_list),
                    'positive_ratio': positive_count / len(feedback_list),
                    'negative_ratio': negative_count / len(feedback_list),
                    'avg_confidence': np.mean([f['confidence'] for f in feedback_list])
                }
                
        return {
            'sentiment_distribution': dict(sentiment_distribution),
            'feature_analysis': feature_analysis,
            'total_reviews': len(sentiment_results)
        }

# 知识图谱构建示例
import networkx as nx
import matplotlib.pyplot as plt
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity

class ProductKnowledgeGraph:
    def __init__(self):
        self.graph = nx.Graph()
        self.product_features = {}
        self.similarity_threshold = 0.3
        
    def build_graph_from_products(self, products_data):
        """从产品数据构建知识图谱"""
        # 添加产品节点
        for product in products_data:
            asin = product['asin']
            self.graph.add_node(asin, 
                              title=product['title'],
                              category=product.get('category', 'Unknown'),
                              price=product.get('price', 0),
                              rating=product.get('rating', 0),
                              node_type='product')
            
            # 提取产品特征
            features = self._extract_features(product)
            self.product_features[asin] = features
            
            # 添加特征节点和关系
            for feature in features:
                if not self.graph.has_node(feature):
                    self.graph.add_node(feature, node_type='feature')
                self.graph.add_edge(asin, feature, relation='has_feature')
                
        # 计算产品相似性并添加边
        self._add_similarity_edges()
        
    def _extract_features(self, product):
        """从产品信息中提取特征"""
        features = set()
        
        # 从标题中提取
        title_words = product['title'].lower().split()
        features.update([word for word in title_words if len(word) > 3])
        
        # 从特性列表中提取
        if 'features' in product:
            for feature_text in product['features']:
                words = feature_text.lower().split()
                features.update([word for word in words if len(word) > 3])
                
        # 从类目中提取
        if 'category' in product:
            category_words = product['category'].lower().split()
            features.update(category_words)
            
        return list(features)
        
    def _add_similarity_edges(self):
        """添加产品相似性边"""
        asins = [node for node in self.graph.nodes() 
                if self.graph.nodes[node].get('node_type') == 'product']
        
        # 构建特征向量
        feature_texts = []
        for asin in asins:
            features = self.product_features.get(asin, [])
            feature_texts.append(' '.join(features))
            
        # 计算TF-IDF相似性
        vectorizer = TfidfVectorizer(max_features=1000, stop_words='english')
        tfidf_matrix = vectorizer.fit_transform(feature_texts)
        similarity_matrix = cosine_similarity(tfidf_matrix)
        
        # 添加相似性边
        for i, asin1 in enumerate(asins):
            for j, asin2 in enumerate(asins):
                if i < j and similarity_matrix[i][j] > self.similarity_threshold:
                    self.graph.add_edge(asin1, asin2, 
                                      relation='similar_to',
                                      similarity=similarity_matrix[i][j])
                                      
    def get_recommendations(self, target_asin, top_n=5):
        """基于图结构的产品推荐"""
        recommendations = []
        
        if target_asin not in self.graph:
            return recommendations
            
        # 获取相似产品
        similar_products = []
        for neighbor in self.graph.neighbors(target_asin):
            if (self.graph.nodes[neighbor].get('node_type') == 'product' and
                self.graph.edges[target_asin, neighbor].get('relation') == 'similar_to'):
                similarity = self.graph.edges[target_asin, neighbor]['similarity']
                similar_products.append((neighbor, similarity))
                
        # 按相似度排序
        similar_products.sort(key=lambda x: x[1], reverse=True)
        
        return similar_products[:top_n]
        
    def analyze_market_structure(self):
        """分析市场结构"""
        # 计算网络指标
        metrics = {
            'total_products': len([n for n in self.graph.nodes() 
                                 if self.graph.nodes[n].get('node_type') == 'product']),
            'total_features': len([n for n in self.graph.nodes() 
                                 if self.graph.nodes[n].get('node_type') == 'feature']),
            'average_clustering': nx.average_clustering(self.graph),
            'density': nx.density(self.graph)
        }
        
        # 识别核心特征（连接度最高的特征节点）
        feature_centrality = {}
        for node in self.graph.nodes():
            if self.graph.nodes[node].get('node_type') == 'feature':
                centrality = nx.degree_centrality(self.graph)[node]
                feature_centrality[node] = centrality
                
        top_features = sorted(feature_centrality.items(), 
                            key=lambda x: x[1], reverse=True)[:10]
        
        metrics['top_features'] = top_features
        
        return metrics

import requests
import json
import time
import pandas as pd
from datetime import datetime, timedelta
import logging

class PangolinAmazonAPI:
    def __init__(self, api_key, base_url="https://api.pangolinfo.com/v1"):
        self.api_key = api_key
        self.base_url = base_url
        self.session = requests.Session()
        self.session.headers.update({
            'Authorization': f'Bearer {api_key}',
            'Content-Type': 'application/json',
            'User-Agent': 'PangolinClient/1.0'
        })
        
        # 设置日志
        logging.basicConfig(level=logging.INFO)
        self.logger = logging.getLogger(__name__)
        
    def get_product_details(self, asin, marketplace='US'):
        """获取产品详细信息"""
        endpoint = f"{self.base_url}/products/{asin}"
        params = {'marketplace': marketplace}
        
        try:
            response = self.session.get(endpoint, params=params)
            response.raise_for_status()
            
            data = response.json()
            return self._process_product_data(data)
            
        except requests.exceptions.RequestException as e:
            self.logger.error(f"Error fetching product {asin}: {e}")
            return None
            
    def search_products(self, keyword, marketplace='US', page=1, per_page=20):
        """按关键词搜索产品"""
        endpoint = f"{self.base_url}/search"
        params = {
            'keyword': keyword,
            'marketplace': marketplace,
            'page': page,
            'per_page': per_page
        }
        
        try:
            response = self.session.get(endpoint, params=params)
            response.raise_for_status()
            
            data = response.json()
            products = []
            
            for item in data.get('products', []):
                processed_item = self._process_product_data(item)
                if processed_item:
                    products.append(processed_item)
                    
            return {
                'products': products,
                'total_count': data.get('total_count', 0),
                'page': page,
                'has_next': data.get('has_next', False)
            }
            
        except requests.exceptions.RequestException as e:
            self.logger.error(f"Error searching for '{keyword}': {e}")
            return None
            
    def get_category_bestsellers(self, category_id, marketplace='US', top_n=100):
        """获取类目畅销榜"""
        endpoint = f"{self.base_url}/categories/{category_id}/bestsellers"
        params = {
            'marketplace': marketplace,
            'limit': top_n
        }
        
        try:
            response = self.session.get(endpoint, params=params)
            response.raise_for_status()
            
            data = response.json()
            bestsellers = []
            
            for item in data.get('bestsellers', []):
                processed_item = self._process_product_data(item)
                if processed_item:
                    processed_item['rank'] = item.get('rank')
                    bestsellers.append(processed_item)
                    
            return bestsellers
            
        except requests.exceptions.RequestException as e:
            self.logger.error(f"Error fetching bestsellers for category {category_id}: {e}")
            return None
            
    def batch_get_products(self, asin_list, marketplace='US', batch_size=50):
        """批量获取产品信息"""
        endpoint = f"{self.base_url}/products/batch"
        results = []
        
        for i in range(0, len(asin_list), batch_size):
            batch_asins = asin_list[i:i+batch_size]
            
            payload = {
                'asins': batch_asins,
                'marketplace': marketplace
            }
            
            try:
                response = self.session.post(endpoint, json=payload)
                response.raise_for_status()
                
                data = response.json()
                
                for asin, product_data in data.get('products', {}).items():
                    if product_data:
                        processed_data = self._process_product_data(product_data)
                        if processed_data:
                            results.append(processed_data)
                            
                # 添加延迟避免频率限制
                time.sleep(0.5)
                
            except requests.exceptions.RequestException as e:
                self.logger.error(f"Error in batch request: {e}")
                continue
                
        return results
        
    def get_price_history(self, asin, marketplace='US', days=30):
        """获取价格历史数据"""
        endpoint = f"{self.base_url}/products/{asin}/price-history"
        params = {
            'marketplace': marketplace,
            'days': days
        }
        
        try:
            response = self.session.get(endpoint, params=params)
            response.raise_for_status()
            
            data = response.json()
            price_history = []
            
            for entry in data.get('price_history', []):
                price_history.append({
                    'date': datetime.fromisoformat(entry['date']),
                    'price': float(entry['price']),
                    'currency': entry.get('currency', 'USD'),
                    'availability': entry.get('availability', 'Unknown')
                })
                
            return price_history
            
        except requests.exceptions.RequestException as e:
            self.logger.error(f"Error fetching price history for {asin}: {e}")
            return None
            
    def monitor_competitors(self, competitor_asins, marketplace='US'):
        """竞争对手监控"""
        monitoring_results = {}
        
        for asin in competitor_asins:
            product_data = self.get_product_details(asin, marketplace)
            price_history = self.get_price_history(asin, marketplace, days=7)
            
            if product_data and price_history:
                # 计算价格趋势
                prices = [p['price'] for p in price_history]
                price_trend = 'stable'
                
                if len(prices) > 1:
                    recent_change = (prices[-1] - prices[0]) / prices[0]
                    if recent_change > 0.05:
                        price_trend = 'increasing'
                    elif recent_change < -0.05:
                        price_trend = 'decreasing'
                        
                monitoring_results[asin] = {
                    'product_info': product_data,
                    'current_price': prices[-1] if prices else None,
                    'price_trend': price_trend,
                    'rank_change': self._calculate_rank_change(asin, marketplace),
                    'review_velocity': self._calculate_review_velocity(product_data),
                    'last_updated': datetime.now()
                }
                
        return monitoring_results
        
    def _process_product_data(self, raw_data):
        """处理原始产品数据"""
        if not raw_data:
            return None
            
        try:
            processed = {
                'asin': raw_data.get('asin'),
                'title': raw_data.get('title', '').strip(),
                'price': self._parse_price(raw_data.get('price')),
                'currency': raw_data.get('currency', 'USD'),
                'rating': float(raw_data.get('rating', 0)),
                'review_count': int(raw_data.get('review_count', 0)),
                'availability': raw_data.get('availability', 'Unknown'),
                'brand': raw_data.get('brand', '').strip(),
                'category': raw_data.get('category', ''),
                'features': raw_data.get('features', []),
                'images': raw_data.get('images', []),
                'variations': raw_data.get('variations', []),
                'qa_count': int(raw_data.get('qa_count', 0)),
                'bestseller_rank': raw_data.get('bestseller_rank'),
                'dimensions': raw_data.get('dimensions', {}),
                'weight': raw_data.get('weight'),
                'prime_eligible': raw_data.get('prime_eligible', False),
                'fba': raw_data.get('fba', False),
                'seller_info': raw_data.get('seller_info', {}),
                'last_updated': datetime.now()
            }
            
            return processed
            
        except Exception as e:
            self.logger.error(f"Error processing product data: {e}")
            return None
            
    def _parse_price(self, price_str):
        """解析价格字符串"""
        if not price_str:
            return 0.0
            
        # 移除货币符号和空格
        price_clean = re.sub(r'[^\d.,]', '', str(price_str))
        
        try:
            # 处理千位分隔符
            if ',' in price_clean and '.' in price_clean:
                if price_clean.rindex(',') > price_clean.rindex('.'):
                    # 欧洲格式：1.234,56
                    price_clean = price_clean.replace('.', '').replace(',', '.')
                else:
                    # 美国格式：1,234.56
                    price_clean = price_clean.replace(',', '')
            elif ',' in price_clean:
                # 只有逗号的情况
                if len(price_clean.split(',')[-1]) == 2:
                    # 欧洲格式：1234,56
                    price_clean = price_clean.replace(',', '.')
                else:
                    # 美国格式：1,234
                    price_clean = price_clean.replace(',', '')
                    
            return float(price_clean)
            
        except ValueError:
            return 0.0
            
    def _calculate_rank_change(self, asin, marketplace):
        """计算排名变化（需要历史数据支持）"""
        # 这里可以集成历史排名数据的对比逻辑
        return {'change': 0, 'direction': 'stable'}
        
    def _calculate_review_velocity(self, product_data):
        """计算评论增长速度"""
        # 基于评论数量和产品上架时间估算
        review_count = product_data.get('review_count', 0)
        # 这里可以添加更复杂的计算逻辑
        return {'daily_average': review_count / 365, 'trend': 'stable'}

# 实际应用示例
class AmazonMarketAnalyzer:
    def __init__(self, pangolin_api):
        self.api = pangolin_api
        
    def analyze_market_opportunity(self, keyword, target_price_range=(10, 100)):
        """分析市场机会"""
        search_results = self.api.search_products(keyword, per_page=100)
        
        if not search_results:
            return None
            
        products = search_results['products']
        
        # 过滤价格范围
        filtered_products = [
            p for p in products 
            if target_price_range[0] <= p['price'] <= target_price_range[1]
        ]
        
        # 分析竞争强度
        competition_analysis = {
            'total_products': len(filtered_products),
            'avg_rating': np.mean([p['rating'] for p in filtered_products if p['rating'] > 0]),
            'avg_review_count': np.mean([p['review_count'] for p in filtered_products]),
            'price_distribution': self._analyze_price_distribution(filtered_products),
            'top_brands': self._get_top_brands(filtered_products),
            'market_gaps': self._identify_market_gaps(filtered_products)
        }
        
        return {
            'keyword': keyword,
            'competition_analysis': competition_analysis,
            'opportunity_score': self._calculate_opportunity_score(competition_analysis),
            'recommendations': self._generate_recommendations(competition_analysis)
        }
        
    def _analyze_price_distribution(self, products):
        """分析价格分布"""
        prices = [p['price'] for p in products if p['price'] > 0]
        
        return {
            'min': min(prices) if prices else 0,
            'max': max(prices) if prices else 0,
            'median': np.median(prices) if prices else 0,
            'q1': np.percentile(prices, 25) if prices else 0,
            'q3': np.percentile(prices, 75) if prices else 0
        }
        
    def _get_top_brands(self, products, top_n=5):
        """获取主要品牌"""
        brand_count = {}
        for product in products:
            brand = product.get('brand', 'Unknown')
            if brand and brand != 'Unknown':
                brand_count[brand] = brand_count.get(brand, 0) + 1
                
        return sorted(brand_count.items(), key=lambda x: x[1], reverse=True)[:top_n]
        
    def _identify_market_gaps(self, products):
        """识别市场空白"""
        # 分析价格区间的产品密度
        price_ranges = [(0, 25), (25, 50), (50, 75), (75, 100), (100, 200)]
        gap_analysis = {}
        
        for low, high in price_ranges:
            range_products = [p for p in products if low <= p['price'] < high]
            gap_analysis[f'${low}-{high}'] = {
                'product_count': len(range_products),
                'avg_rating': np.mean([p['rating'] for p in range_products if p['rating'] > 0]) if range_products else 0,
                'competition_level': 'Low' if len(range_products) < 10 else 'High' if len(range_products) > 50 else 'Medium'
            }
            
        return gap_analysis
        
    def _calculate_opportunity_score(self, analysis):
        """计算市场机会评分"""
        score = 50  # 基础分
        
        # 竞争强度调整
        if analysis['total_products'] < 50:
            score += 20
        elif analysis['total_products'] > 200:
            score -= 20
            
        # 平均评分调整
        if analysis['avg_rating'] < 4.0:
            score += 15
        elif analysis['avg_rating'] > 4.5:
            score -= 10
            
        # 评论数调整
        if analysis['avg_review_count'] < 100:
            score += 10
        elif analysis['avg_review_count'] > 1000:
            score -= 15
            
        return max(0, min(100, score))
        
    def _generate_recommendations(self, analysis):
        """生成市场建议"""
        recommendations = []
        
        if analysis['total_products'] < 30:
            recommendations.append("市场竞争较小，适合快速进入")
            
        if analysis['avg_rating'] < 4.0:
            recommendations.append("现有产品评分较低，存在质量提升机会")
            
        # 分析价格空白
        for price_range, data in analysis['market_gaps'].items():
            if data['competition_level'] == 'Low' and data['product_count'] < 5:
                recommendations.append(f"价格区间{price_range}竞争较少，可考虑布局")
                
        return recommendations

# 使用示例
if __name__ == "__main__":
    # 初始化API客户端
    pangolin_api = PangolinAmazonAPI(api_key="your_api_key_here")
    
    # 创建市场分析器
    analyzer = AmazonMarketAnalyzer(pangolin_api)
    
    # 分析特定关键词的市场机会
    market_analysis = analyzer.analyze_market_opportunity("wireless earbuds", (20, 150))
    
    if market_analysis:
        print(f"关键词: {market_analysis['keyword']}")
        print(f"机会评分: {market_analysis['opportunity_score']}/100")
        print("市场建议:")
        for rec in market_analysis['recommendations']:
            print(f"  - {rec}")
    
    # 监控竞争对手
    competitor_asins = ["B08C7KG5LP", "B07SJR6HL3", "B0863TXGM3"]
    monitoring_results = pangolin_api.monitor_competitors(competitor_asins)
    
    for asin, data in monitoring_results.items():
        print(f"\n竞品 {asin}:")
        print(f"  当前价格: ${data['current_price']}")
        print(f"  价格趋势: {data['price_trend']}")
        print(f"  评分: {data['product_info']['rating']}")

class ComplianceManager:
    def __init__(self):
        self.data_retention_days = 90  # 数据保留期限
        self.rate_limits = {
            'product_details': 100,  # 每分钟最大请求数
            'search': 50,
            'batch': 20
        }
        self.forbidden_fields = [
            'buyer_name', 'buyer_email', 'buyer_phone',
            'order_id', 'payment_info', 'shipping_address'
        ]
        
    def validate_request(self, endpoint, params):
        """验证请求合规性"""
        # 检查请求频率
        if not self._check_rate_limit(endpoint):
            raise ComplianceError("Request rate limit exceeded")
            
        # 检查数据字段合规性
        if self._contains_forbidden_fields(params):
            raise ComplianceError("Request contains forbidden personal data fields")
            
        return True
        
    def sanitize_data(self, data):
        """数据脱敏处理"""
        if isinstance(data, dict):
            sanitized = {}
            for key, value in data.items():
                if key not in self.forbidden_fields:
                    if isinstance(value, (dict, list)):
                        sanitized[key] = self.sanitize_data(value)
                    else:
                        sanitized[key] = value
            return sanitized
        elif isinstance(data, list):
            return [self.sanitize_data(item) for item in data]
        else:
            return data
            
    def _check_rate_limit(self, endpoint):
        """检查请求频率限制"""
        # 实现请求频率检查逻辑
        return True
        
    def _contains_forbidden_fields(self, params):
        """检查是否包含禁止字段"""
        if isinstance(params, dict):
            return any(field in params for field in self.forbidden_fields)
        return False

class ComplianceError(Exception):
    pass

class MarketEntryAnalyzer:
    def __init__(self, pangolin_api):
        self.api = pangolin_api
        self.compliance_manager = ComplianceManager()
        
    def conduct_market_research(self, target_categories, target_countries=['US', 'UK', 'DE']):
        """执行全面市场调研"""
        research_results = {}
        
        for country in target_countries:
            country_results = {}
            
            for category in target_categories:
                # 获取类目畅销榜前100
                bestsellers = self.api.get_category_bestsellers(
                    category_id=category['id'],
                    marketplace=country,
                    top_n=100
                )
                
                if bestsellers:
                    # 深度分析类目数据
                    category_analysis = self._analyze_category_depth(
                        bestsellers, category['name'], country
                    )
                    country_results[category['name']] = category_analysis
                    
                # 添加延迟确保合规
                time.sleep(1)
                
            research_results[country] = country_results
            
        # 生成综合报告
        comprehensive_report = self._generate_market_report(research_results)
        
        return comprehensive_report
        
    def _analyze_category_depth(self, products, category_name, marketplace):
        """深度分析类目数据"""
        # 价格分布分析
        prices = [p['price'] for p in products if p['price'] > 0]
        price_analysis = {
            'price_ranges': self._calculate_price_ranges(prices),
            'avg_price': np.mean(prices) if prices else 0,
            'price_volatility': np.std(prices) if prices else 0
        }
        
        # 品牌集中度分析
        brand_distribution = {}
        for product in products:
            brand = product.get('brand', 'Unknown')
            brand_distribution[brand] = brand_distribution.get(brand, 0) + 1
            
        # 计算HHI指数（赫芬达尔-赫希曼指数）
        total_products = len(products)
        hhi = sum((count/total_products)**2 for count in brand_distribution.values()) * 10000
        
        # 评分质量分析
        ratings = [p['rating'] for p in products if p['rating'] > 0]
        quality_analysis = {
            'avg_rating': np.mean(ratings) if ratings else 0,
            'high_rated_ratio': len([r for r in ratings if r >= 4.5]) / len(ratings) if ratings else 0,
            'low_rated_ratio': len([r for r in ratings if r < 4.0]) / len(ratings) if ratings else 0
        }
        
        # 市场成熟度评估
        maturity_indicators = {
            'brand_concentration': 'High' if hhi > 2500 else 'Medium' if hhi > 1500 else 'Low',
            'avg_review_count': np.mean([p['review_count'] for p in products]),
            'new_entrant_potential': self._assess_new_entrant_potential(products)
        }
        
        return {
            'category': category_name,
            'marketplace': marketplace,
            'total_products_analyzed': len(products),
            'price_analysis': price_analysis,
            'brand_analysis': {
                'hhi_index': hhi,
                'top_brands': sorted(brand_distribution.items(), key=lambda x: x[1], reverse=True)[:10],
                'brand_diversity': len(brand_distribution)
            },
            'quality_analysis': quality_analysis,
            'maturity_indicators': maturity_indicators,
            'entry_barriers': self._identify_entry_barriers(products, price_analysis, brand_distribution)
        }
        
    def _calculate_price_ranges(self, prices):
        """计算价格区间分布"""
        if not prices:
            return {}
            
        ranges = [(0, 25), (25, 50), (50, 100), (100, 200), (200, float('inf'))]
        distribution = {}
        
        for low, high in ranges:
            count = len([p for p in prices if low <= p < high])
            range_name = f"${low}-{high}" if high != float('inf') else f"${low}+"
            distribution[range_name] = {
                'count': count,
                'percentage': (count / len(prices)) * 100
            }
            
        return distribution
        
    def _assess_new_entrant_potential(self, products):
        """评估新进入者潜力"""
        # 基于多个维度评估
        factors = {
            'low_review_products': len([p for p in products if p['review_count'] < 50]),
            'medium_rated_products': len([p for p in products if 3.5 <= p['rating'] < 4.5]),
            'price_gaps': self._identify_price_gaps(products),
            'feature_gaps': self._identify_feature_gaps(products)
        }
        
        # 计算综合潜力评分
        potential_score = 0
        if factors['low_review_products'] > len(products) * 0.3:
            potential_score += 25
        if factors['medium_rated_products'] > len(products) * 0.4:
            potential_score += 25
        if len(factors['price_gaps']) > 0:
            potential_score += 25
        if len(factors['feature_gaps']) > 0:
            potential_score += 25
            
        return {
            'score': potential_score,
            'level': 'High' if potential_score >= 75 else 'Medium' if potential_score >= 50 else 'Low',
            'factors': factors
        }
        
    def _identify_entry_barriers(self, products, price_analysis, brand_distribution):
        """识别进入壁垒"""
        barriers = []
        
        # 品牌壁垒
        top_brand_share = max(brand_distribution.values()) / len(products) if brand_distribution else 0
        if top_brand_share > 0.3:
            barriers.append({
                'type': 'Brand Dominance',
                'severity': 'High',
                'description': f"Top brand controls {top_brand_share:.1%} of market"
            })
            
        # 价格壁垒
        if price_analysis['avg_price'] > 100:
            barriers.append({
                'type': 'High Price Point',
                'severity': 'Medium',
                'description': f"Average price ${price_analysis['avg_price']:.2f} may require significant investment"
            })
            
        # 质量壁垒
        high_rated_products = len([p for p in products if p['rating'] > 4.5])
        if high_rated_products / len(products) > 0.6:
            barriers.append({
                'type': 'Quality Standards',
                'severity': 'Medium',
                'description': "High proportion of highly-rated products sets quality bar"
            })
            
        return barriers
        
    def _generate_market_report(self, research_results):
        """生成综合市场报告"""
        report = {
            'executive_summary': {},
            'market_analysis': research_results,
            'recommendations': {},
            'risk_assessment': {},
            'generated_at': datetime.now()
        }
        
        # 执行摘要
        total_categories = sum(len(country_data) for country_data in research_results.values())
        
        report['executive_summary'] = {
            'markets_analyzed': len(research_results),
            'categories_analyzed': total_categories,
            'key_findings': self._extract_key_findings(research_results),
            'overall_opportunity': self._calculate_overall_opportunity(research_results)
        }
        
        # 推荐策略
        report['recommendations'] = self._generate_strategic_recommendations(research_results)
        
        # 风险评估
        report['risk_assessment'] = self._assess_market_risks(research_results)
        
        return report
        
    def _extract_key_findings(self, research_results):
        """提取关键发现"""
        findings = []
        
        for country, categories in research_results.items():
            for category, analysis in categories.items():
                if analysis['maturity_indicators']['new_entrant_potential']['level'] == 'High':
                    findings.append(f"High opportunity in {category} category in {country} market")
                    
                if analysis['brand_analysis']['hhi_index'] < 1500:
                    findings.append(f"Low brand concentration in {category} ({country}) - fragmented market")
                    
                if analysis['quality_analysis']['low_rated_ratio'] > 0.3:
                    findings.append(f"Quality gap opportunity in {category} ({country}) - 30%+ products under 4.0 rating")
                    
        return findings[:10]  # 返回前10个关键发现
        
    def _calculate_overall_opportunity(self, research_results):
        """计算整体机会评分"""
        scores = []
        
        for country, categories in research_results.items():
            for category, analysis in categories.items():
                score = analysis['maturity_indicators']['new_entrant_potential']['score']
                scores.append(score)
                
        if not scores:
            return 0
            
        overall_score = np.mean(scores)
        
        return {
            'score': overall_score,
            'level': 'High' if overall_score >= 75 else 'Medium' if overall_score >= 50 else 'Low',
            'confidence': min(len(scores) / 10, 1.0)  # 基于分析样本数量的信心度
        }

class CompetitorMonitoringSystem:
    def __init__(self, pangolin_api, notification_config=None):
        self.api = pangolin_api
        self.notification_config = notification_config or {}
        self.db_connection = self._init_database()
        
    def _init_database(self):
        """初始化数据库连接"""
        import sqlite3
        conn = sqlite3.connect('competitor_monitoring.db')
        
        # 创建表结构
        conn.execute('''
            CREATE TABLE IF NOT EXISTS competitor_data (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                asin TEXT NOT NULL,
                title TEXT,
                price REAL,
                rating REAL,
                review_count INTEGER,
                availability TEXT,
                rank INTEGER,
                timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
            )
        ''')
        
        conn.execute('''
            CREATE TABLE IF NOT EXISTS price_alerts (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                asin TEXT NOT NULL,
                previous_price REAL,
                current_price REAL,
                change_percentage REAL,
                alert_type TEXT,
                timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
            )
        ''')
        
        conn.commit()
        return conn
        
    def add_competitors(self, competitor_list):
        """添加竞争对手监控列表"""
        self.competitor_asins = competitor_list
        
        # 初始化基线数据
        for asin in competitor_list:
            baseline_data = self.api.get_product_details(asin)
            if baseline_data:
                self._store_competitor_data(baseline_data)
                
    def run_daily_monitoring(self):
        """执行日常监控"""
        monitoring_results = {}
        alerts = []
        
        for asin in self.competitor_asins:
            try:
                # 获取当前数据
                current_data = self.api.get_product_details(asin)
                if not current_data:
                    continue
                    
                # 获取历史数据进行对比
                historical_data = self._get_historical_data(asin, days=7)
                
                # 分析变化
                changes = self._analyze_changes(current_data, historical_data)
                
                # 检查是否需要发送警报
                alert_conditions = self._check_alert_conditions(asin, current_data, changes)
                if alert_conditions:
                    alerts.extend(alert_conditions)
                    
                # 存储当前数据
                self._store_competitor_data(current_data)
                
                monitoring_results[asin] = {
                    'current_data': current_data,
                    'changes': changes,
                    'alerts': alert_conditions
                }
                
                time.sleep(1)  # 控制请求频率
                
            except Exception as e:
                print(f"Error monitoring {asin}: {e}")
                continue
                
        # 生成日报
        daily_report = self._generate_daily_report(monitoring_results, alerts)
        
        # 发送通知
        if alerts:
            self._send_notifications(alerts, daily_report)
            
        return daily_report
        
    def _analyze_changes(self, current_data, historical_data):
        """分析数据变化"""
        if not historical_data:
            return {'status': 'no_historical_data'}
            
        latest_historical = historical_data[0]  # 最新的历史记录
        
        changes = {}
        
        # 价格变化分析
        if current_data['price'] and latest_historical.get('price'):
            price_change = current_data['price'] - latest_historical['price']
            price_change_pct = (price_change / latest_historical['price']) * 100
            
            changes['price'] = {
                'absolute_change': price_change,
                'percentage_change': price_change_pct,
                'direction': 'increase' if price_change > 0 else 'decrease' if price_change < 0 else 'stable'
            }
            
        # 评分变化
        if current_data['rating'] and latest_historical.get('rating'):
            rating_change = current_data['rating'] - latest_historical['rating']
            changes['rating'] = {
                'change': rating_change,
                'direction': 'increase' if rating_change > 0 else 'decrease' if rating_change < 0 else 'stable'
            }
            
        # 评论数变化
        if current_data['review_count'] and latest_historical.get('review_count'):
            review_change = current_data['review_count'] - latest_historical['review_count']
            changes['reviews'] = {
                'new_reviews': review_change,
                'growth_rate': (review_change / latest_historical['review_count']) * 100 if latest_historical['review_count'] > 0 else 0
            }
            
        # 可用性变化
        if current_data['availability'] != latest_historical.get('availability'):
            changes['availability'] = {
                'previous': latest_historical.get('availability'),
                'current': current_data['availability'],
                'status': 'changed'
            }
            
        return changes
        
    def _check_alert_conditions(self, asin, current_data, changes):
        """检查警报条件"""
        alerts = []
        
        # 价格变化警报
        if 'price' in changes:
            price_change_pct = abs(changes['price']['percentage_change'])
            
            if price_change_pct > 10:  # 价格变化超过10%
                alert_type = 'price_drop' if changes['price']['direction'] == 'decrease' else 'price_increase'
                alerts.append({
                    'type': alert_type,
                    'asin': asin,
                    'severity': 'high' if price_change_pct > 20 else 'medium',
                    'message': f"Price {changes['price']['direction']} by {price_change_pct:.1f}%",
                    'current_price': current_data['price'],
                    'previous_price': current_data['price'] - changes['price']['absolute_change']
                })
                
        # 库存警报
        if 'availability' in changes:
            if 'out of stock' in current_data['availability'].lower():
                alerts.append({
                    'type': 'out_of_stock',
                    'asin': asin,
                    'severity': 'high',
                    'message': f"Product went out of stock",
                    'availability': current_data['availability']
                })
            elif 'in stock' in current_data['availability'].lower() and 'out of stock' in changes['availability']['previous'].lower():
                alerts.append({
                    'type': 'back_in_stock',
                    'asin': asin,
                    'severity': 'medium',
                    'message': f"Product back in stock",
                    'availability': current_data['availability']
                })
                
        # 评分大幅下降警报
        if 'rating' in changes:
            if changes['rating']['change'] < -0.2:  # 评分下降超过0.2
                alerts.append({
                    'type': 'rating_drop',
                    'asin': asin,
                    'severity': 'medium',
                    'message': f"Rating dropped by {abs(changes['rating']['change']):.2f}",
                    'current_rating': current_data['rating']
                })
                
        return alerts
        
    def _generate_daily_report(self, monitoring_results, alerts):
        """生成日报"""
        report = {
            'date': datetime.now().strftime('%Y-%m-%d'),
            'summary': {
                'total_competitors': len(monitoring_results),
                'total_alerts': len(alerts),
                'high_priority_alerts': len([a for a in alerts if a['severity'] == 'high']),
                'price_changes': len([r for r in monitoring_results.values() if 'price' in r.get('changes', {})]),
                'stock_issues': len([a for a in alerts if a['type'] in ['out_of_stock', 'back_in_stock']])
            },
            'detailed_analysis': monitoring_results,
            'alerts': alerts,
            'market_insights': self._generate_market_insights(monitoring_results)
        }
        
        return report
        
    def _generate_market_insights(self, monitoring_results):
        """生成市场洞察"""
        insights = []
        
        # 价格趋势分析
        price_changes = []
        for asin, data in monitoring_results.items():
            if 'price' in data.get('changes', {}):
                price_changes.append(data['changes']['price']['percentage_change'])
                
        if price_changes:
            avg_price_change = np.mean(price_changes)
            if abs(avg_price_change) > 5:
                direction = "increasing" if avg_price_change > 0 else "decreasing"
                insights.append(f"Overall market prices are {direction} by {abs(avg_price_change):.1f}% on average")
                
        # 库存短缺分析
        out_of_stock_count = len([
            data for data in monitoring_results.values()
            if 'out of stock' in data['current_data']['availability'].lower()
        ])
        
        if out_of_stock_count > len(monitoring_results) * 0.2:
            insights.append(f"Supply chain issues detected - {out_of_stock_count} out of {len(monitoring_results)} competitors out of stock")
            
        # 评论增长分析
        review_growth_rates = []
        for data in monitoring_results.values():
            if 'reviews' in data.get('changes', {}):
                growth_rate = data['changes']['reviews']['growth_rate']
                if growth_rate > 0:
                    review_growth_rates.append(growth_rate)
                    
        if review_growth_rates:
            avg_growth = np.mean(review_growth_rates)
            if avg_growth > 10:
                insights.append(f"High review activity in market - average growth rate {avg_growth:.1f}%")
                
        return insights
        
    def _send_notifications(self, alerts, daily_report):
        """发送通知"""
        # 邮件通知
        if self.notification_config.get('email'):
            self._send_email_notification(alerts, daily_report)
            
        # Slack通知
        if self.notification_config.get('slack_webhook'):
            self._send_slack_notification(alerts)
            
        # 微信通知
        if self.notification_config.get('wechat'):
            self._send_wechat_notification(alerts)
            
    def _send_email_notification(self, alerts, daily_report):
        """发送邮件通知"""
        import smtplib
        from email.mime.text import MIMEText
        from email.mime.multipart import MIMEMultipart
        
        # 构建邮件内容
        html_content = self._format_email_content(alerts, daily_report)
        
        msg = MIMEMultipart()
        msg['From'] = self.notification_config['email']['from']
        msg['To'] = self.notification_config['email']['to']
        msg['Subject'] = f"Amazon竞品监控日报 - {datetime.now().strftime('%Y-%m-%d')}"
        
        msg.attach(MIMEText(html_content, 'html'))
        
        try:
            server = smtplib.SMTP(self.notification_config['email']['smtp_server'], 587)
            server.starttls()
            server.login(self.notification_config['email']['username'], self.notification_config['email']['password'])
            server.send_message(msg)
            server.quit()
        except Exception as e:
            print(f"Failed to send email notification: {e}")
            
    def _format_email_content(self, alerts, daily_report):
        """格式化邮件内容"""
        html = f"""
        <html>
        <head>
            <style>
                body {{ font-family: Arial, sans-serif; }}
                .alert-high {{ color: #d32f2f; font-weight: bold; }}
                .alert-medium {{ color: #f57c00; }}
                .summary {{ background-color: #f5f5f5; padding: 15px; border-radius: 5px; }}
                table {{ border-collapse: collapse; width: 100%; }}
                th, td {{ border: 1px solid #ddd; padding: 8px; text-align: left; }}
                th {{ background-color: #f2f2f2; }}
            </style>
        </head>
        <body>
            <h2>Amazon竞品监控日报</h2>
            <p>日期: {daily_report['date']}</p>
            
            <div class="summary">
                <h3>概况</h3>
                <ul>
                    <li>监控竞品数量: {daily_report['summary']['total_competitors']}</li>
                    <li>总警报数: {daily_report['summary']['total_alerts']}</li>
                    <li>高优先级警报: {daily_report['summary']['high_priority_alerts']}</li>
                    <li>价格变动产品: {daily_report['summary']['price_changes']}</li>
                    <li>库存问题: {daily_report['summary']['stock_issues']}</li>
                </ul>
            </div>
            
            <h3>重要警报</h3>
            <table>
                <tr>
                    <th>ASIN</th>
                    <th>警报类型</th>
                    <th>严重程度</th>
                    <th>描述</th>
                </tr>
        """
        
        for alert in alerts:
            severity_class = f"alert-{alert['severity']}"
            html += f"""
                <tr>
                    <td>{alert['asin']}</td>
                    <td>{alert['type']}</td>
                    <td class="{severity_class}">{alert['severity'].upper()}</td>
                    <td>{alert['message']}</td>
                </tr>
            """
            
        html += """
            </table>
            
            <h3>市场洞察</h3>
            <ul>
        """
        
        for insight in daily_report['market_insights']:
            html += f"<li>{insight}</li>"
            
        html += """
            </ul>
        </body>
        </html>
        """
        
        return html

# 使用示例
def setup_monitoring_system():
    """设置监控系统"""
    # 初始化API
    pangolin_api = PangolinAmazonAPI(api_key="your_api_key")
    
    # 配置通知
    notification_config = {
        'email': {
            'smtp_server': 'smtp.gmail.com',
            'username': '[email protected]',
            'password': 'your_app_password',
            'from': '[email protected]',
            'to': '[email protected]'
        },
        'slack_webhook': 'https://hooks.slack.com/services/your/webhook/url'
    }
    
    # 创建监控系统
    monitoring_system = CompetitorMonitoringSystem(pangolin_api, notification_config)
    
    # 添加竞争对手
    competitor_asins = [
        "B08C7KG5LP",  # AirPods Pro
        "B07SJR6HL3",  # Sony WH-1000XM4
        "B0863TXGM3",  # Bose QuietComfort Earbuds
        "B08PZHYWJS",  # Samsung Galaxy Buds Pro
        "B091G2HKT1"   # Jabra Elite 85t
    ]
    
    monitoring_system.add_competitors(competitor_asins)
    
    # 执行监控
    daily_report = monitoring_system.run_daily_monitoring()
    
    return daily_report