# 示例：使用LLM生成架构设计文档
import openai

def generate_architecture_design(requirement):
    prompt = f"""
    作为系统架构师，基于以下需求生成架构设计文档：

    需求：{requirement}

    请提供：
    1. 系统架构图（使用Mermaid语法）
    2. 核心组件说明
    3. 数据流设计
    4. 技术栈选型及理由
    5. 非功能性需求分析
    6. 潜在风险与应对策略

    输出格式：结构化Markdown
    """

    response = openai.ChatCompletion.create(
        model="gpt-4-turbo",
        messages=[{"role": "user", "content": prompt}],
        temperature=0.3
    )

    return response.choices[0].message.content

# 使用示例
requirement = """
设计一个企业级知识管理系统，支持：
- 多租户架构
- 文档上传与智能检索
- 权限管理
- 协作编辑
- 多语言支持
- 每日百万级访问量
"""

architecture_doc = generate_architecture_design(requirement)
print(architecture_doc)

def microservices_design_assistant(requirements, constraints):
    """
    LLM辅助微服务架构设计
    """
    system_prompt = """
    你是微服务架构专家。基于业务需求和约束条件，
    设计合理的微服务拆分方案。

    输出格式：
    1. 服务拆分清单（服务名称、职责、接口）
    2. 服务间通信策略
    3. 数据一致性方案
    4. 技术栈推荐
    5. 运维监控方案
    """

    user_prompt = f"""
    业务需求：{requirements}
    技术约束：{constraints}
    """

    response = llm_generate(system_prompt, user_prompt)
    return parse_architecture(response)

# 使用示例
requirements = """
电商系统，包含：商品管理、订单处理、支付、
库存、用户、推荐、搜索、营销活动
"""

constraints = """
- 订单量峰值：10万单/小时
- 数据一致性要求：最终一致性可接受
- 团队规模：20人
- 技术栈倾向：Go/Java + gRPC + Kafka
"""

design = microservices_design_assistant(requirements, constraints)

# LLM辅助RESTful API设计
def design_api_with_llm(business_requirement):
    prompt = f"""
    基于以下业务需求，设计RESTful API：

    {business_requirement}

    要求：
    1. 遵循RESTful最佳实践
    2. 包含完整的端点定义
    3. 请求/响应示例
    4. 错误码设计
    5. 版本控制策略
    6. 认证授权方案
    7. 限流策略
    """

    return llm_generate(prompt)

# 输出示例（LLM生成）
"""
## API设计文档

### 1. 端点定义

#### 1.1 创建订单

# 完整的开发流水线示例
class LLMPoweredDevelopment:
    def __init__(self):
        self.llm = LLMClient()

    def generate_feature(self, requirement):
        """从需求到完整实现"""

        # 1. 需求分析
        analysis = self.analyze_requirement(requirement)

        # 2. 架构设计
        architecture = self.design_architecture(analysis)

        # 3. API设计
        api_spec = self.design_api(architecture)

        # 4. 数据库设计
        db_schema = self.design_database(api_spec)

        # 5. 代码生成
        code = self.generate_code(api_spec, db_schema)

        # 6. 测试生成
        tests = self.generate_tests(code)

        # 7. 文档生成
        docs = self.generate_docs(api_spec, code)

        return {
            'architecture': architecture,
            'api_spec': api_spec,
            'db_schema': db_schema,
            'code': code,
            'tests': tests,
            'docs': docs
        }

    def generate_code(self, api_spec, db_schema):
        """生成生产级代码"""

        prompt = f"""
        基于以下API规范和数据库Schema，生成完整的后端代码：

        API规范：
        {api_spec}

        数据库Schema：
        {db_schema}

        技术栈：Python + FastAPI + SQLAlchemy + PostgreSQL

        要求：
        1. 完整的项目结构
        2. 数据模型定义
        3. API路由实现
        4. 依赖注入
        5. 异常处理
        6. 日志记录
        7. 类型注解
        8. 配置管理
        9. 遵循Clean Architecture
        """

        return self.llm.generate(prompt)

def llm_code_review(code, context=""):
    """LLM辅助代码审查"""

    prompt = f"""
    作为资深架构师，审查以下代码：

    上下文：
    {context}

    代码：
    ```python
    {code}

# 配置文件示例
KNOWLEDGE_SYSTEM_CONFIG = {
    "llm_instances": {
        "search": {
            "model": "Qwen2.5-7B-Instruct",
            "deployment": "local",
            "reason": "低延迟，适合批量文档检索"
        },
        "summary": {
            "model": "Gemma-2-13B",
            "deployment": "cloud",
            "reason": "平衡成本与质量，适合摘要任务"
        },
        "qa": {
            "model": "DeepSeek-V3-34B",
            "deployment": "cloud",
            "reason": "强推理能力，适合复杂问答"
        },
        "analysis": {
            "model": "Claude-4-200K",
            "deployment": "cloud",
            "reason": "长上下文，适合深度分析"
        }
    },
    "vector_db": {
        "engine": "Milvus",
        "embedding_model": "bge-m3",
        "dimension": 1024,
        "index_type": "HNSW"
    },
    "caching": {
        "redis_cluster": True,
        "semantic_cache": True,
        "cache_ttl": 3600
    }
}

class IntelligentCodeReview:
    def __init__(self):
        self.router = TaskRouter()
        self.code_llm = CodeLLM(model="StarCoder2-15B")
        self.security_llm = SecurityLLM(model="DeepSeek-V3-34B")

    def review_pull_request(self, pr_diff, repo_context):
        """智能代码审查"""

        # 1. 任务分解
        tasks = self.router.decompose_tasks(pr_diff, repo_context)

        # 2. 并行执行
        results = asyncio.gather(*[
            self._run_task(task) for task in tasks
        ])

        # 3. 结果整合
        report = self._generate_report(results)

        return report

    async def _run_task(self, task):
        """执行单个审查任务"""

        if task.type == "quality":
            return await self.code_llm.analyze_quality(
                code=task.code,
                context=task.context
            )
        elif task.type == "security":
            return await self.security_llm.scan_vulnerabilities(
                code=task.code
            )
        elif task.type == "performance":
            return await self.code_llm.check_performance(
                code=task.code
            )

    def _generate_report(self, results):
        """生成审查报告"""

        prompt = f"""
        整合以下代码审查结果，生成结构化报告：

        {results}

        输出格式：
        - 总体评分
        - 关键问题（按优先级）
        - 改进建议
        - 最佳实践推荐
        """

        return self.llm.generate(prompt)

# LLMOps监控指标示例
LLM_MONITORING_METRICS = {
    "performance": {
        "latency": "响应时间（p50/p95/p99）",
        "throughput": "每秒请求数",
        "token_usage": "Token消耗统计",
        "cost": "成本追踪"
    },
    "quality": {
        "accuracy": "准确率",
        "relevance": "相关性评分",
        "hallucination": "幻觉率",
        "consistency": "一致性检查"
    },
    "reliability": {
        "error_rate": "错误率",
        "timeout_rate": "超时率",
        "fallback_rate": "降级触发率",
        "availability": "可用性"
    },
    "business": {
        "user_satisfaction": "用户满意度",
        "task_completion": "任务完成率",
        "time_saved": "节省时间",
        "roi": "投资回报率"
    }
}

# 示例代码：用户认证服务
class AuthService:
    def __init__(self, db_connector):
        self.db = db_connector

    def authenticate(self, username, password):
        user = self.db.get_user(username)
        if not user:
            return {'success': False, 'error': 'USER_NOT_FOUND'}

        if not self._verify_password(password, user['password_hash']):
            return {'success': False, 'error': 'INVALID_PASSWORD'}

        return {'success': True, 'user_id': user['id']}

    def _verify_password(self, password, hash):
        # 密码验证逻辑
        return True

import pytest
from unittest.mock import Mock, patch
from auth_service import AuthService

class TestAuthService:
    @pytest.fixture
    def mock_db(self):
        return Mock()

    @pytest.fixture
    def auth_service(self, mock_db):
        return AuthService(mock_db)

    def test_authenticate_success(self, auth_service, mock_db):
        # Arrange
        mock_db.get_user.return_value = {
            'id': '123',
            'password_hash': 'hashed_password'
        }
        auth_service._verify_password = Mock(return_value=True)

        # Act
        result = auth_service.authenticate('testuser', 'password123')

        # Assert
        assert result['success'] == True
        assert result['user_id'] == '123'

    def test_authenticate_user_not_found(self, auth_service, mock_db):
        # Arrange
        mock_db.get_user.return_value = None

        # Act
        result = auth_service.authenticate('nonexistent', 'password')

        # Assert
        assert result['success'] == False
        assert result['error'] == 'USER_NOT_FOUND'

    def test_authenticate_invalid_password(self, auth_service, mock_db):
        # Arrange
        mock_db.get_user.return_value = {
            'id': '123',
            'password_hash': 'hashed_password'
        }
        auth_service._verify_password = Mock(return_value=False)

        # Act
        result = auth_service.authenticate('testuser', 'wrongpassword')

        # Assert
        assert result['success'] == False
        assert result['error'] == 'INVALID_PASSWORD'

    # AI自动生成的边界条件测试
    def test_authenticate_empty_credentials(self, auth_service, mock_db):
        result = auth_service.authenticate('', '')
        assert result['success'] == False

    @pytest.mark.parametrize("username,password,expected", [
        ('admin', '', 'INVALID_PASSWORD'),
        ('', 'password', 'USER_NOT_FOUND'),
        ('a' * 100, 'pass', 'USER_NOT_FOUND'),
    ])
    def test_authenticate_edge_cases(self, auth_service, mock_db, username, password, expected):
        result = auth_service.authenticate(username, password)
        assert result['error'] == expected

import pytest
from fastapi.testclient import TestClient
from unittest.mock import patch, MagicMock
from datetime import datetime, timedelta
import json

@pytest.fixture
def client():
    from main import app
    return TestClient(app)

@pytest.fixture
def test_db():
    # 使用内存数据库进行测试
    pass

class TestOrderWorkflow:
    @patch('services.payment_gateway.charge')
    @patch('services.inventory.check_stock')
    def test_successful_order_flow(self, mock_payment, mock_inventory, client, test_db):
        # 准备测试数据
        order_data = {
            'user_id': 'user123',
            'items': [{'product_id': 'prod1', 'quantity': 2}],
            'total': 100.00
        }

        # Mock外部服务
        mock_inventory.return_value = {'available': True}
        mock_payment.return_value = {'success': True, 'transaction_id': 'tx123'}

        # Step 1: 创建订单
        response = client.post('/api/orders', json=order_data)
        assert response.status_code == 200
        order_id = response.json()['order_id']

        # Step 2: 验证订单状态
        response = client.get(f'/api/orders/{order_id}')
        order = response.json()
        assert order['status'] == 'PENDING_PAYMENT'

        # Step 3: 模拟支付回调
        payment_data = {
            'transaction_id': 'tx123',
            'amount': 100.00,
            'status': 'SUCCESS'
        }
        response = client.post(f'/api/orders/{order_id}/payment', json=payment_data)
        assert response.status_code == 200

        # Step 4: 验证最终状态
        response = client.get(f'/api/orders/{order_id}')
        order = response.json()
        assert order['status'] == 'PAID'

    @patch('services.inventory.check_stock')
    def test_insufficient_stock_scenario(self, mock_inventory, client, test_db):
        order_data = {
            'user_id': 'user123',
            'items': [{'product_id': 'prod1', 'quantity': 100}],
            'total': 5000.00
        }

        mock_inventory.return_value = {'available': False}

        response = client.post('/api/orders', json=order_data)
        assert response.status_code == 200
        order = response.json()
        assert order['status'] == 'OUT_OF_STOCK'

    # AI生成的性能测试
    def test_concurrent_order_creation(self, client, test_db):
        import threading
        results = []
        orders = []

        def create_order():
            order_data = {
                'user_id': 'user123',
                'items': [{'product_id': 'prod1', 'quantity': 1}],
                'total': 50.00
            }
            response = client.post('/api/orders', json=order_data)
            results.append(response.status_code)
            if response.status_code == 200:
                orders.append(response.json())

        threads = [threading.Thread(target=create_order) for _ in range(10)]
        for t in threads:
            t.start()
        for t in threads:
            t.join()

        assert all(status in [200, 429] for status in results)  # 成功或限流

from locust import HttpUser, task, between, events
from locust.runners import MasterRunner
import time
import json

class ProductAPIUser(HttpUser):
    wait_time = between(1, 3)

    def on_start(self):
        """用户初始化，可能需要登录"""
        self.client.post('/api/auth/login', json={
            'username': 'perf_test_user',
            'password': 'test123'
        })

    @task(3)
    def browse_products(self):
        """浏览商品列表（高频操作）"""
        categories = ['electronics', 'clothing', 'home', 'sports']
        category = categories[self.user.environment.runner.user_count % len(categories)]

        with self.client.get(
            f'/api/products?category={category}&page=1',
            catch_response=True,
            name='/api/products'
        ) as response:
            if response.status_code == 200:
                data = response.json()
                if len(data['products']) == 0:
                    response.failure('Empty product list')
            else:
                response.failure(f'Got status {response.status_code}')

    @task(2)
    def search_products(self):
        """搜索商品（中频操作）"""
        search_terms = ['laptop', 'phone', 'shoes', 'watch']
        term = search_terms[time.time_ns() % len(search_terms)]

        self.client.get(f'/api/products/search?q={term}', name='/api/products/search')

    @task(1)
    def view_product_details(self):
        """查看商品详情（低频操作）"""
        product_id = f'prod_{time.time_ns() % 1000}'
        self.client.get(f'/api/products/{product_id}', name='/api/products/[id]')

# AI添加的性能监控插件
class PerformanceMonitor:
    @events.test_stop.add_listener
    def on_test_stop(environment, **kwargs):
        """测试结束后生成性能报告"""
        if not isinstance(environment.runner, MasterRunner):
            stats = environment.stats

            print("\n" + "="*50)
            print("PERFORMANCE TEST SUMMARY")
            print("="*50)
            print(f"Total Requests: {stats.total.num_requests}")
            print(f"Failure Rate: {stats.total.fail_ratio * 100:.2f}%")
            print(f"Median Response Time: {stats.total.median_response_time:.2f}ms")
            print(f"P95 Response Time: {stats.total.get_response_time_percentile(0.95):.2f}ms")
            print(f"P99 Response Time: {stats.total.get_response_time_percentile(0.99):.2f}ms")
            print(f"Requests/Second: {stats.total.total_rps:.2f}")

            # AI添加的性能瓶颈分析
            if stats.total.get_response_time_percentile(0.95) > 200:
                print("\n⚠️  PERFORMANCE BOTTLENECK DETECTED:")
                print("   - P95 response time exceeds 200ms threshold")
                print("   Suggested actions:")
                print("   1. Check database query execution plans")
                print("   2. Verify index usage on frequently queried fields")
                print("   3. Consider implementing caching layer")
                print("   4. Evaluate horizontal scaling options")

            # AI生成的优化建议
            if stats.total.fail_ratio > 0.01:  # 失败率超过1%
                print("\n⚠️  HIGH ERROR RATE DETECTED:")
                print("   - Investigate error logs for patterns")
                print("   - Check resource exhaustion (memory/CPU)")
                print("   - Verify database connection pool limits")

# 启动命令建议（AI生成）
"""
locust -f performance_test.py --host=http://localhost:8000
  --users 500 --spawn-rate 50 --run-time 5m

# 渐进式压测
locust -f performance_test.py --host=http://localhost:8000
  --users 100 --spawn-rate 10 --run-time 2m  # 第一阶段
locust -f performance_test.py --host=http://localhost:8000
  --users 300 --spawn-rate 30 --run-time 2m  # 第二阶段
locust -f performance_test.py --host=http://localhost:8000
  --users 500 --spawn-rate 50 --run-time 5m  # 最终压测
"""

# AI提供的核心业务逻辑伪代码
class SubscriptionService:
    def create_subscription(self, user_id: str, plan_id: str, trial_days: int = 0):
        """
        创建订阅
        边界条件：
        - 用户已有活跃订阅时需要先取消
        - 试用套餐不能升级到更低套餐
        - 年付套餐退款比例需要计算
        """
        pass

    def check_subscription_status(self, user_id: str) -> Dict:
        """
        检查用户订阅状态
        返回：
        - is_active: 是否有效
        - plan_details: 套餐详情
        - remaining_days: 剩余天数
        - features: 可用特性列表
        """
        pass

    def handle_renewal(self, subscription_id: str):
        """
        处理续费
        需要处理：
        - 支付失败重试逻辑
        - 套餐价格变动时的处理
        - 多订阅合并逻辑
        """
        pass

from sqlalchemy import and_, or_
from datetime import datetime, timedelta
from typing import Optional
import uuid

class SubscriptionService:
    def __init__(self, db_session, payment_service):
        self.db = db_session
        self.payment = payment_service

    def create_subscription(
        self,
        user_id: str,
        plan_id: str,
        trial_days: int = 0,
        auto_renew: bool = True
    ) -> Optional['UserSubscription']:
        """
        创建用户订阅

        Args:
            user_id: 用户ID
            plan_id: 套餐ID
            trial_days: 试用天数（默认为0）
            auto_renew: 是否自动续费

        Returns:
            创建的订阅对象，失败返回None

        Raises:
            ValueError: 参数验证失败
            AlreadySubscribedError: 用户已有活跃订阅
            PlanNotFoundError: 套餐不存在
        """
        # 1. 验证套餐存在
        plan = self.db.query(SubscriptionPlan).filter_by(id=plan_id).first()
        if not plan:
            raise PlanNotFoundError(f"Plan {plan_id} not found")

        # 2. 检查用户是否已有活跃订阅（使用锁防止并发问题）
        existing = self.db.query(UserSubscription).filter(
            and_(
                UserSubscription.user_id == user_id,
                UserSubscription.status.in_(['trial', 'active'])
            )
            ).with_for_update().first()

        if existing:
            raise AlreadySubscribedError(
                f"User {user_id} already has active subscription: {existing.id}"
            )

        # 3. 计算开始和结束时间
        now = datetime.utcnow()
        if trial_days > 0:
            trial_end = now + timedelta(days=trial_days)
            # 试用期间的billing从试用期结束开始
            if plan.billing_cycle == 'monthly':
                billing_end = trial_end + timedelta(days=30)
            else:
                billing_end = trial_end + timedelta(days=365)
        else:
            trial_end = None
            if plan.billing_cycle == 'monthly':
                billing_end = now + timedelta(days=30)
            else:
                billing_end = now + timedelta(days=365)

        # 4. 创建订阅记录
        subscription = UserSubscription(
            id=str(uuid.uuid4()),
            user_id=user_id,
            plan_id=plan_id,
            status='trial' if trial_days > 0 else 'active',
            trial_end_at=trial_end,
            billing_start_at=now if trial_days == 0 else trial_end,
            billing_end_at=billing_end,
            auto_renew=auto_renew
        )

        # 5. 保存到数据库
        self.db.add(subscription)

        try:
            self.db.commit()
            self.db.refresh(subscription)
            return subscription
        except Exception as e:
            self.db.rollback()
            raise SubscriptionCreationError(f"Failed to create subscription: {str(e)}")

# 原始代码
def get_user_orders(user_id: int):
    orders = db.execute(
        f"SELECT * FROM orders WHERE user_id = {user_id}"
    ).fetchall()
    return [dict(order) for order in orders]