import torch
import torch.nn as nn
from transformers import AutoTokenizer, AutoModelForCausalLM
from typing import Dict, List, Optional
class TextContentGenerator:
    """
    文本内容生成器
    基于预训练语言模型实现品牌化文本内容生成
    """
    
    def __init__(self, model_name: str = "gpt-3.5-turbo", brand_config: Dict = None):
        """
        初始化文本生成器
        
        Args:
            model_name: 预训练模型名称
            brand_config: 品牌配置信息，包含风格、语调等参数
        """
        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
        self.model = AutoModelForCausalLM.from_pretrained(model_name)
        self.brand_config = brand_config or {}
        
        # 品牌风格提示词模板
        self.brand_prompt_template = self._build_brand_prompt()
    
    def _build_brand_prompt(self) -> str:
        """构建品牌风格提示词"""
        tone = self.brand_config.get('tone', 'professional')
        style = self.brand_config.get('style', 'informative')
        target_audience = self.brand_config.get('target_audience', 'general')
        
        return f"""
        请以{tone}的语调，采用{style}的写作风格，
        面向{target_audience}受众群体创作内容。
        确保内容符合品牌调性和价值观。
        """
    
    def generate_content(self, 
                        prompt: str, 
                        content_type: str = "article",
                        max_length: int = 1000,
                        temperature: float = 0.7) -> Dict:
        """
        生成文本内容
        
        Args:
            prompt: 用户输入提示
            content_type: 内容类型（article, social_post, email等）
            max_length: 最大生成长度
            temperature: 生成温度，控制创造性
            
        Returns:
            包含生成内容和元数据的字典
        """
        # 构建完整提示词
        full_prompt = f"{self.brand_prompt_template}\n\n内容类型：{content_type}\n用户需求：{prompt}"
        
        # 编码输入
        inputs = self.tokenizer.encode(full_prompt, return_tensors="pt")
        
        # 生成内容
        with torch.no_grad():
            outputs = self.model.generate(
                inputs,
                max_length=max_length,
                temperature=temperature,
                do_sample=True,
                pad_token_id=self.tokenizer.eos_token_id
            )
        
        # 解码输出
        generated_text = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
        
        # 提取生成的内容（去除提示词部分）
        content = generated_text[len(full_prompt):].strip()
        
        return {
            "content": content,
            "content_type": content_type,
            "metadata": {
                "length": len(content),
                "temperature": temperature,
                "brand_aligned": True
            }
        }

import torch
from diffusers import StableDiffusionPipeline, DDIMScheduler
from PIL import Image
import numpy as np
class ImageContentGenerator:
    """
    图像内容生成器
    基于Stable Diffusion实现品牌化图像生成
    """
    
    def __init__(self, model_id: str = "runwayml/stable-diffusion-v1-5"):
        """初始化图像生成器"""
        self.pipe = StableDiffusionPipeline.from_pretrained(
            model_id,
            torch_dtype=torch.float16,
            safety_checker=None,
            requires_safety_checker=False
        )
        
        # 使用DDIM调度器提高生成质量
        self.pipe.scheduler = DDIMScheduler.from_config(self.pipe.scheduler.config)
        
        # GPU加速
        if torch.cuda.is_available():
            self.pipe = self.pipe.to("cuda")
    
    def generate_brand_image(self, 
                           prompt: str,
                           brand_style: str = "modern",
                           negative_prompt: str = None,
                           width: int = 512,
                           height: int = 512,
                           num_inference_steps: int = 50,
                           guidance_scale: float = 7.5) -> Dict:
        """
        生成品牌化图像
        
        Args:
            prompt: 图像描述提示词
            brand_style: 品牌风格（modern, classic, minimalist等）
            negative_prompt: 负面提示词
            width, height: 图像尺寸
            num_inference_steps: 推理步数
            guidance_scale: 引导强度
            
        Returns:
            包含生成图像和元数据的字典
        """
        # 构建品牌化提示词
        style_prompts = {
            "modern": "modern design, clean lines, contemporary style",
            "classic": "classic design, elegant, timeless style",
            "minimalist": "minimalist design, simple, clean aesthetic"
        }
        
        enhanced_prompt = f"{prompt}, {style_prompts.get(brand_style, '')}, high quality, professional"
        
        # 默认负面提示词
        if negative_prompt is None:
            negative_prompt = "low quality, blurry, distorted, watermark, text"
        
        # 生成图像
        with torch.autocast("cuda"):
            result = self.pipe(
                prompt=enhanced_prompt,
                negative_prompt=negative_prompt,
                width=width,
                height=height,
                num_inference_steps=num_inference_steps,
                guidance_scale=guidance_scale
            )
        
        image = result.images[0]
        
        return {
            "image": image,
            "prompt": enhanced_prompt,
            "metadata": {
                "brand_style": brand_style,
                "dimensions": f"{width}x{height}",
                "inference_steps": num_inference_steps,
                "guidance_scale": guidance_scale
            }
        }

import torch
import torch.nn as nn
from torchvision import transforms
import clip
class BrandStyleController:
    """
    品牌风格控制器
    实现跨模态的品牌风格一致性保持
    """
    
    def __init__(self, brand_assets_path: str):
        """
        初始化品牌风格控制器
        
        Args:
            brand_assets_path: 品牌资产文件路径
        """
        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
        
        # 加载CLIP模型用于多模态风格理解
        self.clip_model, self.clip_preprocess = clip.load("ViT-B/32", device=self.device)
        
        # 加载品牌资产
        self.brand_assets = self._load_brand_assets(brand_assets_path)
        
        # 提取品牌风格特征
        self.brand_style_features = self._extract_brand_features()
    
    def evaluate_style_consistency(self, generated_content: Dict) -> float:
        """
        评估生成内容的风格一致性
        
        Args:
            generated_content: 生成的内容（文本、图像或视频）
            
        Returns:
            风格一致性得分（0-1之间）
        """
        content_type = generated_content.get("type")
        content_data = generated_content.get("data")
        
        if content_type == "text":
            return self._evaluate_text_style(content_data)
        elif content_type == "image":
            return self._evaluate_image_style(content_data)
        else:
            return 0.0

import hashlib
import numpy as np
from typing import Dict, List, Tuple
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
class CopyrightRiskController:
    """
    版权风险控制器
    实现AI生成内容的版权风险检测和控制
    """
    
    def __init__(self, reference_database_path: str):
        """
        初始化版权风险控制器
        
        Args:
            reference_database_path: 参考数据库路径
        """
        self.reference_db = self._load_reference_database(reference_database_path)
        self.similarity_threshold = 0.8  # 相似度阈值
        self.tfidf_vectorizer = TfidfVectorizer(max_features=10000, stop_words='english')
        
        # 构建参考内容的特征向量
        self._build_reference_vectors()
    
    def _load_reference_database(self, db_path: str) -> List[Dict]:
        """加载参考数据库"""
        # 加载已知的版权内容数据库
        reference_data = []
        # 实际实现中需要从数据库或文件中加载
        return reference_data
    
    def _build_reference_vectors(self):
        """构建参考内容的特征向量"""
        if not self.reference_db:
            return
        
        # 提取所有参考文本
        reference_texts = [item.get('content', '') for item in self.reference_db]
        
        # 构建TF-IDF向量
        if reference_texts:
            self.reference_vectors = self.tfidf_vectorizer.fit_transform(reference_texts)
    
    def check_copyright_risk(self, generated_content: Dict) -> Dict:
        """
        检查生成内容的版权风险
        
        Args:
            generated_content: 生成的内容
            
        Returns:
            包含风险评估结果的字典
        """
        content_type = generated_content.get("type")
        content_data = generated_content.get("data")
        
        if content_type == "text":
            return self._check_text_copyright(content_data)
        elif content_type == "image":
            return self._check_image_copyright(content_data)
        else:
            return {"risk_level": "unknown", "similarity_score": 0.0}
    
    def _check_text_copyright(self, text: str) -> Dict:
        """检查文本版权风险"""
        if not hasattr(self, 'reference_vectors') or self.reference_vectors is None:
            return {"risk_level": "low", "similarity_score": 0.0, "matches": []}
        
        # 将生成文本转换为向量
        text_vector = self.tfidf_vectorizer.transform([text])
        
        # 计算与参考内容的相似度
        similarities = cosine_similarity(text_vector, self.reference_vectors)[0]
        
        # 找到最高相似度和对应的内容
        max_similarity = np.max(similarities)
        max_index = np.argmax(similarities)
        
        # 确定风险等级
        if max_similarity >= self.similarity_threshold:
            risk_level = "high"
        elif max_similarity >= 0.6:
            risk_level = "medium"
        else:
            risk_level = "low"
        
        # 找到所有高相似度的匹配
        high_similarity_indices = np.where(similarities >= 0.6)[0]
        matches = []
        
        for idx in high_similarity_indices:
            if idx < len(self.reference_db):
                matches.append({
                    "reference_id": self.reference_db[idx].get("id", "unknown"),
                    "similarity_score": similarities[idx],
                    "reference_title": self.reference_db[idx].get("title", "Unknown"),
                    "source": self.reference_db[idx].get("source", "Unknown")
                })
        
        return {
            "risk_level": risk_level,
            "similarity_score": max_similarity,
            "matches": matches,
            "recommendations": self._generate_risk_recommendations(risk_level, max_similarity)
        }
    
    def _generate_risk_recommendations(self, risk_level: str, similarity_score: float) -> List[str]:
        """生成风险控制建议"""
        recommendations = []
        
        if risk_level == "high":
            recommendations.extend([
                "建议重新生成内容，避免版权风险",
                "如需使用，请联系原作者获取授权",
                "考虑大幅修改内容结构和表达方式"
            ])
        elif risk_level == "medium":
            recommendations.extend([
                "建议适当修改内容以降低相似度",
                "增加原创性元素和个人观点",
                "考虑引用原文并标注来源"
            ])
        else:
            recommendations.append("内容原创性较高，版权风险较低")
        
        return recommendations
    
    def generate_compliance_report(self, content_batch: List[Dict]) -> Dict:
        """
        生成合规性报告
        
        Args:
            content_batch: 批量内容列表
            
        Returns:
            合规性报告
        """
        report = {
            "total_content": len(content_batch),
            "risk_distribution": {"high": 0, "medium": 0, "low": 0},
            "high_risk_items": [],
            "recommendations": [],
            "compliance_score": 0.0
        }
        
        for i, content in enumerate(content_batch):
            risk_result = self.check_copyright_risk(content)
            risk_level = risk_result.get("risk_level", "unknown")
            
            if risk_level in report["risk_distribution"]:
                report["risk_distribution"][risk_level] += 1
            
            if risk_level == "high":
                report["high_risk_items"].append({
                    "content_id": i,
                    "risk_details": risk_result
                })
        
        # 计算合规得分
        total = report["total_content"]
        if total > 0:
            compliance_score = (
                report["risk_distribution"]["low"] * 1.0 +
                report["risk_distribution"]["medium"] * 0.6 +
                report["risk_distribution"]["high"] * 0.0
            ) / total
            report["compliance_score"] = compliance_score
        
        # 生成总体建议
        if report["compliance_score"] < 0.6:
            report["recommendations"].append("整体版权风险较高，建议全面审查内容")
        elif report["compliance_score"] < 0.8:
            report["recommendations"].append("存在一定版权风险，建议重点关注中高风险内容")
        else:
            report["recommendations"].append("整体版权风险可控，建议保持现有质量标准")
        
        return report

class MediaContentPipeline:
    """
    媒体内容生产流水线
    实现新闻、图片、视频的自动化生产
    """
    
    def __init__(self):
        self.text_generator = TextContentGenerator()
        self.image_generator = ImageContentGenerator()
        self.quality_assessor = ContentQualityAssessor()
        self.copyright_controller = CopyrightRiskController("./reference_db")
    
    def produce_news_content(self, news_brief: str, content_requirements: Dict) -> Dict:
        """
        生产新闻内容
        
        Args:
            news_brief: 新闻简报
            content_requirements: 内容要求
            
        Returns:
            完整的新闻内容包
        """
        # 生成新闻文本
        text_content = self.text_generator.generate_content(
            prompt=news_brief,
            content_type="news_article",
            max_length=content_requirements.get("max_length", 1500)
        )
        
        # 生成配图
        image_prompt = self._extract_image_prompt(text_content["content"])
        image_content = self.image_generator.generate_brand_image(
            prompt=image_prompt,
            brand_style="news_professional"
        )
        
        # 质量评估
        text_quality = self.quality_assessor.assess_content_quality({
            "type": "text",
            "data": text_content["content"],
            "prompt": news_brief
        })
        
        # 版权风险检查
        copyright_risk = self.copyright_controller.check_copyright_risk({
            "type": "text",
            "data": text_content["content"]
        })
        
        return {
            "text_content": text_content,
            "image_content": image_content,
            "quality_score": text_quality["overall_score"],
            "copyright_risk": copyright_risk,
            "ready_for_publish": (
                text_quality["overall_score"] > 0.8 and 
                copyright_risk["risk_level"] == "low"
            )
        }