商品數據獲取 → 直播商品篩選 → 鏈接批量生成 → 格式標準化處理 → 文檔自動輸出
     ↓             ↓             ↓             ↓             ↓
多條件商品查詢   智能排序過濾   平台鏈接規則   模板化格式處理   多格式文檔生成

# 偽代碼：直播商品篩選引擎
class LiveProductSelector:
    """直播商品篩選器"""
    
    def __init__(self):
        self.selection_rules = self.load_selection_rules()
        self.weight_factors = self.load_weight_factors()
    
    def load_selection_rules(self):
        """加載篩選規則"""
        return {
            "min_stock": 10,           # 最小庫存
            "max_stock": 1000,         # 最大庫存
            "min_sales": 5,            # 最小銷量
            "price_range": [50, 500],  # 價格區間
            "exclude_categories": ["清倉商品", "下架商品"],
            "include_categories": ["熱銷商品", "新品", "主推商品"]
        }
    
    def load_weight_factors(self):
        """加載權重因子"""
        return {
            "sales_weight": 0.4,       # 銷量權重
            "profit_weight": 0.3,      # 利潤權重
            "inventory_weight": 0.2,   # 庫存權重
            "seasonal_weight": 0.1     # 季節性權重
        }
    
    def select_live_products(self, all_products, live_theme="日常直播"):
        """篩選直播商品"""
        filtered_products = self.filter_products(all_products)
        scored_products = self.score_products(filtered_products, live_theme)
        sorted_products = self.sort_products(scored_products)
        
        # 根據直播時長選擇商品數量
        product_count = self.determine_product_count(live_theme)
        selected_products = sorted_products[:product_count]
        
        log.info(f"已篩選出 {len(selected_products)} 個直播商品")
        return selected_products
    
    def filter_products(self, products):
        """基礎條件篩選"""
        filtered = []
        
        for product in products:
            # 庫存檢查
            if not (self.selection_rules["min_stock"] <= product["stock"] <= self.selection_rules["max_stock"]):
                continue
            
            # 銷量檢查
            if product["sales"] < self.selection_rules["min_sales"]:
                continue
            
            # 價格檢查
            if not (self.selection_rules["price_range"][0] <= product["price"] <= self.selection_rules["price_range"][1]):
                continue
            
            # 品類檢查
            if any(category in product["category"] for category in self.selection_rules["exclude_categories"]):
                continue
            
            filtered.append(product)
        
        return filtered
    
    def score_products(self, products, live_theme):
        """為商品評分"""
        scored_products = []
        
        for product in products:
            score = 0
            
            # 銷量得分
            sales_score = self.calculate_sales_score(product["sales"])
            score += sales_score * self.weight_factors["sales_weight"]
            
            # 利潤得分
            profit_score = self.calculate_profit_score(product["profit_margin"])
            score += profit_score * self.weight_factors["profit_weight"]
            
            # 庫存得分
            inventory_score = self.calculate_inventory_score(product["stock"])
            score += inventory_score * self.weight_factors["inventory_weight"]
            
            # 季節性得分
            seasonal_score = self.calculate_seasonal_score(product, live_theme)
            score += seasonal_score * self.weight_factors["seasonal_weight"]
            
            scored_products.append({
                **product,
                "live_score": score,
                "selection_reason": self.get_selection_reason(score, sales_score, profit_score)
            })
        
        return scored_products
    
    def calculate_sales_score(self, sales_count):
        """計算銷量得分"""
        if sales_count >= 1000:
            return 100
        elif sales_count >= 500:
            return 80
        elif sales_count >= 100:
            return 60
        elif sales_count >= 50:
            return 40
        else:
            return 20
    
    def calculate_profit_score(self, profit_margin):
        """計算利潤得分"""
        if profit_margin >= 0.5:
            return 100
        elif profit_margin >= 0.3:
            return 80
        elif profit_margin >= 0.2:
            return 60
        elif profit_margin >= 0.1:
            return 40
        else:
            return 20
    
    def calculate_inventory_score(self, stock_count):
        """計算庫存得分"""
        if stock_count >= 500:
            return 100
        elif stock_count >= 200:
            return 80
        elif stock_count >= 100:
            return 60
        elif stock_count >= 50:
            return 40
        else:
            return 20
    
    def calculate_seasonal_score(self, product, live_theme):
        """計算季節性得分"""
        # 基於直播主題和商品特性的匹配度評分
        theme_keywords = {
            "日常直播": ["日常", "通用", "百搭"],
            "節日促銷": ["節日", "禮物", "禮盒"],
            "季節特賣": ["夏季", "冬季", "春秋"]
        }
        
        keywords = theme_keywords.get(live_theme, [])
        product_name = product["name"].lower()
        
        for keyword in keywords:
            if keyword in product_name:
                return 80
        
        return 40
    
    def get_selection_reason(self, total_score, sales_score, profit_score):
        """獲取選中原因"""
        reasons = []
        
        if sales_score >= 80:
            reasons.append("熱銷商品")
        if profit_score >= 80:
            reasons.append("高利潤")
        if total_score >= 70:
            reasons.append("綜合評分高")
        
        return "、".join(reasons) if reasons else "符合基礎條件"
    
    def sort_products(self, scored_products):
        """排序商品"""
        return sorted(scored_products, key=lambda x: x["live_score"], reverse=True)
    
    def determine_product_count(self, live_theme):
        """確定商品數量"""
        theme_counts = {
            "日常直播": 30,
            "節日促銷": 50,
            "季節特賣": 40,
            "新品發佈": 20
        }
        return theme_counts.get(live_theme, 30)

# 初始化篩選器
product_selector = LiveProductSelector()

# 偽代碼：商品數據採集模塊
def collect_product_data():
    """採集商品數據"""
    # 登錄抖店後台
    browser.launch("chrome", "https://compass.jinritemai.com/login")
    browser.input_text("#username", env.get("douyin_username"))
    browser.input_text("#password", env.get("douyin_password"))
    browser.click(".login-btn")
    browser.wait_for_element(".dashboard", timeout=10)
    
    # 進入商品管理頁面
    browser.click("商品")
    browser.click("商品管理")
    browser.wait_for_element(".product-list", timeout=5)
    
    all_products = []
    page_count = 0
    max_pages = 10  # 限制採集頁數
    
    while page_count < max_pages:
        # 獲取當前頁面商品列表
        product_items = browser.find_elements(".product-item")
        
        for item in product_items:
            try:
                product_info = {
                    "product_id": item.find_element(".product-id").text,
                    "name": item.find_element(".product-name").text,
                    "price": extract_price(item.find_element(".price").text),
                    "stock": extract_number(item.find_element(".stock").text),
                    "sales": extract_number(item.find_element(".sales").text),
                    "category": item.find_element(".category").text,
                    "status": item.find_element(".status").text,
                    "profit_margin": self.estimate_profit_margin(item)
                }
                
                # 只採集上架商品
                if product_info["status"] == "上架":
                    all_products.append(product_info)
                    
            except Exception as e:
                log.warning(f"提取商品數據失敗: {str(e)}")
                continue
        
        # 翻頁處理
        if browser.is_element_exist(".next-page") and len(product_items) > 0:
            browser.click(".next-page")
            browser.wait_for_element(".product-list", timeout=3)
            page_count += 1
        else:
            break
    
    log.info(f"成功採集 {len(all_products)} 個商品數據")
    return all_products

def extract_price(price_text):
    """從文本中提取價格"""
    import re
    matches = re.findall(r'[\d.,]+', str(price_text))
    if matches:
        return float(matches[0].replace(',', ''))
    return 0.0

def extract_number(number_text):
    """從文本中提取數字"""
    import re
    matches = re.findall(r'\d+', str(number_text))
    if matches:
        return int(matches[0])
    return 0

def estimate_profit_margin(product_element):
    """估算利潤率"""
    # 簡化估算邏輯，實際應從成本價計算
    try:
        price = extract_price(product_element.find_element(".price").text)
        # 假設成本價為售價的60%
        cost = price * 0.6
        profit_margin = (price - cost) / price if price > 0 else 0
        return profit_margin
    except:
        return 0.3  # 默認利潤率30%

# 執行數據採集
all_products_data = collect_product_data()

# 偽代碼：鏈接生成引擎
class LiveLinkGenerator:
    """直播鏈接生成器"""
    
    def __init__(self):
        self.link_templates = self.load_link_templates()
        self.url_rules = self.load_url_rules()
    
    def load_link_templates(self):
        """加載鏈接模板"""
        return {
            "standard": "https://haohuo.jinritemai.com/views/product/item?id={product_id}",
            "short": "https://v.douyin.com/{short_code}/",
            "promotion": "https://haohuo.jinritemai.com/views/product/item?id={product_id}&promotion=1",
            "with_anchor": "https://haohuo.jinritemai.com/views/product/item?id={product_id}&anchor={anchor_id}"
        }
    
    def load_url_rules(self):
        """加載URL規則"""
        return {
            "max_length": 100,
            "allowed_params": ["id", "promotion", "anchor", "source"],
            "required_params": ["id"]
        }
    
    def generate_live_links(self, selected_products, link_type="standard", additional_params=None):
        """生成直播鏈接"""
        live_links = []
        
        for product in selected_products:
            link_data = self.generate_single_link(product, link_type, additional_params)
            live_links.append(link_data)
        
        log.info(f"已生成 {len(live_links)} 個直播鏈接")
        return live_links
    
    def generate_single_link(self, product, link_type, additional_params):
        """生成單個鏈接"""
        template = self.link_templates.get(link_type, self.link_templates["standard"])
        
        # 基礎參數替換
        link_url = template.format(
            product_id=product["product_id"],
            short_code=self.generate_short_code(product),
            anchor_id=env.get("default_anchor_id", "main")
        )
        
        # 添加額外參數
        if additional_params:
            link_url = self.add_url_params(link_url, additional_params)
        
        # 驗證鏈接格式
        if not self.validate_link(link_url):
            log.warning(f"鏈接格式驗證失敗: {link_url}")
        
        return {
            "product_id": product["product_id"],
            "product_name": product["name"],
            "price": product["price"],
            "live_score": product.get("live_score", 0),
            "link_url": link_url,
            "link_type": link_type,
            "qr_code": self.generate_qr_code(link_url),
            "generated_time": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        }
    
    def generate_short_code(self, product):
        """生成短鏈代碼"""
        # 基於商品ID生成短鏈代碼的簡化邏輯
        import hashlib
        hash_object = hashlib.md5(product["product_id"].encode())
        return hash_object.hexdigest()[:8]
    
    def add_url_params(self, base_url, params):
        """添加URL參數"""
        from urllib.parse import urlencode
        
        # 檢查參數是否允許
        filtered_params = {k: v for k, v in params.items() if k in self.url_rules["allowed_params"]}
        
        if filtered_params:
            param_string = urlencode(filtered_params)
            separator = '&' if '?' in base_url else '?'
            return base_url + separator + param_string
        
        return base_url
    
    def validate_link(self, link_url):
        """驗證鏈接格式"""
        # 檢查長度
        if len(link_url) > self.url_rules["max_length"]:
            return False
        
        # 檢查必需參數
        if "id=" not in link_url:
            return False
        
        return True
    
    def generate_qr_code(self, link_url):
        """生成二維碼"""
        try:
            import qrcode
            qr = qrcode.QRCode(
                version=1,
                error_correction=qrcode.constants.ERROR_CORRECT_L,
                box_size=10,
                border=4,
            )
            qr.add_data(link_url)
            qr.make(fit=True)
            
            qr_img = qr.make_image(fill_color="black", back_color="white")
            qr_filename = f"qrcodes/{hash(link_url)}.png"
            qr_img.save(qr_filename)
            
            return qr_filename
        except Exception as e:
            log.warning(f"生成二維碼失敗: {str(e)}")
            return None
    
    def generate_multiple_formats(self, selected_products):
        """生成多種格式鏈接"""
        all_formats = {}
        
        for format_name in self.link_templates.keys():
            links = self.generate_live_links(selected_products, format_name)
            all_formats[format_name] = links
        
        return all_formats

# 初始化鏈接生成器
link_generator = LiveLinkGenerator()

# 篩選直播商品
selected_live_products = product_selector.select_live_products(all_products_data, "日常直播")

# 生成直播鏈接
live_links = link_generator.generate_live_links(selected_live_products, "standard")

# 偽代碼：文檔生成模塊
import pandas as pd
from openpyxl import Workbook
from openpyxl.styles import Font, PatternFill, Alignment
import json

class LiveDocumentGenerator:
    """直播文檔生成器"""
    
    def __init__(self):
        self.document_templates = self.load_document_templates()
    
    def load_document_templates(self):
        """加載文檔模板"""
        return {
            "excel": {
                "headers": ["序號", "商品名稱", "價格", "直播評分", "商品鏈接", "二維碼", "選中原因"],
                "column_widths": [8, 40, 12, 12, 60, 20, 25]
            },
            "text": {
                "template": "【{index}】{name} - ¥{price}\n鏈接: {link}\n評分: {score} - {reason}\n{separator}"
            },
            "json": {
                "structure": ["product_id", "product_name", "price", "link_url", "live_score"]
            }
        }
    
    def generate_live_documents(self, live_links, output_formats=["excel", "text"]):
        """生成直播文檔"""
        generated_files = {}
        
        for format_type in output_formats:
            if format_type == "excel":
                file_path = self.generate_excel_document(live_links)
            elif format_type == "text":
                file_path = self.generate_text_document(live_links)
            elif format_type == "json":
                file_path = self.generate_json_document(live_links)
            else:
                continue
            
            if file_path:
                generated_files[format_type] = file_path
        
        return generated_files
    
    def generate_excel_document(self, live_links):
        """生成Excel文檔"""
        try:
            wb = Workbook()
            ws = wb.active
            ws.title = "直播商品鏈接"
            
            # 設置表頭
            headers = self.document_templates["excel"]["headers"]
            ws.append(headers)
            
            # 設置表頭樣式
            header_font = Font(bold=True, color="FFFFFF")
            header_fill = PatternFill(start_color="366092", end_color="366092", fill_type="solid")
            
            for cell in ws[1]:
                cell.font = header_font
                cell.fill = header_fill
                cell.alignment = Alignment(horizontal="center")
            
            # 填充數據
            for index, link_data in enumerate(live_links, 1):
                row = [
                    index,
                    link_data["product_name"],
                    f"¥{link_data['price']:.2f}",
                    f"{link_data.get('live_score', 0):.1f}",
                    link_data["link_url"],
                    link_data.get("qr_code", "無"),
                    link_data.get("selection_reason", "")
                ]
                ws.append(row)
            
            # 設置列寬
            column_widths = self.document_templates["excel"]["column_widths"]
            for i, width in enumerate(column_widths, 1):
                ws.column_dimensions[chr(64 + i)].width = width
            
            # 添加篩選器
            ws.auto_filter.ref = ws.dimensions
            
            # 保存文件
            filename = f"直播商品鏈接_{datetime.now().strftime('%Y%m%d_%H%M')}.xlsx"
            wb.save(filename)
            
            log.info(f"Excel文檔已生成: {filename}")
            return filename
            
        except Exception as e:
            log.error(f"生成Excel文檔失敗: {str(e)}")
            return None
    
    def generate_text_document(self, live_links):
        """生成文本文檔"""
        try:
            template = self.document_templates["text"]["template"]
            content = f"直播商品鏈接清單\n生成時間: {datetime.now().strftime('%Y-%m-%d %H:%M')}\n\n"
            
            for index, link_data in enumerate(live_links, 1):
                line = template.format(
                    index=index,
                    name=link_data["product_name"],
                    price=link_data["price"],
                    link=link_data["link_url"],
                    score=link_data.get("live_score", 0),
                    reason=link_data.get("selection_reason", ""),
                    separator="-" * 50
                )
                content += line + "\n"
            
            filename = f"直播商品鏈接_{datetime.now().strftime('%Y%m%d_%H%M')}.txt"
            with open(filename, 'w', encoding='utf-8') as f:
                f.write(content)
            
            log.info(f"文本文檔已生成: {filename}")
            return filename
            
        except Exception as e:
            log.error(f"生成文本文檔失敗: {str(e)}")
            return None
    
    def generate_json_document(self, live_links):
        """生成JSON文檔"""
        try:
            json_data = {
                "generated_time": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
                "total_products": len(live_links),
                "products": []
            }
            
            for link_data in live_links:
                product_info = {
                    key: link_data[key] for key in self.document_templates["json"]["structure"]
                    if key in link_data
                }
                json_data["products"].append(product_info)
            
            filename = f"直播商品鏈接_{datetime.now().strftime('%Y%m%d_%H%M')}.json"
            with open(filename, 'w', encoding='utf-8') as f:
                json.dump(json_data, f, ensure_ascii=False, indent=2)
            
            log.info(f"JSON文檔已生成: {filename}")
            return filename
            
        except Exception as e:
            log.error(f"生成JSON文檔失敗: {str(e)}")
            return None
    
    def generate_live_script_template(self, live_links, live_theme):
        """生成直播話術模板"""
        script_template = f"""
        🎤 直播話術模板 - {live_theme}
        直播時間: {datetime.now().strftime('%Y年%m月%d日 %H:%M')}
        =========================================
        
        開場話術:
        "大家好！歡迎來到直播間～今天為大家準備了{len(live_links)}款精選好物，都是近期爆款哦！"
        
        商品介紹順序:
        """
        
        for index, link_data in enumerate(live_links, 1):
            script_template += f"""
        {index}. 【{link_data['product_name']}】- ¥{link_data['price']:.2f}
           賣點: {self.generate_selling_points(link_data)}
           話術: "這款{link_data['product_name']}真的是性價比超高！{self.generate_live_talk(link_data)}"
           鏈接: {link_data['link_url']}
            """
        
        script_template += f"""
        結束話術:
        "感謝大家今天的觀看！沒搶到的小夥伴不用擔心，點擊購物車還能繼續購買哦～我們下期再見！"
        """
        
        filename = f"直播話術_{live_theme}_{datetime.now().strftime('%Y%m%d_%H%M')}.txt"
        with open(filename, 'w', encoding='utf-8') as f:
            f.write(script_template)
        
        return filename
    
    def generate_selling_points(self, link_data):
        """生成商品賣點"""
        # 基於商品名稱和價格生成賣點
        price = link_data["price"]
        name = link_data["product_name"]
        
        if price < 100:
            return "性價比超高，入手不虧！"
        elif price < 300:
            return "品質保證，這個價格真的很值！"
        else:
            return "高端品質，買了絕對不後悔！"
    
    def generate_live_talk(self, link_data):
        """生成直播話術"""
        # 基於商品信息生成直播話術
        score = link_data.get("live_score", 0)
        
        if score >= 80:
            return "這款是我們的爆款推薦，庫存有限，喜歡的寶寶們抓緊下單！"
        elif score >= 60:
            return "這款口碑很好，很多回頭客都在回購，今天價格特別優惠！"
        else:
            return "這款是我們的潛力新品，今天首發特惠，大家可以試試看！"

# 初始化文檔生成器
doc_generator = LiveDocumentGenerator()

# 生成多種格式文檔
generated_docs = doc_generator.generate_live_documents(live_links, ["excel", "text", "json"])

# 生成直播話術模板
live_script = doc_generator.generate_live_script_template(live_links, "日常直播")

# 偽代碼：分發與監控模塊
import smtplib
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from email.mime.base import MIMEBase
from email import encoders

class DistributionManager:
    """分發管理器"""
    
    def __init__(self):
        self.distribution_config = self.load_distribution_config()
    
    def load_distribution_config(self):
        """加載分發配置"""
        return {
            "email": {
                "enabled": True,
                "recipients": ["live_team@company.com", "assistant@company.com"]
            },
            "dingtalk": {
                "enabled": True,
                "webhook": env.get("dingtalk_webhook")
            },
            "local_network": {
                "enabled": False,
                "shared_folder": "//server/live_materials"
            }
        }
    
    def distribute_live_materials(self, generated_docs, live_links, live_theme):
        """分發直播材料"""
        distribution_results = {}
        
        # 郵件分發
        if self.distribution_config["email"]["enabled"]:
            email_result = self.send_email_notification(generated_docs, live_links, live_theme)
            distribution_results["email"] = email_result
        
        # 釘釘通知
        if self.distribution_config["dingtalk"]["enabled"]:
            dingtalk_result = self.send_dingtalk_notification(live_links, live_theme)
            distribution_results["dingtalk"] = dingtalk_result
        
        # 局域網共享
        if self.distribution_config["local_network"]["enabled"]:
            network_result = self.copy_to_network_share(generated_docs)
            distribution_results["network"] = network_result
        
        return distribution_results
    
    def send_email_notification(self, generated_docs, live_links, live_theme):
        """發送郵件通知"""
        try:
            msg = MIMEMultipart()
            msg['Subject'] = f'直播商品鏈接清單 - {live_theme} - {datetime.now().strftime("%Y-%m-%d")}'
            msg['From'] = env.get("email_sender")
            msg['To'] = ', '.join(self.distribution_config["email"]["recipients"])
            
            # 郵件正文
            body = f"""
            <h2>📋 直播商品鏈接清單</h2>
            
            <p><strong>直播主題:</strong> {live_theme}</p>
            <p><strong>商品數量:</strong> {len(live_links)} 個</p>
            <p><strong>生成時間:</strong> {datetime.now().strftime('%Y-%m-%d %H:%M')}</p>
            
            <h3>📊 商品概覽:</h3>
            <ul>
            """
            
            for i, link_data in enumerate(live_links[:5], 1):  # 只顯示前5個
                body += f'<li>{link_data["product_name"]} - ¥{link_data["price"]:.2f}</li>'
            
            if len(live_links) > 5:
                body += f'<li>... 還有 {len(live_links) - 5} 個商品</li>'
            
            body += """
            </ul>
            
            <p>詳細商品信息請查看附件，直播加油！🎉</p>
            """
            
            msg.attach(MIMEText(body, 'html'))
            
            # 添加附件
            for doc_type, file_path in generated_docs.items():
                with open(file_path, "rb") as f:
                    part = MIMEBase('application', 'octet-stream')
                    part.set_payload(f.read())
                    encoders.encode_base64(part)
                    part.add_header('Content-Disposition', f'attachment; filename="{Path(file_path).name}"')
                    msg.attach(part)
            
            # 發送郵件
            server = smtplib.SMTP(env.get("smtp_server"), env.get("smtp_port"))
            server.starttls()
            server.login(env.get("email_sender"), env.get("email_password"))
            server.send_message(msg)
            server.quit()
            
            log.info("直播材料郵件發送成功")
            return True
            
        except Exception as e:
            log.error(f"發送郵件失敗: {str(e)}")
            return False
    
    def send_dingtalk_notification(self, live_links, live_theme):
        """發送釘釘通知"""
        try:
            notification_content = {
                "msgtype": "markdown",
                "markdown": {
                    "title": f"直播商品鏈接已生成 - {live_theme}",
                    "text": f"""### 🎯 直播商品鏈接已生成
                    
**直播主題**: {live_theme}
**商品數量**: {len(live_links)} 個
**生成時間**: {datetime.now().strftime('%Y-%m-%d %H:%M')}
                    
**精選商品預覽**:
"""
                }
            }
            
            # 添加商品預覽
            for i, link_data in enumerate(live_links[:3], 1):
                notification_content["markdown"]["text"] += f"{i}. {link_data['product_name']} - ¥{link_data['price']:.2f}\n"
            
            if len(live_links) > 3:
                notification_content["markdown"]["text"] += f"... 還有 {len(live_links) - 3} 個商品\n"
            
            notification_content["markdown"]["text"] += f"\n請及時查收郵件獲取完整鏈接清單！"
            
            # 發送釘釘消息
            dingtalk.send(webhook=self.distribution_config["dingtalk"]["webhook"], 
                         data=notification_content)
            
            log.info("釘釘通知發送成功")
            return True
            
        except Exception as e:
            log.error(f"發送釘釘通知失敗: {str(e)}")
            return False
    
    def copy_to_network_share(self, generated_docs):
        """複製到網絡共享"""
        try:
            shared_folder = self.distribution_config["local_network"]["shared_folder"]
            
            for doc_type, file_path in generated_docs.items():
                import shutil
                dest_path = f"{shared_folder}/{Path(file_path).name}"
                shutil.copy2(file_path, dest_path)
            
            log.info("文件已複製到網絡共享")
            return True
            
        except Exception as e:
            log.error(f"複製到網絡共享失敗: {str(e)}")
            return False

class LinkMonitor:
    """鏈接狀態監控器"""
    
    def __init__(self):
        self.monitor_config = self.load_monitor_config()
    
    def load_monitor_config(self):
        """加載監控配置"""
        return {
            "check_interval": 3600,  # 1小時檢查一次
            "alert_threshold": 0.9,  # 90%鏈接有效
            "monitor_duration": 24   # 監控24小時
        }
    
    def monitor_links_status(self, live_links):
        """監控鏈接狀態"""
        status_report = {
            "total_links": len(live_links),
            "active_links": 0,
            "broken_links": [],
            "last_check": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        }
        
        for link_data in live_links:
            if self.check_link_status(link_data["link_url"]):
                status_report["active_links"] += 1
            else:
                status_report["broken_links"].append(link_data)
        
        # 檢查是否需要告警
        active_ratio = status_report["active_links"] / status_report["total_links"]
        if active_ratio < self.monitor_config["alert_threshold"]:
            self.send_alert_notification(status_report)
        
        return status_report
    
    def check_link_status(self, link_url):
        """檢查鏈接狀態"""
        try:
            import requests
            response = requests.head(link_url, timeout=10, allow_redirects=True)
            return response.status_code == 200
        except:
            return False
    
    def send_alert_notification(self, status_report):
        """發送告警通知"""
        alert_content = f"""
        🚨 直播鏈接狀態告警
        
        發現鏈接有效性低於閾值！
        
        統計信息:
        - 總鏈接數: {status_report['total_links']}
        - 有效鏈接: {status_report['active_links']}
        - 失效鏈接: {len(status_report['broken_links'])}
        - 有效比例: {status_report['active_links']/status_report['total_links']*100:.1f}%
        
        請及時檢查並更新鏈接！
        """
        
        dingtalk.send_markdown(
            webhook=env.get("alert_webhook"),
            title="直播鏈接狀態告警",
            text=alert_content
        )

# 執行分發與監控
distribution_manager = DistributionManager()
link_monitor = LinkMonitor()

# 分發直播材料
distribution_results = distribution_manager.distribute_live_materials(
    generated_docs, live_links, "日常直播"
)

# 監控鏈接狀態
link_status = link_monitor.monitor_links_status(live_links)

# 基於直播節奏智能排序商品
def optimize_product_sequence(live_links, live_duration=120):
    """優化商品展示順序"""
    # 基於價格、熱度、品類等因素智能排序
    sequenced_products = []
    
    # 開場爆款（高熱度中等價格）
    opening_products = [p for p in live_links if 60 <= p["live_score"] <= 80 and p["price"] < 200]
    sequenced_products.extend(opening_products[:3])
    
    # 中場主推（各種價位均衡）
    mid_products = [p for p in live_links if p not in sequenced_products]
    sequenced_products.extend(mid_products)
    
    # 壓軸高價（高價值商品）
    closing_products = [p for p in live_links if p["price"] > 300 and p["live_score"] > 70]
    sequenced_products.extend(closing_products[-2:])
    
    return sequenced_products

# 監控商品價格變動並自動更新鏈接
def monitor_price_changes(live_links):
    """監控價格變動"""
    updated_links = []
    
    for link_data in live_links:
        current_price = get_current_price(link_data["product_id"])
        
        if current_price != link_data["price"]:
            # 價格變動，更新鏈接
            updated_link = update_link_with_new_price(link_da