insightflow/backend/main.py

#!/usr/bin/env python3
"""
InsightFlow Backend - Phase 6 (API Platform)
API 开放平台：API Key 管理、Swagger 文档、限流
Knowledge Growth: Multi-file fusion + Entity Alignment + Document Import
ASR: 阿里云听悟 + OSS
"""

import os
import sys
import json
import hashlib
import secrets
import httpx
import uuid
import re
import io
import time
from fastapi import FastAPI, File, UploadFile, HTTPException, Form, Depends, Header, Request
from fastapi.middleware.cors import CORSMiddleware
from fastapi.staticfiles import StaticFiles
from fastapi.responses import JSONResponse
from pydantic import BaseModel, Field
from typing import List, Optional, Union, Dict
from datetime import datetime

# Add backend directory to path for imports
backend_dir = os.path.dirname(os.path.abspath(__file__))
if backend_dir not in sys.path:
    sys.path.insert(0, backend_dir)

# Import clients
try:
    from oss_uploader import get_oss_uploader
    OSS_AVAILABLE = True
except ImportError:
    OSS_AVAILABLE = False

try:
    from tingwu_client import TingwuClient
    TINGWU_AVAILABLE = True
except ImportError:
    TINGWU_AVAILABLE = False

try:
    from db_manager import get_db_manager, Project, Entity, EntityMention
    DB_AVAILABLE = True
except ImportError as e:
    print(f"DB import error: {e}")
    DB_AVAILABLE = False

try:
    from document_processor import DocumentProcessor
    DOC_PROCESSOR_AVAILABLE = True
except ImportError:
    DOC_PROCESSOR_AVAILABLE = False

try:
    from entity_aligner import EntityAligner
    ALIGNER_AVAILABLE = True
except ImportError:
    ALIGNER_AVAILABLE = False

try:
    from llm_client import get_llm_client, ChatMessage
    LLM_CLIENT_AVAILABLE = True
except ImportError:
    LLM_CLIENT_AVAILABLE = False

try:
    from knowledge_reasoner import get_knowledge_reasoner, KnowledgeReasoner, ReasoningType
    REASONER_AVAILABLE = True
except ImportError:
    REASONER_AVAILABLE = False

try:
    from export_manager import get_export_manager, ExportEntity, ExportRelation, ExportTranscript
    EXPORT_AVAILABLE = True
except ImportError:
    EXPORT_AVAILABLE = False

try:
    from neo4j_manager import get_neo4j_manager, sync_project_to_neo4j, NEO4J_AVAILABLE
except ImportError:
    NEO4J_AVAILABLE = False

# Phase 6: API Key Manager
try:
    from api_key_manager import get_api_key_manager, ApiKeyManager, ApiKey
    API_KEY_AVAILABLE = True
except ImportError as e:
    print(f"API Key Manager import error: {e}")
    API_KEY_AVAILABLE = False

# Phase 6: Rate Limiter
try:
    from rate_limiter import get_rate_limiter, RateLimitConfig, RateLimitInfo
    RATE_LIMITER_AVAILABLE = True
except ImportError as e:
    print(f"Rate Limiter import error: {e}")
    RATE_LIMITER_AVAILABLE = False

# Phase 7: Workflow Manager
try:
    from workflow_manager import (
        get_workflow_manager, WorkflowManager, Workflow, WorkflowTask,
        WebhookConfig, WorkflowLog, WorkflowType, WebhookType, TaskStatus
    )
    WORKFLOW_AVAILABLE = True
except ImportError as e:
    print(f"Workflow Manager import error: {e}")
    WORKFLOW_AVAILABLE = False

# Phase 7: Multimodal Support
try:
    from multimodal_processor import (
        get_multimodal_processor, MultimodalProcessor,
        VideoProcessingResult, VideoFrame
    )
    MULTIMODAL_AVAILABLE = True
except ImportError as e:
    print(f"Multimodal Processor import error: {e}")
    MULTIMODAL_AVAILABLE = False

try:
    from image_processor import (
        get_image_processor, ImageProcessor,
        ImageProcessingResult, ImageEntity, ImageRelation
    )
    IMAGE_PROCESSOR_AVAILABLE = True
except ImportError as e:
    print(f"Image Processor import error: {e}")
    IMAGE_PROCESSOR_AVAILABLE = False

try:
    from multimodal_entity_linker import (
        get_multimodal_entity_linker, MultimodalEntityLinker,
        MultimodalEntity, EntityLink, AlignmentResult, FusionResult
    )
    MULTIMODAL_LINKER_AVAILABLE = True
except ImportError as e:
    print(f"Multimodal Entity Linker import error: {e}")
    MULTIMODAL_LINKER_AVAILABLE = False

# Phase 7 Task 7: Plugin Manager
try:
    from plugin_manager import (
        get_plugin_manager, PluginManager, Plugin,
        BotSession, WebhookEndpoint, WebDAVSync,
        PluginType, PluginStatus, ChromeExtensionHandler, BotHandler,
        WebhookIntegration
    )
    PLUGIN_MANAGER_AVAILABLE = True
except ImportError as e:
    print(f"Plugin Manager import error: {e}")
    PLUGIN_MANAGER_AVAILABLE = False

# Phase 7 Task 3: Security Manager
try:
    from security_manager import (
        get_security_manager, SecurityManager,
        AuditLog, EncryptionConfig, MaskingRule, DataAccessPolicy, AccessRequest,
        AuditActionType, MaskingRuleType
    )
    SECURITY_MANAGER_AVAILABLE = True
except ImportError as e:
    print(f"Security Manager import error: {e}")
    SECURITY_MANAGER_AVAILABLE = False

# Phase 7 Task 4: Collaboration Manager
try:
    from collaboration_manager import (
        get_collaboration_manager, CollaborationManager,
        ProjectSharing, CommentManager, ChangeHistoryTracker, TeamSpaceManager,
        ProjectShare, Comment, ChangeHistory, TeamSpace, TeamMember, Invitation,
        SharePermission, CommentTargetType, CommentStatus, ChangeActionType,
        TeamMemberRole, InvitationStatus
    )
    COLLABORATION_AVAILABLE = True
except ImportError as e:
    print(f"Collaboration Manager import error: {e}")
    COLLABORATION_AVAILABLE = False

# Phase 7 Task 5: Report Generator
try:
    from report_generator import (
        get_report_generator, ReportGenerator, ReportTemplate, Report,
        MeetingMinutes, ActionItem, ReportFormat, ReportType,
        TemplateField, TemplateFieldType, NetworkAnalysis
    )
    REPORT_GENERATOR_AVAILABLE = True
except ImportError as e:
    print(f"Report Generator import error: {e}")
    REPORT_GENERATOR_AVAILABLE = False

# Phase 7 Task 6: Search Manager
try:
    from search_manager import (
        get_search_manager, SearchManager,
        FullTextSearch, SemanticSearch,
        EntityPathDiscovery, KnowledgeGapDetection,
        SearchResult, SemanticSearchResult, EntityPath, KnowledgeGap
    )
    SEARCH_MANAGER_AVAILABLE = True
except ImportError as e:
    print(f"Search Manager import error: {e}")
    SEARCH_MANAGER_AVAILABLE = False

# Phase 7 Task 8: Performance Manager
try:
    from performance_manager import (
        get_performance_manager, PerformanceManager,
        CacheManager, DatabaseSharding, TaskQueue, PerformanceMonitor
    )
    PERFORMANCE_MANAGER_AVAILABLE = True
except ImportError as e:
    print(f"Performance Manager import error: {e}")
    PERFORMANCE_MANAGER_AVAILABLE = False

# Phase 7 Task 6: Search Manager
try:
    from search_manager import (
        get_search_manager, SearchManager, FullTextSearch, SemanticSearch,
        EntityPathDiscovery, KnowledgeGapDetector,
        SearchOperator, SearchField
    )
    SEARCH_MANAGER_AVAILABLE = True
except ImportError as e:
    print(f"Search Manager import error: {e}")
    SEARCH_MANAGER_AVAILABLE = False

# Phase 7 Task 8: Performance Manager
try:
    from performance_manager import (
        get_performance_manager, PerformanceManager, CacheManager,
        DatabaseSharding, TaskQueue, PerformanceMonitor,
        CacheStats, TaskInfo, PerformanceMetric, TaskStatus, TaskPriority
    )
    PERFORMANCE_MANAGER_AVAILABLE = True
except ImportError as e:
    print(f"Performance Manager import error: {e}")
    PERFORMANCE_MANAGER_AVAILABLE = False

# Phase 8: Tenant Manager (Multi-Tenant SaaS)
try:
    from tenant_manager import (
        get_tenant_manager, TenantManager, Tenant, TenantDomain, TenantBranding,
        TenantMember, TenantRole, TenantStatus, TenantTier, DomainStatus,
        TenantContext
    )
    TENANT_MANAGER_AVAILABLE = True
except ImportError as e:
    print(f"Tenant Manager import error: {e}")
    TENANT_MANAGER_AVAILABLE = False

# Phase 8: Subscription Manager
try:
    from subscription_manager import (
        get_subscription_manager, SubscriptionManager, SubscriptionPlan, Subscription,
        UsageRecord, Payment, Invoice, Refund, BillingHistory,
        SubscriptionStatus, PaymentProvider, PaymentStatus, InvoiceStatus, RefundStatus
    )
    SUBSCRIPTION_MANAGER_AVAILABLE = True
except ImportError as e:
    print(f"Subscription Manager import error: {e}")
    SUBSCRIPTION_MANAGER_AVAILABLE = False

# Phase 8: Enterprise Manager
try:
    from enterprise_manager import (
        get_enterprise_manager, EnterpriseManager, SSOConfig, SCIMConfig, SCIMUser,
        AuditLogExport, DataRetentionPolicy, DataRetentionJob,
        SAMLAuthRequest, SAMLAuthResponse,
        SSOProvider, SSOStatus, SCIMSyncStatus, AuditLogExportFormat,
        DataRetentionAction, ComplianceStandard
    )
    ENTERPRISE_MANAGER_AVAILABLE = True
except ImportError as e:
    print(f"Enterprise Manager import error: {e}")
    ENTERPRISE_MANAGER_AVAILABLE = False

# FastAPI app with enhanced metadata for Swagger
app = FastAPI(
    title="InsightFlow API",
    description="""
    InsightFlow 知识管理平台 API
    
    ## 功能
    
    * **项目管理** - 创建、读取、更新、删除项目
    * **实体管理** - 实体提取、对齐、属性管理
    * **关系管理** - 实体关系创建、查询、分析
    * **转录管理** - 音频转录、文档导入
    * **知识推理** - 因果推理、对比分析、时序分析
    * **图分析** - Neo4j 图数据库集成、路径查询
    * **导出功能** - 多种格式导出（PDF、Excel、CSV、JSON）
    * **工作流** - 自动化任务、Webhook 通知
    
    ## 认证
    
    大部分 API 需要 API Key 认证。在请求头中添加：
    ```
    X-API-Key: your_api_key_here
    ```
    """,
    version="0.7.0",
    contact={
        "name": "InsightFlow Team",
        "url": "https://github.com/insightflow/insightflow",
    },
    license_info={
        "name": "MIT",
        "url": "https://opensource.org/licenses/MIT",
    },
    openapi_tags=[
        {"name": "Projects", "description": "项目管理"},
        {"name": "Entities", "description": "实体管理"},
        {"name": "Relations", "description": "关系管理"},
        {"name": "Transcripts", "description": "转录管理"},
        {"name": "Analysis", "description": "分析和推理"},
        {"name": "Graph", "description": "图分析和 Neo4j"},
        {"name": "Export", "description": "数据导出"},
        {"name": "API Keys", "description": "API 密钥管理"},
        {"name": "Workflows", "description": "工作流自动化"},
        {"name": "Webhooks", "description": "Webhook 配置"},
        {"name": "Multimodal", "description": "多模态支持（视频、图片）"},
        {"name": "Plugins", "description": "插件管理"},
        {"name": "Chrome Extension", "description": "Chrome 扩展集成"},
        {"name": "Bot", "description": "飞书/钉钉机器人"},
        {"name": "Integrations", "description": "Zapier/Make 集成"},
        {"name": "WebDAV", "description": "WebDAV 同步"},
        {"name": "Security", "description": "数据安全与合规（加密、脱敏、审计）"},
        {"name": "Tenants", "description": "多租户 SaaS 管理（租户、域名、品牌、成员）"},
        {"name": "Subscriptions", "description": "订阅与计费管理（计划、订阅、支付、发票、退款）"},
        {"name": "Enterprise", "description": "企业级功能（SSO/SAML、SCIM、审计日志导出、数据保留策略）"},
        {"name": "System", "description": "系统信息"},
    ]
)

app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# ==================== Phase 6: API Key Authentication & Rate Limiting ====================

# 公开访问的路径（不需要 API Key）
PUBLIC_PATHS = {
    "/", "/docs", "/openapi.json", "/redoc",
    "/api/v1/health", "/api/v1/status",
    "/api/v1/api-keys",  # POST 创建 API Key 不需要认证
}

# 管理路径（需要 master key）
ADMIN_PATHS = {
    "/api/v1/admin/",
}

# Master Key（用于管理所有 API Keys）
MASTER_KEY = os.getenv("INSIGHTFLOW_MASTER_KEY", "")


async def verify_api_key(request: Request, x_api_key: Optional[str] = Header(None, alias="X-API-Key")):
    """
    验证 API Key 的依赖函数
    
    - 公开路径不需要认证
    - 管理路径需要 master key
    - 其他路径需要有效的 API Key
    """
    path = request.url.path
    method = request.method
    
    # 公开路径直接放行
    if any(path.startswith(p) for p in PUBLIC_PATHS):
        return None
    
    # 创建 API Key 的端点不需要认证（但需要 master key 或其他验证）
    if path == "/api/v1/api-keys" and method == "POST":
        return None
    
    # 检查是否是管理路径
    if any(path.startswith(p) for p in ADMIN_PATHS):
        if not x_api_key or x_api_key != MASTER_KEY:
            raise HTTPException(
                status_code=403,
                detail="Admin access required. Provide valid master key in X-API-Key header."
            )
        return {"type": "admin", "key": x_api_key}
    
    # 其他路径需要有效的 API Key
    if not API_KEY_AVAILABLE:
        # API Key 模块不可用，允许访问（开发模式）
        return None
    
    if not x_api_key:
        raise HTTPException(
            status_code=401,
            detail="API Key required. Provide your key in X-API-Key header.",
            headers={"WWW-Authenticate": "ApiKey"}
        )
    
    # 验证 API Key
    key_manager = get_api_key_manager()
    api_key = key_manager.validate_key(x_api_key)
    
    if not api_key:
        raise HTTPException(
            status_code=401,
            detail="Invalid or expired API Key"
        )
    
    # 更新最后使用时间
    key_manager.update_last_used(api_key.id)
    
    # 将 API Key 信息存储在请求状态中，供后续使用
    request.state.api_key = api_key
    
    return {"type": "api_key", "key_id": api_key.id, "permissions": api_key.permissions}


async def rate_limit_middleware(request: Request, call_next):
    """
    限流中间件
    """
    if not RATE_LIMITER_AVAILABLE or not API_KEY_AVAILABLE:
        response = await call_next(request)
        return response
    
    path = request.url.path
    
    # 公开路径不限流
    if any(path.startswith(p) for p in PUBLIC_PATHS):
        response = await call_next(request)
        return response
    
    # 获取限流键
    limiter = get_rate_limiter()
    
    # 检查是否有 API Key
    x_api_key = request.headers.get("X-API-Key")
    
    if x_api_key and x_api_key == MASTER_KEY:
        # Master key 有更高的限流
        config = RateLimitConfig(requests_per_minute=1000)
        limit_key = f"master:{x_api_key[:16]}"
    elif hasattr(request.state, 'api_key') and request.state.api_key:
        # 使用 API Key 的限流配置
        api_key = request.state.api_key
        config = RateLimitConfig(requests_per_minute=api_key.rate_limit)
        limit_key = f"api_key:{api_key.id}"
    else:
        # IP 限流（未认证用户）
        client_ip = request.client.host if request.client else "unknown"
        config = RateLimitConfig(requests_per_minute=10)
        limit_key = f"ip:{client_ip}"
    
    # 检查限流
    info = await limiter.is_allowed(limit_key, config)
    
    if not info.allowed:
        return JSONResponse(
            status_code=429,
            content={
                "error": "Rate limit exceeded",
                "retry_after": info.retry_after,
                "limit": config.requests_per_minute,
                "window": "minute"
            },
            headers={
                "X-RateLimit-Limit": str(config.requests_per_minute),
                "X-RateLimit-Remaining": "0",
                "X-RateLimit-Reset": str(info.reset_time),
                "Retry-After": str(info.retry_after)
            }
        )
    
    # 继续处理请求
    start_time = time.time()
    response = await call_next(request)
    
    # 添加限流头
    response.headers["X-RateLimit-Limit"] = str(config.requests_per_minute)
    response.headers["X-RateLimit-Remaining"] = str(info.remaining)
    response.headers["X-RateLimit-Reset"] = str(info.reset_time)
    
    # 记录 API 调用日志
    try:
        if hasattr(request.state, 'api_key') and request.state.api_key:
            api_key = request.state.api_key
            response_time = int((time.time() - start_time) * 1000)
            key_manager = get_api_key_manager()
            key_manager.log_api_call(
                api_key_id=api_key.id,
                endpoint=path,
                method=request.method,
                status_code=response.status_code,
                response_time_ms=response_time,
                ip_address=request.client.host if request.client else "",
                user_agent=request.headers.get("User-Agent", "")
            )
    except Exception as e:
        # 日志记录失败不应影响主流程
        print(f"Failed to log API call: {e}")
    
    return response


# 添加限流中间件
app.middleware("http")(rate_limit_middleware)

# ==================== Phase 6: Pydantic Models for API ====================

# API Key 相关模型
class ApiKeyCreate(BaseModel):
    name: str = Field(..., description="API Key 名称/描述")
    permissions: List[str] = Field(default=["read"], description="权限列表: read, write, delete")
    rate_limit: int = Field(default=60, description="每分钟请求限制")
    expires_days: Optional[int] = Field(default=None, description="过期天数（可选）")


class ApiKeyResponse(BaseModel):
    id: str
    key_preview: str
    name: str
    permissions: List[str]
    rate_limit: int
    status: str
    created_at: str
    expires_at: Optional[str]
    last_used_at: Optional[str]
    total_calls: int


class ApiKeyCreateResponse(BaseModel):
    api_key: str = Field(..., description="API Key（仅显示一次，请妥善保存）")
    info: ApiKeyResponse


class ApiKeyListResponse(BaseModel):
    keys: List[ApiKeyResponse]
    total: int


class ApiKeyUpdate(BaseModel):
    name: Optional[str] = None
    permissions: Optional[List[str]] = None
    rate_limit: Optional[int] = None


class ApiCallStats(BaseModel):
    total_calls: int
    success_calls: int
    error_calls: int
    avg_response_time_ms: float
    max_response_time_ms: int
    min_response_time_ms: int


class ApiStatsResponse(BaseModel):
    summary: ApiCallStats
    endpoints: List[Dict]
    daily: List[Dict]


class ApiCallLog(BaseModel):
    id: int
    endpoint: str
    method: str
    status_code: int
    response_time_ms: int
    ip_address: str
    user_agent: str
    error_message: str
    created_at: str


class ApiLogsResponse(BaseModel):
    logs: List[ApiCallLog]
    total: int


class RateLimitStatus(BaseModel):
    limit: int
    remaining: int
    reset_time: int
    window: str


# 原有模型（保留）
class EntityModel(BaseModel):
    id: str
    name: str
    type: str
    definition: Optional[str] = ""
    aliases: List[str] = []

class TranscriptSegment(BaseModel):
    start: float
    end: float
    text: str
    speaker: Optional[str] = "Speaker A"

class AnalysisResult(BaseModel):
    transcript_id: str
    project_id: str
    segments: List[TranscriptSegment]
    entities: List[EntityModel]
    full_text: str
    created_at: str

class ProjectCreate(BaseModel):
    name: str
    description: str = ""

class EntityUpdate(BaseModel):
    name: Optional[str] = None
    type: Optional[str] = None
    definition: Optional[str] = None
    aliases: Optional[List[str]] = None

class RelationCreate(BaseModel):
    source_entity_id: str
    target_entity_id: str
    relation_type: str
    evidence: Optional[str] = ""

class TranscriptUpdate(BaseModel):
    full_text: str

class AgentQuery(BaseModel):
    query: str
    stream: bool = False

class AgentCommand(BaseModel):
    command: str

class EntityMergeRequest(BaseModel):
    source_entity_id: str
    target_entity_id: str

class GlossaryTermCreate(BaseModel):
    term: str
    pronunciation: Optional[str] = ""


# ==================== Phase 7: Workflow Pydantic Models ====================

class WorkflowCreate(BaseModel):
    name: str = Field(..., description="工作流名称")
    description: str = Field(default="", description="工作流描述")
    workflow_type: str = Field(..., description="工作流类型: auto_analyze, auto_align, auto_relation, scheduled_report, custom")
    project_id: str = Field(..., description="所属项目ID")
    schedule: Optional[str] = Field(default=None, description="调度表达式(cron或分钟数)")
    schedule_type: str = Field(default="manual", description="调度类型: manual, cron, interval")
    config: Dict = Field(default_factory=dict, description="工作流配置")
    webhook_ids: List[str] = Field(default_factory=list, description="关联的Webhook ID列表")


class WorkflowUpdate(BaseModel):
    name: Optional[str] = None
    description: Optional[str] = None
    status: Optional[str] = None  # active, paused, error, completed
    schedule: Optional[str] = None
    schedule_type: Optional[str] = None
    is_active: Optional[bool] = None
    config: Optional[Dict] = None
    webhook_ids: Optional[List[str]] = None


class WorkflowResponse(BaseModel):
    id: str
    name: str
    description: str
    workflow_type: str
    project_id: str
    status: str
    schedule: Optional[str]
    schedule_type: str
    config: Dict
    webhook_ids: List[str]
    is_active: bool
    created_at: str
    updated_at: str
    last_run_at: Optional[str]
    next_run_at: Optional[str]
    run_count: int
    success_count: int
    fail_count: int


class WorkflowListResponse(BaseModel):
    workflows: List[WorkflowResponse]
    total: int


class WorkflowTaskCreate(BaseModel):
    name: str = Field(..., description="任务名称")
    task_type: str = Field(..., description="任务类型: analyze, align, discover_relations, notify, custom")
    config: Dict = Field(default_factory=dict, description="任务配置")
    order: int = Field(default=0, description="执行顺序")
    depends_on: List[str] = Field(default_factory=list, description="依赖的任务ID列表")
    timeout_seconds: int = Field(default=300, description="超时时间(秒)")
    retry_count: int = Field(default=3, description="重试次数")
    retry_delay: int = Field(default=5, description="重试延迟(秒)")


class WorkflowTaskUpdate(BaseModel):
    name: Optional[str] = None
    task_type: Optional[str] = None
    config: Optional[Dict] = None
    order: Optional[int] = None
    depends_on: Optional[List[str]] = None
    timeout_seconds: Optional[int] = None
    retry_count: Optional[int] = None
    retry_delay: Optional[int] = None


class WorkflowTaskResponse(BaseModel):
    id: str
    workflow_id: str
    name: str
    task_type: str
    config: Dict
    order: int
    depends_on: List[str]
    timeout_seconds: int
    retry_count: int
    retry_delay: int
    created_at: str
    updated_at: str


class WebhookCreate(BaseModel):
    name: str = Field(..., description="Webhook名称")
    webhook_type: str = Field(..., description="Webhook类型: feishu, dingtalk, slack, custom")
    url: str = Field(..., description="Webhook URL")
    secret: str = Field(default="", description="签名密钥")
    headers: Dict = Field(default_factory=dict, description="自定义请求头")
    template: str = Field(default="", description="消息模板")


class WebhookUpdate(BaseModel):
    name: Optional[str] = None
    webhook_type: Optional[str] = None
    url: Optional[str] = None
    secret: Optional[str] = None
    headers: Optional[Dict] = None
    template: Optional[str] = None
    is_active: Optional[bool] = None


class WebhookResponse(BaseModel):
    id: str
    name: str
    webhook_type: str
    url: str
    headers: Dict
    template: str
    is_active: bool
    created_at: str
    updated_at: str
    last_used_at: Optional[str]
    success_count: int
    fail_count: int


class WebhookListResponse(BaseModel):
    webhooks: List[WebhookResponse]
    total: int


class WorkflowLogResponse(BaseModel):
    id: str
    workflow_id: str
    task_id: Optional[str]
    status: str
    start_time: Optional[str]
    end_time: Optional[str]
    duration_ms: int
    input_data: Dict
    output_data: Dict
    error_message: str
    created_at: str


class WorkflowLogListResponse(BaseModel):
    logs: List[WorkflowLogResponse]
    total: int


class WorkflowTriggerRequest(BaseModel):
    input_data: Dict = Field(default_factory=dict, description="工作流输入数据")


class WorkflowTriggerResponse(BaseModel):
    success: bool
    workflow_id: str
    log_id: str
    results: Dict
    duration_ms: int


class WorkflowStatsResponse(BaseModel):
    total: int
    success: int
    failed: int
    success_rate: float
    avg_duration_ms: float
    daily: List[Dict]


# API Keys
KIMI_API_KEY = os.getenv("KIMI_API_KEY", "")
KIMI_BASE_URL = os.getenv("KIMI_BASE_URL", "https://api.kimi.com/coding")

# Phase 3: Entity Aligner singleton
_aligner = None
def get_aligner():
    global _aligner
    if _aligner is None and ALIGNER_AVAILABLE:
        _aligner = EntityAligner()
    return _aligner

# Phase 3: Document Processor singleton
_doc_processor = None
def get_doc_processor():
    global _doc_processor
    if _doc_processor is None and DOC_PROCESSOR_AVAILABLE:
        _doc_processor = DocumentProcessor()
    return _doc_processor

# Phase 7 Task 4: Collaboration Manager singleton
_collaboration_manager = None
def get_collab_manager():
    global _collaboration_manager
    if _collaboration_manager is None and COLLABORATION_AVAILABLE:
        db = get_db_manager() if DB_AVAILABLE else None
        _collaboration_manager = get_collaboration_manager(db)
    return _collaboration_manager

# Phase 2: Entity Edit API
@app.put("/api/v1/entities/{entity_id}", tags=["Entities"])
async def update_entity(entity_id: str, update: EntityUpdate, _=Depends(verify_api_key)):
    """更新实体信息（名称、类型、定义、别名）"""
    if not DB_AVAILABLE:
        raise HTTPException(status_code=500, detail="Database not available")
    
    db = get_db_manager()
    entity = db.get_entity(entity_id)
    if not entity:
        raise HTTPException(status_code=404, detail="Entity not found")
    
    # 更新字段
    update_data = {k: v for k, v in update.dict().items() if v is not None}
    updated = db.update_entity(entity_id, **update_data)
    
    return {
        "id": updated.id,
        "name": updated.name,
        "type": updated.type,
        "definition": updated.definition,
        "aliases": updated.aliases
    }

@app.delete("/api/v1/entities/{entity_id}", tags=["Entities"])
async def delete_entity(entity_id: str, _=Depends(verify_api_key)):
    """删除实体"""
    if not DB_AVAILABLE:
        raise HTTPException(status_code=500, detail="Database not available")
    
    db = get_db_manager()
    entity = db.get_entity(entity_id)
    if not entity:
        raise HTTPException(status_code=404, detail="Entity not found")
    
    db.delete_entity(entity_id)
    return {"success": True, "message": f"Entity {entity_id} deleted"}

@app.post("/api/v1/entities/{entity_id}/merge", tags=["Entities"])
async def merge_entities_endpoint(entity_id: str, merge_req: EntityMergeRequest, _=Depends(verify_api_key)):
    """合并两个实体"""
    if not DB_AVAILABLE:
        raise HTTPException(status_code=500, detail="Database not available")
    
    db = get_db_manager()
    
    # 验证两个实体都存在
    source = db.get_entity(merge_req.source_entity_id)
    target = db.get_entity(merge_req.target_entity_id)
    
    if not source or not target:
        raise HTTPException(status_code=404, detail="Entity not found")
    
    result = db.merge_entities(merge_req.target_entity_id, merge_req.source_entity_id)
    return {
        "success": True,
        "merged_entity": {
            "id": result.id,
            "name": result.name,
            "type": result.type,
            "definition": result.definition,
            "aliases": result.aliases
        }
    }

# Phase 2: Relation Edit API
@app.post("/api/v1/projects/{project_id}/relations", tags=["Relations"])
async def create_relation_endpoint(project_id: str, relation: RelationCreate, _=Depends(verify_api_key)):
    """创建新的实体关系"""
    if not DB_AVAILABLE:
        raise HTTPException(status_code=500, detail="Database not available")
    
    db = get_db_manager()
    
    # 验证实体存在
    source = db.get_entity(relation.source_entity_id)
    target = db.get_entity(relation.target_entity_id)
    
    if not source or not target:
        raise HTTPException(status_code=404, detail="Source or target entity not found")
    
    relation_id = db.create_relation(
        project_id=project_id,
        source_entity_id=relation.source_entity_id,
        target_entity_id=relation.target_entity_id,
        relation_type=relation.relation_type,
        evidence=relation.evidence
    )
    
    return {
        "id": relation_id,
        "source_id": relation.source_entity_id,
        "target_id": relation.target_entity_id,
        "type": relation.relation_type,
        "success": True
    }

@app.delete("/api/v1/relations/{relation_id}", tags=["Relations"])
async def delete_relation(relation_id: str, _=Depends(verify_api_key)):
    """删除关系"""
    if not DB_AVAILABLE:
        raise HTTPException(status_code=500, detail="Database not available")
    
    db = get_db_manager()
    db.delete_relation(relation_id)
    return {"success": True, "message": f"Relation {relation_id} deleted"}

@app.put("/api/v1/relations/{relation_id}", tags=["Relations"])
async def update_relation(relation_id: str, relation: RelationCreate, _=Depends(verify_api_key)):
    """更新关系"""
    if not DB_AVAILABLE:
        raise HTTPException(status_code=500, detail="Database not available")
    
    db = get_db_manager()
    updated = db.update_relation(
        relation_id=relation_id,
        relation_type=relation.relation_type,
        evidence=relation.evidence
    )
    
    return {
        "id": relation_id,
        "type": updated["relation_type"],
        "evidence": updated["evidence"],
        "success": True
    }

# Phase 2: Transcript Edit API
@app.get("/api/v1/transcripts/{transcript_id}", tags=["Transcripts"])
async def get_transcript(transcript_id: str, _=Depends(verify_api_key)):
    """获取转录详情"""
    if not DB_AVAILABLE:
        raise HTTPException(status_code=500, detail="Database not available")
    
    db = get_db_manager()
    transcript = db.get_transcript(transcript_id)
    
    if not transcript:
        raise HTTPException(status_code=404, detail="Transcript not found")
    
    return transcript

@app.put("/api/v1/transcripts/{transcript_id}", tags=["Transcripts"])
async def update_transcript(transcript_id: str, update: TranscriptUpdate, _=Depends(verify_api_key)):
    """更新转录文本（人工修正）"""
    if not DB_AVAILABLE:
        raise HTTPException(status_code=500, detail="Database not available")
    
    db = get_db_manager()
    transcript = db.get_transcript(transcript_id)
    
    if not transcript:
        raise HTTPException(status_code=404, detail="Transcript not found")
    
    updated = db.update_transcript(transcript_id, update.full_text)
    return {
        "id": transcript_id,
        "full_text": updated["full_text"],
        "updated_at": updated["updated_at"],
        "success": True
    }

# Phase 2: Manual Entity Creation
class ManualEntityCreate(BaseModel):
    name: str
    type: str = "OTHER"
    definition: str = ""
    transcript_id: Optional[str] = None
    start_pos: Optional[int] = None
    end_pos: Optional[int] = None

@app.post("/api/v1/projects/{project_id}/entities", tags=["Entities"])
async def create_manual_entity(project_id: str, entity: ManualEntityCreate, _=Depends(verify_api_key)):
    """手动创建实体（划词新建）"""
    if not DB_AVAILABLE:
        raise HTTPException(status_code=500, detail="Database not available")
    
    db = get_db_manager()
    
    # 检查是否已存在
    existing = db.get_entity_by_name(project_id, entity.name)
    if existing:
        return {
            "id": existing.id,
            "name": existing.name,
            "type": existing.type,
            "existed": True
        }
    
    entity_id = str(uuid.uuid4())[:8]
    new_entity = db.create_entity(Entity(
        id=entity_id,
        project_id=project_id,
        name=entity.name,
        type=entity.type,
        definition=entity.definition
    ))
    
    # 如果有提及位置信息，保存提及
    if entity.transcript_id and entity.start_pos is not None and entity.end_pos is not None:
        transcript = db.get_transcript(entity.transcript_id)
        if transcript:
            text = transcript["full_text"]
            mention = EntityMention(
                id=str(uuid.uuid4())[:8],
                entity_id=entity_id,
                transcript_id=entity.transcript_id,
                start_pos=entity.start_pos,
                end_pos=entity.end_pos,
                text_snippet=text[max(0, entity.start_pos-20):min(len(text), entity.end_pos+20)],
                confidence=1.0
            )
            db.add_mention(mention)
    
    return {
        "id": new_entity.id,
        "name": new_entity.name,
        "type": new_entity.type,
        "definition": new_entity.definition,
        "success": True
    }

def transcribe_audio(audio_data: bytes, filename: str) -> dict:
    """转录音频：OSS上传 + 听悟转录"""
    
    # 1. 上传 OSS
    if not OSS_AVAILABLE:
        print("OSS not available, using mock")
        return mock_transcribe()
    
    try:
        uploader = get_oss_uploader()
        audio_url, object_name = uploader.upload_audio(audio_data, filename)
        print(f"Uploaded to OSS: {object_name}")
    except Exception as e:
        print(f"OSS upload failed: {e}")
        return mock_transcribe()
    
    # 2. 听悟转录
    if not TINGWU_AVAILABLE:
        print("Tingwu not available, using mock")
        return mock_transcribe()
    
    try:
        client = TingwuClient()
        result = client.transcribe(audio_url)
        print(f"Transcription complete: {len(result['segments'])} segments")
        return result
    except Exception as e:
        print(f"Tingwu failed: {e}")
        return mock_transcribe()

def mock_transcribe() -> dict:
    """Mock 转录结果"""
    return {
        "full_text": "我们今天讨论 Project Alpha 的进度，K8s 集群已经部署完成。",
        "segments": [
            {"start": 0.0, "end": 5.0, "text": "我们今天讨论 Project Alpha 的进度，K8s 集群已经部署完成。", "speaker": "Speaker A"}
        ]
    }

def extract_entities_with_llm(text: str) -> tuple[List[dict], List[dict]]:
    """使用 Kimi API 提取实体和关系
    
    Returns:
        (entities, relations): 实体列表和关系列表
    """
    if not KIMI_API_KEY or not text:
        return [], []
    
    prompt = f"""从以下会议文本中提取关键实体和它们之间的关系，以 JSON 格式返回：

文本：{text[:3000]}

要求：
1. entities: 每个实体包含 name(名称), type(类型: PROJECT/TECH/PERSON/ORG/OTHER), definition(一句话定义)
2. relations: 每个关系包含 source(源实体名), target(目标实体名), type(关系类型: belongs_to/works_with/depends_on/mentions/related)
3. 只返回 JSON 对象，格式: {{"entities": [...], "relations": [...]}}

示例：
{{
  "entities": [
    {{"name": "Project Alpha", "type": "PROJECT", "definition": "核心项目"}},
    {{"name": "K8s", "type": "TECH", "definition": "Kubernetes容器编排平台"}}
  ],
  "relations": [
    {{"source": "Project Alpha", "target": "K8s", "type": "depends_on"}}
  ]
}}
"""
    
    try:
        response = httpx.post(
            f"{KIMI_BASE_URL}/v1/chat/completions",
            headers={"Authorization": f"Bearer {KIMI_API_KEY}", "Content-Type": "application/json"},
            json={"model": "k2p5", "messages": [{"role": "user", "content": prompt}], "temperature": 0.1},
            timeout=60.0
        )
        response.raise_for_status()
        result = response.json()
        content = result["choices"][0]["message"]["content"]
        
        import re
        json_match = re.search(r'\{{.*?\}}', content, re.DOTALL)
        if json_match:
            data = json.loads(json_match.group())
            return data.get("entities", []), data.get("relations", [])
    except Exception as e:
        print(f"LLM extraction failed: {e}")
    
    return [], []

def align_entity(project_id: str, name: str, db, definition: str = "") -> Optional['Entity']:
    """实体对齐 - Phase 3: 使用 embedding 对齐"""
    # 1. 首先尝试精确匹配
    existing = db.get_entity_by_name(project_id, name)
    if existing:
        return existing
    
    # 2. 使用 embedding 对齐（如果可用）
    aligner = get_aligner()
    if aligner:
        similar = aligner.find_similar_entity(project_id, name, definition)
        if similar:
            return similar
    
    # 3. 回退到简单相似度匹配
    similar = db.find_similar_entities(project_id, name)
    if similar:
        return similar[0]
    
    return None

# API Endpoints

@app.post("/api/v1/projects", response_model=dict, tags=["Projects"])
async def create_project(project: ProjectCreate, _=Depends(verify_api_key)):
    """创建新项目"""
    if not DB_AVAILABLE:
        raise HTTPException(status_code=500, detail="Database not available")
    
    db = get_db_manager()
    project_id = str(uuid.uuid4())[:8]
    p = db.create_project(project_id, project.name, project.description)
    return {"id": p.id, "name": p.name, "description": p.description}

@app.get("/api/v1/projects", tags=["Projects"])
async def list_projects(_=Depends(verify_api_key)):
    """列出所有项目"""
    if not DB_AVAILABLE:
        return []
    
    db = get_db_manager()
    projects = db.list_projects()
    return [{"id": p.id, "name": p.name, "description": p.description} for p in projects]

@app.post("/api/v1/projects/{project_id}/upload", response_model=AnalysisResult, tags=["Projects"])
async def upload_audio(project_id: str, file: UploadFile = File(...), _=Depends(verify_api_key)):
    """上传音频到指定项目 - Phase 3: 支持多文件融合"""
    if not DB_AVAILABLE:
        raise HTTPException(status_code=500, detail="Database not available")
    
    db = get_db_manager()
    project = db.get_project(project_id)
    if not project:
        raise HTTPException(status_code=404, detail="Project not found")
    
    content = await file.read()
    
    # 转录
    print(f"Processing: {file.filename}")
    tw_result = transcribe_audio(content, file.filename)
    
    # 提取实体和关系
    print("Extracting entities and relations...")
    raw_entities, raw_relations = extract_entities_with_llm(tw_result["full_text"])
    
    # 保存转录记录
    transcript_id = str(uuid.uuid4())[:8]
    db.save_transcript(
        transcript_id=transcript_id,
        project_id=project_id,
        filename=file.filename,
        full_text=tw_result["full_text"]
    )
    
    # 实体对齐并保存 - Phase 3: 使用增强对齐
    aligned_entities = []
    entity_name_to_id = {}  # 用于关系映射
    
    for raw_ent in raw_entities:
        existing = align_entity(project_id, raw_ent["name"], db, raw_ent.get("definition", ""))
        
        if existing:
            ent_model = EntityModel(
                id=existing.id,
                name=existing.name,
                type=existing.type,
                definition=existing.definition,
                aliases=existing.aliases
            )
            entity_name_to_id[raw_ent["name"]] = existing.id
        else:
            new_ent = db.create_entity(Entity(
                id=str(uuid.uuid4())[:8],
                project_id=project_id,
                name=raw_ent["name"],
                type=raw_ent.get("type", "OTHER"),
                definition=raw_ent.get("definition", "")
            ))
            ent_model = EntityModel(
                id=new_ent.id,
                name=new_ent.name,
                type=new_ent.type,
                definition=new_ent.definition
            )
            entity_name_to_id[raw_ent["name"]] = new_ent.id
        
        aligned_entities.append(ent_model)
        
        # 保存实体提及位置
        full_text = tw_result["full_text"]
        name = raw_ent["name"]
        start_pos = 0
        while True:
            pos = full_text.find(name, start_pos)
            if pos == -1:
                break
            mention = EntityMention(
                id=str(uuid.uuid4())[:8],
                entity_id=entity_name_to_id[name],
                transcript_id=transcript_id,
                start_pos=pos,
                end_pos=pos + len(name),
                text_snippet=full_text[max(0, pos-20):min(len(full_text), pos+len(name)+20)],
                confidence=1.0
            )
            db.add_mention(mention)
            start_pos = pos + 1
    
    # 保存关系
    for rel in raw_relations:
        source_id = entity_name_to_id.get(rel.get("source", ""))
        target_id = entity_name_to_id.get(rel.get("target", ""))
        if source_id and target_id:
            db.create_relation(
                project_id=project_id,
                source_entity_id=source_id,
                target_entity_id=target_id,
                relation_type=rel.get("type", "related"),
                evidence=tw_result["full_text"][:200],
                transcript_id=transcript_id
            )
    
    # 构建片段
    segments = [TranscriptSegment(**seg) for seg in tw_result["segments"]]
    
    return AnalysisResult(
        transcript_id=transcript_id,
        project_id=project_id,
        segments=segments,
        entities=aligned_entities,
        full_text=tw_result["full_text"],
        created_at=datetime.now().isoformat()
    )

# Phase 3: Document Upload API
@app.post("/api/v1/projects/{project_id}/upload-document")
async def upload_document(project_id: str, file: UploadFile = File(...), _=Depends(verify_api_key)):
    """上传 PDF/DOCX 文档到指定项目"""
    if not DB_AVAILABLE:
        raise HTTPException(status_code=500, detail="Database not available")
    
    if not DOC_PROCESSOR_AVAILABLE:
        raise HTTPException(status_code=500, detail="Document processor not available")
    
    db = get_db_manager()
    project = db.get_project(project_id)
    if not project:
        raise HTTPException(status_code=404, detail="Project not found")
    
    content = await file.read()
    
    # 处理文档
    processor = get_doc_processor()
    try:
        result = processor.process(content, file.filename)
    except Exception as e:
        raise HTTPException(status_code=400, detail=f"Document processing failed: {str(e)}")
    
    # 保存文档转录记录
    transcript_id = str(uuid.uuid4())[:8]
    db.save_transcript(
        transcript_id=transcript_id,
        project_id=project_id,
        filename=file.filename,
        full_text=result["text"],
        transcript_type="document"
    )
    
    # 提取实体和关系
    raw_entities, raw_relations = extract_entities_with_llm(result["text"])
    
    # 实体对齐并保存
    aligned_entities = []
    entity_name_to_id = {}
    
    for raw_ent in raw_entities:
        existing = align_entity(project_id, raw_ent["name"], db, raw_ent.get("definition", ""))
        
        if existing:
            entity_name_to_id[raw_ent["name"]] = existing.id
            aligned_entities.append(EntityModel(
                id=existing.id,
                name=existing.name,
                type=existing.type,
                definition=existing.definition,
                aliases=existing.aliases
            ))
        else:
            new_ent = db.create_entity(Entity(
                id=str(uuid.uuid4())[:8],
                project_id=project_id,
                name=raw_ent["name"],
                type=raw_ent.get("type", "OTHER"),
                definition=raw_ent.get("definition", "")
            ))
            entity_name_to_id[raw_ent["name"]] = new_ent.id
            aligned_entities.append(EntityModel(
                id=new_ent.id,
                name=new_ent.name,
                type=new_ent.type,
                definition=new_ent.definition
            ))
        
        # 保存实体提及位置
        full_text = result["text"]
        name = raw_ent["name"]
        start_pos = 0
        while True:
            pos = full_text.find(name, start_pos)
            if pos == -1:
                break
            mention = EntityMention(
                id=str(uuid.uuid4())[:8],
                entity_id=entity_name_to_id[name],
                transcript_id=transcript_id,
                start_pos=pos,
                end_pos=pos + len(name),
                text_snippet=full_text[max(0, pos-20):min(len(full_text), pos+len(name)+20)],
                confidence=1.0
            )
            db.add_mention(mention)
            start_pos = pos + 1
    
    # 保存关系
    for rel in raw_relations:
        source_id = entity_name_to_id.get(rel.get("source", ""))
        target_id = entity_name_to_id.get(rel.get("target", ""))
        if source_id and target_id:
            db.create_relation(
                project_id=project_id,
                source_entity_id=source_id,
                target_entity_id=target_id,
                relation_type=rel.get("type", "related"),
                evidence=result["text"][:200],
                transcript_id=transcript_id
            )
    
    return {
        "transcript_id": transcript_id,
        "project_id": project_id,
        "filename": file.filename,
        "text_length": len(result["text"]),
        "entities": [e.dict() for e in aligned_entities],
        "created_at": datetime.now().isoformat()
    }

# Phase 3: Knowledge Base API
@app.get("/api/v1/projects/{project_id}/knowledge-base")
async def get_knowledge_base(project_id: str, _=Depends(verify_api_key)):
    """获取项目知识库 - 包含所有实体、关系、术语表"""
    if not DB_AVAILABLE:
        raise HTTPException(status_code=500, detail="Database not available")
    
    db = get_db_manager()
    project = db.get_project(project_id)
    if not project:
        raise HTTPException(status_code=404, detail="Project not found")
    
    # 获取所有实体
    entities = db.list_project_entities(project_id)
    
    # 获取所有关系
    relations = db.list_project_relations(project_id)
    
    # 获取所有转录
    transcripts = db.list_project_transcripts(project_id)
    
    # 获取术语表
    glossary = db.list_glossary(project_id)
    
    # 构建实体统计和属性
    entity_stats = {}
    entity_attributes = {}
    for ent in entities:
        mentions = db.get_entity_mentions(ent.id)
        entity_stats[ent.id] = {
            "mention_count": len(mentions),
            "transcript_ids": list(set([m.transcript_id for m in mentions]))
        }
        # Phase 5: 获取实体属性
        attrs = db.get_entity_attributes(ent.id)
        entity_attributes[ent.id] = attrs
    
    # 构建实体名称映射
    entity_map = {e.id: e.name for e in entities}
    
    return {
        "project": {
            "id": project.id,
            "name": project.name,
            "description": project.description
        },
        "stats": {
            "entity_count": len(entities),
            "relation_count": len(relations),
            "transcript_count": len(transcripts),
            "glossary_count": len(glossary)
        },
        "entities": [
            {
                "id": e.id,
                "name": e.name,
                "type": e.type,
                "definition": e.definition,
                "aliases": e.aliases,
                "mention_count": entity_stats.get(e.id, {}).get("mention_count", 0),
                "appears_in": entity_stats.get(e.id, {}).get("transcript_ids", []),
                "attributes": entity_attributes.get(e.id, [])  # Phase 5: 包含属性
            }
            for e in entities
        ],
        "relations": [
            {
                "id": r["id"],
                "source_id": r["source_entity_id"],
                "source_name": entity_map.get(r["source_entity_id"], "Unknown"),
                "target_id": r["target_entity_id"],
                "target_name": entity_map.get(r["target_entity_id"], "Unknown"),
                "type": r["relation_type"],
                "evidence": r["evidence"]
            }
            for r in relations
        ],
        "glossary": [
            {
                "id": g["id"],
                "term": g["term"],
                "pronunciation": g["pronunciation"],
                "frequency": g["frequency"]
            }
            for g in glossary
        ],
        "transcripts": [
            {
                "id": t["id"],
                "filename": t["filename"],
                "type": t.get("type", "audio"),
                "created_at": t["created_at"]
            }
            for t in transcripts
        ]
    }

# Phase 3: Glossary API
@app.post("/api/v1/projects/{project_id}/glossary")
async def add_glossary_term(project_id: str, term: GlossaryTermCreate, _=Depends(verify_api_key)):
    """添加术语到项目术语表"""
    if not DB_AVAILABLE:
        raise HTTPException(status_code=500, detail="Database not available")
    
    db = get_db_manager()
    project = db.get_project(project_id)
    if not project:
        raise HTTPException(status_code=404, detail="Project not found")
    
    term_id = db.add_glossary_term(
        project_id=project_id,
        term=term.term,
        pronunciation=term.pronunciation
    )
    
    return {
        "id": term_id,
        "term": term.term,
        "pronunciation": term.pronunciation,
        "success": True
    }

@app.get("/api/v1/projects/{project_id}/glossary")
async def get_glossary(project_id: str, _=Depends(verify_api_key)):
    """获取项目术语表"""
    if not DB_AVAILABLE:
        raise HTTPException(status_code=500, detail="Database not available")
    
    db = get_db_manager()
    glossary = db.list_glossary(project_id)
    return glossary

@app.delete("/api/v1/glossary/{term_id}")
async def delete_glossary_term(term_id: str, _=Depends(verify_api_key)):
    """删除术语"""
    if not DB_AVAILABLE:
        raise HTTPException(status_code=500, detail="Database not available")
    
    db = get_db_manager()
    db.delete_glossary_term(term_id)
    return {"success": True}

# Phase 3: Entity Alignment API
@app.post("/api/v1/projects/{project_id}/align-entities")
async def align_project_entities(project_id: str, threshold: float = 0.85, _=Depends(verify_api_key)):
    """运行实体对齐算法，合并相似实体"""
    if not DB_AVAILABLE:
        raise HTTPException(status_code=500, detail="Database not available")
    
    aligner = get_aligner()
    if not aligner:
        raise HTTPException(status_code=500, detail="Entity aligner not available")
    
    db = get_db_manager()
    entities = db.list_project_entities(project_id)
    
    merged_count = 0
    merged_pairs = []
    
    # 使用 embedding 对齐
    for i, entity in enumerate(entities):
        # 跳过已合并的实体
        existing = db.get_entity(entity.id)
        if not existing:
            continue
            
        similar = aligner.find_similar_entity(
            project_id, 
            entity.name, 
            entity.definition,
            exclude_id=entity.id,
            threshold=threshold
        )
        
        if similar:
            # 合并实体
            db.merge_entities(similar.id, entity.id)
            merged_count += 1
            merged_pairs.append({
                "source": entity.name,
                "target": similar.name
            })
    
    return {
        "success": True,
        "merged_count": merged_count,
        "merged_pairs": merged_pairs
    }

@app.get("/api/v1/projects/{project_id}/entities")
async def get_project_entities(project_id: str, _=Depends(verify_api_key)):
    """获取项目的全局实体列表"""
    if not DB_AVAILABLE:
        return []
    
    db = get_db_manager()
    entities = db.list_project_entities(project_id)
    return [{"id": e.id, "name": e.name, "type": e.type, "definition": e.definition, "aliases": e.aliases} for e in entities]


@app.get("/api/v1/projects/{project_id}/relations")
async def get_project_relations(project_id: str, _=Depends(verify_api_key)):
    """获取项目的实体关系列表"""
    if not DB_AVAILABLE:
        return []
    
    db = get_db_manager()
    relations = db.list_project_relations(project_id)
    
    # 获取实体名称映射
    entities = db.list_project_entities(project_id)
    entity_map = {e.id: e.name for e in entities}
    
    return [{
        "id": r["id"],
        "source_id": r["source_entity_id"],
        "source_name": entity_map.get(r["source_entity_id"], "Unknown"),
        "target_id": r["target_entity_id"],
        "target_name": entity_map.get(r["target_entity_id"], "Unknown"),
        "type": r["relation_type"],
        "evidence": r["evidence"]
    } for r in relations]


@app.get("/api/v1/projects/{project_id}/transcripts")
async def get_project_transcripts(project_id: str, _=Depends(verify_api_key)):
    """获取项目的转录列表"""
    if not DB_AVAILABLE:
        return []
    
    db = get_db_manager()
    transcripts = db.list_project_transcripts(project_id)
    return [{
        "id": t["id"],
        "filename": t["filename"],
        "type": t.get("type", "audio"),
        "created_at": t["created_at"],
        "preview": t["full_text"][:100] + "..." if len(t["full_text"]) > 100 else t["full_text"]
    } for t in transcripts]


@app.get("/api/v1/entities/{entity_id}/mentions")
async def get_entity_mentions(entity_id: str, _=Depends(verify_api_key)):
    """获取实体的所有提及位置"""
    if not DB_AVAILABLE:
        return []
    
    db = get_db_manager()
    mentions = db.get_entity_mentions(entity_id)
    return [{
        "id": m.id,
        "transcript_id": m.transcript_id,
        "start_pos": m.start_pos,
        "end_pos": m.end_pos,
        "text_snippet": m.text_snippet,
        "confidence": m.confidence
    } for m in mentions]

# Health check
@app.get("/health")
async def health_check():
    return {
        "status": "ok",
        "version": "0.7.0",
        "phase": "Phase 7 - Plugin & Integration",
        "oss_available": OSS_AVAILABLE,
        "tingwu_available": TINGWU_AVAILABLE,
        "db_available": DB_AVAILABLE,
        "doc_processor_available": DOC_PROCESSOR_AVAILABLE,
        "aligner_available": ALIGNER_AVAILABLE,
        "llm_client_available": LLM_CLIENT_AVAILABLE,
        "reasoner_available": REASONER_AVAILABLE,
        "multimodal_available": MULTIMODAL_AVAILABLE,
        "image_processor_available": IMAGE_PROCESSOR_AVAILABLE,
        "multimodal_linker_available": MULTIMODAL_LINKER_AVAILABLE,
        "plugin_manager_available": PLUGIN_MANAGER_AVAILABLE
    }


# ==================== Phase 4: Agent 助手 API ====================

@app.post("/api/v1/projects/{project_id}/agent/query")
async def agent_query(project_id: str, query: AgentQuery, _=Depends(verify_api_key)):
    """Agent RAG 问答"""
    if not DB_AVAILABLE or not LLM_CLIENT_AVAILABLE:
        raise HTTPException(status_code=500, detail="Service not available")
    
    db = get_db_manager()
    llm = get_llm_client()
    
    project = db.get_project(project_id)
    if not project:
        raise HTTPException(status_code=404, detail="Project not found")
    
    # 获取项目上下文
    project_context = db.get_project_summary(project_id)
    
    # 构建上下文
    context_parts = []
    for t in project_context.get('recent_transcripts', []):
        context_parts.append(f"【{t['filename']}】\n{t['full_text'][:1000]}")
    
    context = "\n\n".join(context_parts)
    
    if query.stream:
        from fastapi.responses import StreamingResponse
        import json
        
        async def stream_response():
            messages = [
                ChatMessage(role="system", content="你是一个专业的项目分析助手，擅长从会议记录中提取洞察。"),
                ChatMessage(role="user", content=f"""基于以下项目信息回答问题：

## 项目信息
{json.dumps(project_context, ensure_ascii=False, indent=2)}

## 相关上下文
{context[:4000]}

## 用户问题
{query.query}

请用中文回答，保持简洁专业。如果信息不足，请明确说明。""")
            ]
            
            async for chunk in llm.chat_stream(messages):
                yield f"data: {json.dumps({'content': chunk})}\n\n"
            yield "data: [DONE]\n\n"
        
        return StreamingResponse(stream_response(), media_type="text/event-stream")
    else:
        answer = await llm.rag_query(query.query, context, project_context)
        return {"answer": answer, "project_id": project_id}


@app.post("/api/v1/projects/{project_id}/agent/command")
async def agent_command(project_id: str, command: AgentCommand, _=Depends(verify_api_key)):
    """Agent 指令执行 - 解析并执行自然语言指令"""
    if not DB_AVAILABLE or not LLM_CLIENT_AVAILABLE:
        raise HTTPException(status_code=500, detail="Service not available")
    
    db = get_db_manager()
    llm = get_llm_client()
    
    project = db.get_project(project_id)
    if not project:
        raise HTTPException(status_code=404, detail="Project not found")
    
    # 获取项目上下文
    project_context = db.get_project_summary(project_id)
    
    # 解析指令
    parsed = await llm.agent_command(command.command, project_context)
    
    intent = parsed.get("intent", "unknown")
    params = parsed.get("params", {})
    
    result = {"intent": intent, "explanation": parsed.get("explanation", "")}
    
    # 执行指令
    if intent == "merge_entities":
        # 合并实体
        source_names = params.get("source_names", [])
        target_name = params.get("target_name", "")
        
        target_entity = None
        source_entities = []
        
        # 查找目标实体
        for e in project_context.get("top_entities", []):
            if e["name"] == target_name or target_name in e["name"]:
                target_entity = db.get_entity_by_name(project_id, e["name"])
                break
        
        # 查找源实体
        for name in source_names:
            for e in project_context.get("top_entities", []):
                if e["name"] == name or name in e["name"]:
                    ent = db.get_entity_by_name(project_id, e["name"])
                    if ent and (not target_entity or ent.id != target_entity.id):
                        source_entities.append(ent)
                    break
        
        merged = []
        if target_entity:
            for source in source_entities:
                try:
                    db.merge_entities(target_entity.id, source.id)
                    merged.append(source.name)
                except Exception as e:
                    print(f"Merge failed: {e}")
        
        result["action"] = "merge_entities"
        result["target"] = target_entity.name if target_entity else None
        result["merged"] = merged
        result["success"] = len(merged) > 0
        
    elif intent == "answer_question":
        # 问答 - 调用 RAG
        answer = await llm.rag_query(params.get("question", command.command), "", project_context)
        result["action"] = "answer"
        result["answer"] = answer
        
    elif intent == "edit_entity":
        # 编辑实体
        entity_name = params.get("entity_name", "")
        field = params.get("field", "")
        value = params.get("value", "")
        
        entity = db.get_entity_by_name(project_id, entity_name)
        if entity:
            updated = db.update_entity(entity.id, **{field: value})
            result["action"] = "edit_entity"
            result["entity"] = {"id": updated.id, "name": updated.name} if updated else None
            result["success"] = updated is not None
        else:
            result["success"] = False
            result["error"] = "Entity not found"
    
    else:
        result["action"] = "none"
        result["message"] = "无法理解的指令，请尝试：\n- 合并实体：把所有'客户端'合并到'App'\n- 提问：张总对项目的态度如何？\n- 编辑：修改'K8s'的定义为..."
    
    return result


@app.get("/api/v1/projects/{project_id}/agent/suggest")
async def agent_suggest(project_id: str, _=Depends(verify_api_key)):
    """获取 Agent 建议 - 基于项目数据提供洞察"""
    if not DB_AVAILABLE or not LLM_CLIENT_AVAILABLE:
        raise HTTPException(status_code=500, detail="Service not available")
    
    db = get_db_manager()
    llm = get_llm_client()
    
    project_context = db.get_project_summary(project_id)
    
    # 生成建议
    prompt = f"""基于以下项目数据，提供3-5条分析建议：

{json.dumps(project_context, ensure_ascii=False, indent=2)}

请提供：
1. 数据洞察发现
2. 建议的操作（如合并相似实体、补充定义等）
3. 值得关注的关键信息

返回 JSON 格式：{{"suggestions": [{{"type": "insight|action", "title": "...", "description": "..."}}]}}"""
    
    messages = [ChatMessage(role="user", content=prompt)]
    content = await llm.chat(messages, temperature=0.3)
    
    import re
    json_match = re.search(r'\{{.*?\}}', content, re.DOTALL)
    if json_match:
        try:
            data = json.loads(json_match.group())
            return data
        except:
            pass
    
    return {"suggestions": []}


# ==================== Phase 4: 知识溯源 API ====================

@app.get("/api/v1/relations/{relation_id}/provenance")
async def get_relation_provenance(relation_id: str, _=Depends(verify_api_key)):
    """获取关系的知识溯源信息"""
    if not DB_AVAILABLE:
        raise HTTPException(status_code=500, detail="Database not available")
    
    db = get_db_manager()
    relation = db.get_relation_with_details(relation_id)
    
    if not relation:
        raise HTTPException(status_code=404, detail="Relation not found")
    
    return {
        "relation_id": relation_id,
        "source": relation.get("source_name"),
        "target": relation.get("target_name"),
        "type": relation.get("relation_type"),
        "evidence": relation.get("evidence"),
        "transcript": {
            "id": relation.get("transcript_id"),
            "filename": relation.get("transcript_filename"),
        } if relation.get("transcript_id") else None
    }


@app.get("/api/v1/entities/{entity_id}/details")
async def get_entity_details(entity_id: str, _=Depends(verify_api_key)):
    """获取实体详情，包含所有提及位置"""
    if not DB_AVAILABLE:
        raise HTTPException(status_code=500, detail="Database not available")
    
    db = get_db_manager()
    entity = db.get_entity_with_mentions(entity_id)
    
    if not entity:
        raise HTTPException(status_code=404, detail="Entity not found")
    
    return entity


@app.get("/api/v1/entities/{entity_id}/evolution")
async def get_entity_evolution(entity_id: str, _=Depends(verify_api_key)):
    """分析实体的演变和态度变化"""
    if not DB_AVAILABLE or not LLM_CLIENT_AVAILABLE:
        raise HTTPException(status_code=500, detail="Service not available")
    
    db = get_db_manager()
    llm = get_llm_client()
    
    entity = db.get_entity_with_mentions(entity_id)
    if not entity:
        raise HTTPException(status_code=404, detail="Entity not found")
    
    # 分析演变
    analysis = await llm.analyze_entity_evolution(entity["name"], entity.get("mentions", []))
    
    return {
        "entity_id": entity_id,
        "entity_name": entity["name"],
        "mention_count": entity.get("mention_count", 0),
        "analysis": analysis,
        "timeline": [
            {
                "date": m.get("transcript_date"),
                "snippet": m.get("text_snippet"),
                "transcript_id": m.get("transcript_id"),
                "filename": m.get("filename")
            }
            for m in entity.get("mentions", [])
        ]
    }


# ==================== Phase 4: 实体管理增强 API ====================

@app.get("/api/v1/projects/{project_id}/entities/search")
async def search_entities(project_id: str, q: str, _=Depends(verify_api_key)):
    """搜索实体"""
    if not DB_AVAILABLE:
        raise HTTPException(status_code=500, detail="Database not available")
    
    db = get_db_manager()
    entities = db.search_entities(project_id, q)
    return [{"id": e.id, "name": e.name, "type": e.type, "definition": e.definition} for e in entities]


# ==================== Phase 5: 时间线视图 API ====================

@app.get("/api/v1/projects/{project_id}/timeline")
async def get_project_timeline(
    project_id: str, 
    entity_id: str = None,
    start_date: str = None,
    end_date: str = None,
    _=Depends(verify_api_key)
):
    """获取项目时间线 - 按时间顺序的实体提及和关系事件"""
    if not DB_AVAILABLE:
        raise HTTPException(status_code=500, detail="Database not available")
    
    db = get_db_manager()
    project = db.get_project(project_id)
    if not project:
        raise HTTPException(status_code=404, detail="Project not found")
    
    timeline = db.get_project_timeline(project_id, entity_id, start_date, end_date)
    
    return {
        "project_id": project_id,
        "events": timeline,
        "total_count": len(timeline)
    }


@app.get("/api/v1/projects/{project_id}/timeline/summary")
async def get_timeline_summary(project_id: str, _=Depends(verify_api_key)):
    """获取项目时间线摘要统计"""
    if not DB_AVAILABLE:
        raise HTTPException(status_code=500, detail="Database not available")
    
    db = get_db_manager()
    project = db.get_project(project_id)
    if not project:
        raise HTTPException(status_code=404, detail="Project not found")
    
    summary = db.get_entity_timeline_summary(project_id)
    
    return {
        "project_id": project_id,
        "project_name": project.name,
        **summary
    }


@app.get("/api/v1/entities/{entity_id}/timeline")
async def get_entity_timeline(entity_id: str, _=Depends(verify_api_key)):
    """获取单个实体的时间线"""
    if not DB_AVAILABLE:
        raise HTTPException(status_code=500, detail="Database not available")
    
    db = get_db_manager()
    entity = db.get_entity(entity_id)
    if not entity:
        raise HTTPException(status_code=404, detail="Entity not found")
    
    timeline = db.get_project_timeline(entity.project_id, entity_id)
    
    return {
        "entity_id": entity_id,
        "entity_name": entity.name,
        "entity_type": entity.type,
        "events": timeline,
        "total_count": len(timeline)
    }


# ==================== Phase 5: 知识推理与问答增强 API ====================

class ReasoningQuery(BaseModel):
    query: str
    reasoning_depth: str = "medium"  # shallow/medium/deep
    stream: bool = False


@app.post("/api/v1/projects/{project_id}/reasoning/query")
async def reasoning_query(project_id: str, query: ReasoningQuery, _=Depends(verify_api_key)):
    """
    增强问答 - 基于知识推理的智能问答
    
    支持多种推理类型：
    - 因果推理：分析原因和影响
    - 对比推理：比较实体间的异同
    - 时序推理：分析时间线和演变
    - 关联推理：发现隐含关联
    """
    if not DB_AVAILABLE or not REASONER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Knowledge reasoner not available")
    
    db = get_db_manager()
    reasoner = get_knowledge_reasoner()
    
    project = db.get_project(project_id)
    if not project:
        raise HTTPException(status_code=404, detail="Project not found")
    
    # 获取项目上下文
    project_context = db.get_project_summary(project_id)
    
    # 获取知识图谱数据
    entities = db.list_project_entities(project_id)
    relations = db.list_project_relations(project_id)
    
    graph_data = {
        "entities": [{"id": e.id, "name": e.name, "type": e.type, "definition": e.definition} for e in entities],
        "relations": relations
    }
    
    # 执行增强问答
    result = await reasoner.enhanced_qa(
        query=query.query,
        project_context=project_context,
        graph_data=graph_data,
        reasoning_depth=query.reasoning_depth
    )
    
    return {
        "answer": result.answer,
        "reasoning_type": result.reasoning_type.value,
        "confidence": result.confidence,
        "evidence": result.evidence,
        "knowledge_gaps": result.gaps,
        "project_id": project_id
    }


@app.post("/api/v1/projects/{project_id}/reasoning/inference-path")
async def find_inference_path(
    project_id: str,
    start_entity: str,
    end_entity: str,
    _=Depends(verify_api_key)
):
    """
    发现两个实体之间的推理路径
    
    在知识图谱中搜索从 start_entity 到 end_entity 的路径
    """
    if not DB_AVAILABLE or not REASONER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Knowledge reasoner not available")
    
    db = get_db_manager()
    reasoner = get_knowledge_reasoner()
    
    project = db.get_project(project_id)
    if not project:
        raise HTTPException(status_code=404, detail="Project not found")
    
    # 获取知识图谱数据
    entities = db.list_project_entities(project_id)
    relations = db.list_project_relations(project_id)
    
    graph_data = {
        "entities": [{"id": e.id, "name": e.name, "type": e.type} for e in entities],
        "relations": relations
    }
    
    # 查找推理路径
    paths = reasoner.find_inference_paths(start_entity, end_entity, graph_data)
    
    return {
        "start_entity": start_entity,
        "end_entity": end_entity,
        "paths": [
            {
                "path": path.path,
                "strength": path.strength,
                "path_description": " -> ".join([p["entity"] for p in path.path])
            }
            for path in paths[:5]  # 最多返回5条路径
        ],
        "total_paths": len(paths)
    }


class SummaryRequest(BaseModel):
    summary_type: str = "comprehensive"  # comprehensive/executive/technical/risk


@app.post("/api/v1/projects/{project_id}/reasoning/summary")
async def project_summary(project_id: str, req: SummaryRequest, _=Depends(verify_api_key)):
    """
    项目智能总结
    
    根据类型生成不同侧重点的总结：
    - comprehensive: 全面总结
    - executive: 高管摘要
    - technical: 技术总结
    - risk: 风险分析
    """
    if not DB_AVAILABLE or not REASONER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Knowledge reasoner not available")
    
    db = get_db_manager()
    reasoner = get_knowledge_reasoner()
    
    project = db.get_project(project_id)
    if not project:
        raise HTTPException(status_code=404, detail="Project not found")
    
    # 获取项目上下文
    project_context = db.get_project_summary(project_id)
    
    # 获取知识图谱数据
    entities = db.list_project_entities(project_id)
    relations = db.list_project_relations(project_id)
    
    graph_data = {
        "entities": [{"id": e.id, "name": e.name, "type": e.type} for e in entities],
        "relations": relations
    }
    
    # 生成总结
    summary = await reasoner.summarize_project(
        project_context=project_context,
        graph_data=graph_data,
        summary_type=req.summary_type
    )
    
    return {
        "project_id": project_id,
        "summary_type": req.summary_type,
        **summary
        **summary
    }


# ==================== Phase 5: 实体属性扩展 API ====================

class AttributeTemplateCreate(BaseModel):
    name: str
    type: str  # text, number, date, select, multiselect, boolean
    options: Optional[List[str]] = None
    default_value: Optional[str] = ""
    description: Optional[str] = ""
    is_required: bool = False
    sort_order: int = 0


class AttributeTemplateUpdate(BaseModel):
    name: Optional[str] = None
    type: Optional[str] = None
    options: Optional[List[str]] = None
    default_value: Optional[str] = None
    description: Optional[str] = None
    is_required: Optional[bool] = None
    sort_order: Optional[int] = None


class EntityAttributeSet(BaseModel):
    name: str
    type: str
    value: Optional[Union[str, int, float, List[str]]] = None
    template_id: Optional[str] = None
    options: Optional[List[str]] = None
    change_reason: Optional[str] = ""


class EntityAttributeBatchSet(BaseModel):
    attributes: List[EntityAttributeSet]
    change_reason: Optional[str] = ""


# 属性模板管理 API
@app.post("/api/v1/projects/{project_id}/attribute-templates")
async def create_attribute_template_endpoint(project_id: str, template: AttributeTemplateCreate, _=Depends(verify_api_key)):
    """创建属性模板"""
    if not DB_AVAILABLE:
        raise HTTPException(status_code=500, detail="Database not available")
    
    from db_manager import AttributeTemplate
    
    db = get_db_manager()
    project = db.get_project(project_id)
    if not project:
        raise HTTPException(status_code=404, detail="Project not found")
    
    new_template = AttributeTemplate(
        id=str(uuid.uuid4())[:8],
        project_id=project_id,
        name=template.name,
        type=template.type,
        options=template.options or [],
        default_value=template.default_value or "",
        description=template.description or "",
        is_required=template.is_required,
        sort_order=template.sort_order
    )
    
    db.create_attribute_template(new_template)
    
    return {
        "id": new_template.id,
        "name": new_template.name,
        "type": new_template.type,
        "success": True
    }


@app.get("/api/v1/projects/{project_id}/attribute-templates")
async def list_attribute_templates_endpoint(project_id: str, _=Depends(verify_api_key)):
    """列出项目的所有属性模板"""
    if not DB_AVAILABLE:
        raise HTTPException(status_code=500, detail="Database not available")
    
    db = get_db_manager()
    templates = db.list_attribute_templates(project_id)
    
    return [
        {
            "id": t.id,
            "name": t.name,
            "type": t.type,
            "options": t.options,
            "default_value": t.default_value,
            "description": t.description,
            "is_required": t.is_required,
            "sort_order": t.sort_order
        }
        for t in templates
    ]


@app.get("/api/v1/attribute-templates/{template_id}")
async def get_attribute_template_endpoint(template_id: str, _=Depends(verify_api_key)):
    """获取属性模板详情"""
    if not DB_AVAILABLE:
        raise HTTPException(status_code=500, detail="Database not available")
    
    db = get_db_manager()
    template = db.get_attribute_template(template_id)
    
    if not template:
        raise HTTPException(status_code=404, detail="Template not found")
    
    return {
        "id": template.id,
        "name": template.name,
        "type": template.type,
        "options": template.options,
        "default_value": template.default_value,
        "description": template.description,
        "is_required": template.is_required,
        "sort_order": template.sort_order
    }


@app.put("/api/v1/attribute-templates/{template_id}")
async def update_attribute_template_endpoint(template_id: str, update: AttributeTemplateUpdate, _=Depends(verify_api_key)):
    """更新属性模板"""
    if not DB_AVAILABLE:
        raise HTTPException(status_code=500, detail="Database not available")
    
    db = get_db_manager()
    template = db.get_attribute_template(template_id)
    if not template:
        raise HTTPException(status_code=404, detail="Template not found")
    
    update_data = {k: v for k, v in update.dict().items() if v is not None}
    updated = db.update_attribute_template(template_id, **update_data)
    
    return {
        "id": updated.id,
        "name": updated.name,
        "type": updated.type,
        "success": True
    }


@app.delete("/api/v1/attribute-templates/{template_id}")
async def delete_attribute_template_endpoint(template_id: str, _=Depends(verify_api_key)):
    """删除属性模板"""
    if not DB_AVAILABLE:
        raise HTTPException(status_code=500, detail="Database not available")
    
    db = get_db_manager()
    db.delete_attribute_template(template_id)
    
    return {"success": True, "message": f"Template {template_id} deleted"}


# 实体属性值管理 API
@app.post("/api/v1/entities/{entity_id}/attributes")
async def set_entity_attribute_endpoint(entity_id: str, attr: EntityAttributeSet, _=Depends(verify_api_key)):
    """设置实体属性值"""
    if not DB_AVAILABLE:
        raise HTTPException(status_code=500, detail="Database not available")
    
    db = get_db_manager()
    entity = db.get_entity(entity_id)
    if not entity:
        raise HTTPException(status_code=404, detail="Entity not found")
    
    # 验证类型
    valid_types = ['text', 'number', 'date', 'select', 'multiselect']
    if attr.type not in valid_types:
        raise HTTPException(status_code=400, detail=f"Invalid type. Must be one of: {valid_types}")
    
    # 处理 value
    value = attr.value
    if attr.type == 'multiselect' and isinstance(value, list):
        value = json.dumps(value)
    elif value is not None:
        value = str(value)
    
    # 处理 options
    options = attr.options
    if options:
        options = json.dumps(options)
    
    # 检查是否已存在
    conn = db.get_conn()
    existing = conn.execute(
        "SELECT * FROM entity_attributes WHERE entity_id = ? AND name = ?",
        (entity_id, attr.name)
    ).fetchone()
    
    now = datetime.now().isoformat()
    
    if existing:
        # 记录历史
        conn.execute(
            """INSERT INTO attribute_history 
               (id, entity_id, attribute_name, old_value, new_value, changed_by, changed_at, change_reason)
               VALUES (?, ?, ?, ?, ?, ?, ?, ?)""",
            (str(uuid.uuid4())[:8], entity_id, attr.name, existing['value'], value,
             "user", now, attr.change_reason or "")
        )
        
        # 更新
        conn.execute(
            """UPDATE entity_attributes 
               SET value = ?, type = ?, options = ?, updated_at = ?
               WHERE id = ?""",
            (value, attr.type, options, now, existing['id'])
        )
        attr_id = existing['id']
    else:
        # 创建
        attr_id = str(uuid.uuid4())[:8]
        conn.execute(
            """INSERT INTO entity_attributes 
               (id, entity_id, template_id, name, type, value, options, created_at, updated_at)
               VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)""",
            (attr_id, entity_id, attr.template_id, attr.name, attr.type, value, options, now, now)
        )
        
        # 记录历史
        conn.execute(
            """INSERT INTO attribute_history 
               (id, entity_id, attribute_name, old_value, new_value, changed_by, changed_at, change_reason)
               VALUES (?, ?, ?, ?, ?, ?, ?, ?)""",
            (str(uuid.uuid4())[:8], entity_id, attr.name, None, value,
             "user", now, attr.change_reason or "创建属性")
        )
    
    conn.commit()
    conn.close()
    
    return {
        "id": attr_id,
        "entity_id": entity_id,
        "name": attr.name,
        "type": attr.type,
        "value": attr.value,
        "success": True
    }


@app.post("/api/v1/entities/{entity_id}/attributes/batch")
async def batch_set_entity_attributes_endpoint(entity_id: str, batch: EntityAttributeBatchSet, _=Depends(verify_api_key)):
    """批量设置实体属性值"""
    if not DB_AVAILABLE:
        raise HTTPException(status_code=500, detail="Database not available")
    
    from db_manager import EntityAttribute
    
    db = get_db_manager()
    entity = db.get_entity(entity_id)
    if not entity:
        raise HTTPException(status_code=404, detail="Entity not found")
    
    results = []
    for attr_data in batch.attributes:
        template = db.get_attribute_template(attr_data.template_id)
        if template:
            new_attr = EntityAttribute(
                id=str(uuid.uuid4())[:8],
                entity_id=entity_id,
                template_id=attr_data.template_id,
                value=attr_data.value
            )
            db.set_entity_attribute(new_attr, changed_by="user", 
                                   change_reason=batch.change_reason or "批量更新")
            results.append({
                "template_id": attr_data.template_id,
                "template_name": template.name,
                "value": attr_data.value
            })
    
    return {
        "entity_id": entity_id,
        "updated_count": len(results),
        "attributes": results,
        "success": True
    }


@app.get("/api/v1/entities/{entity_id}/attributes")
async def get_entity_attributes_endpoint(entity_id: str, _=Depends(verify_api_key)):
    """获取实体的所有属性值"""
    if not DB_AVAILABLE:
        raise HTTPException(status_code=500, detail="Database not available")
    
    db = get_db_manager()
    entity = db.get_entity(entity_id)
    if not entity:
        raise HTTPException(status_code=404, detail="Entity not found")
    
    attrs = db.get_entity_attributes(entity_id)
    
    return [
        {
            "id": a.id,
            "template_id": a.template_id,
            "template_name": a.template_name,
            "template_type": a.template_type,
            "value": a.value
        }
        for a in attrs
    ]


@app.delete("/api/v1/entities/{entity_id}/attributes/{template_id}")
async def delete_entity_attribute_endpoint(entity_id: str, template_id: str, 
                                  reason: Optional[str] = "", _=Depends(verify_api_key)):
    """删除实体属性值"""
    if not DB_AVAILABLE:
        raise HTTPException(status_code=500, detail="Database not available")
    
    db = get_db_manager()
    db.delete_entity_attribute(entity_id, template_id, 
                               changed_by="user", change_reason=reason)
    
    return {"success": True, "message": "Attribute deleted"}


# 属性历史 API
@app.get("/api/v1/entities/{entity_id}/attributes/history")
async def get_entity_attribute_history_endpoint(entity_id: str, limit: int = 50, _=Depends(verify_api_key)):
    """获取实体的属性变更历史"""
    if not DB_AVAILABLE:
        raise HTTPException(status_code=500, detail="Database not available")
    
    db = get_db_manager()
    history = db.get_attribute_history(entity_id=entity_id, limit=limit)
    
    return [
        {
            "id": h.id,
            "attribute_name": h.attribute_name,
            "old_value": h.old_value,
            "new_value": h.new_value,
            "changed_by": h.changed_by,
            "changed_at": h.changed_at,
            "change_reason": h.change_reason
        }
        for h in history
    ]


@app.get("/api/v1/attribute-templates/{template_id}/history")
async def get_template_history_endpoint(template_id: str, limit: int = 50, _=Depends(verify_api_key)):
    """获取属性模板的所有变更历史（跨实体）"""
    if not DB_AVAILABLE:
        raise HTTPException(status_code=500, detail="Database not available")
    
    db = get_db_manager()
    history = db.get_attribute_history(template_id=template_id, limit=limit)
    
    return [
        {
            "id": h.id,
            "entity_id": h.entity_id,
            "template_name": h.template_name,
            "old_value": h.old_value,
            "new_value": h.new_value,
            "changed_by": h.changed_by,
            "changed_at": h.changed_at,
            "change_reason": h.change_reason
        }
        for h in history
    ]


# 属性筛选搜索 API
@app.get("/api/v1/projects/{project_id}/entities/search-by-attributes")
async def search_entities_by_attributes_endpoint(
    project_id: str,
    attribute_filter: Optional[str] = None,  # JSON 格式: {"职位": "经理", "部门": "技术部"}
    _=Depends(verify_api_key)
):
    """根据属性筛选搜索实体"""
    if not DB_AVAILABLE:
        raise HTTPException(status_code=500, detail="Database not available")
    
    db = get_db_manager()
    project = db.get_project(project_id)
    if not project:
        raise HTTPException(status_code=404, detail="Project not found")
    
    filters = {}
    if attribute_filter:
        try:
            filters = json.loads(attribute_filter)
        except json.JSONDecodeError:
            raise HTTPException(status_code=400, detail="Invalid attribute_filter JSON")
    
    entities = db.search_entities_by_attributes(project_id, filters)
    
    return [
        {
            "id": e.id,
            "name": e.name,
            "type": e.type,
            "definition": e.definition,
            "attributes": e.attributes
        }
        for e in entities
    ]


# ==================== 导出功能 API ====================

from fastapi.responses import StreamingResponse, FileResponse

@app.get("/api/v1/projects/{project_id}/export/graph-svg")
async def export_graph_svg_endpoint(project_id: str, _=Depends(verify_api_key)):
    """导出知识图谱为 SVG"""
    if not DB_AVAILABLE or not EXPORT_AVAILABLE:
        raise HTTPException(status_code=500, detail="Export functionality not available")
    
    db = get_db_manager()
    project = db.get_project(project_id)
    if not project:
        raise HTTPException(status_code=404, detail="Project not found")
    
    # 获取项目数据
    entities_data = db.get_project_entities(project_id)
    relations_data = db.get_project_relations(project_id)
    
    # 转换为导出格式
    entities = []
    for e in entities_data:
        attrs = db.get_entity_attributes(e.id)
        entities.append(ExportEntity(
            id=e.id,
            name=e.name,
            type=e.type,
            definition=e.definition or "",
            aliases=json.loads(e.aliases) if e.aliases else [],
            mention_count=e.mention_count,
            attributes={a.template_name: a.value for a in attrs}
        ))
    
    relations = []
    for r in relations_data:
        relations.append(ExportRelation(
            id=r.id,
            source=r.source_name,
            target=r.target_name,
            relation_type=r.relation_type,
            confidence=r.confidence,
            evidence=r.evidence or ""
        ))
    
    export_mgr = get_export_manager()
    svg_content = export_mgr.export_knowledge_graph_svg(project_id, entities, relations)
    
    return StreamingResponse(
        io.BytesIO(svg_content.encode('utf-8')),
        media_type="image/svg+xml",
        headers={"Content-Disposition": f"attachment; filename=insightflow-graph-{project_id}.svg"}
    )


@app.get("/api/v1/projects/{project_id}/export/graph-png")
async def export_graph_png_endpoint(project_id: str, _=Depends(verify_api_key)):
    """导出知识图谱为 PNG"""
    if not DB_AVAILABLE or not EXPORT_AVAILABLE:
        raise HTTPException(status_code=500, detail="Export functionality not available")
    
    db = get_db_manager()
    project = db.get_project(project_id)
    if not project:
        raise HTTPException(status_code=404, detail="Project not found")
    
    # 获取项目数据
    entities_data = db.get_project_entities(project_id)
    relations_data = db.get_project_relations(project_id)
    
    # 转换为导出格式
    entities = []
    for e in entities_data:
        attrs = db.get_entity_attributes(e.id)
        entities.append(ExportEntity(
            id=e.id,
            name=e.name,
            type=e.type,
            definition=e.definition or "",
            aliases=json.loads(e.aliases) if e.aliases else [],
            mention_count=e.mention_count,
            attributes={a.template_name: a.value for a in attrs}
        ))
    
    relations = []
    for r in relations_data:
        relations.append(ExportRelation(
            id=r.id,
            source=r.source_name,
            target=r.target_name,
            relation_type=r.relation_type,
            confidence=r.confidence,
            evidence=r.evidence or ""
        ))
    
    export_mgr = get_export_manager()
    png_bytes = export_mgr.export_knowledge_graph_png(project_id, entities, relations)
    
    return StreamingResponse(
        io.BytesIO(png_bytes),
        media_type="image/png",
        headers={"Content-Disposition": f"attachment; filename=insightflow-graph-{project_id}.png"}
    )


@app.get("/api/v1/projects/{project_id}/export/entities-excel")
async def export_entities_excel_endpoint(project_id: str, _=Depends(verify_api_key)):
    """导出实体数据为 Excel"""
    if not DB_AVAILABLE or not EXPORT_AVAILABLE:
        raise HTTPException(status_code=500, detail="Export functionality not available")
    
    db = get_db_manager()
    project = db.get_project(project_id)
    if not project:
        raise HTTPException(status_code=404, detail="Project not found")
    
    # 获取实体数据
    entities_data = db.get_project_entities(project_id)
    
    entities = []
    for e in entities_data:
        attrs = db.get_entity_attributes(e.id)
        entities.append(ExportEntity(
            id=e.id,
            name=e.name,
            type=e.type,
            definition=e.definition or "",
            aliases=json.loads(e.aliases) if e.aliases else [],
            mention_count=e.mention_count,
            attributes={a.template_name: a.value for a in attrs}
        ))
    
    export_mgr = get_export_manager()
    excel_bytes = export_mgr.export_entities_excel(entities)
    
    return StreamingResponse(
        io.BytesIO(excel_bytes),
        media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
        headers={"Content-Disposition": f"attachment; filename=insightflow-entities-{project_id}.xlsx"}
    )


@app.get("/api/v1/projects/{project_id}/export/entities-csv")
async def export_entities_csv_endpoint(project_id: str, _=Depends(verify_api_key)):
    """导出实体数据为 CSV"""
    if not DB_AVAILABLE or not EXPORT_AVAILABLE:
        raise HTTPException(status_code=500, detail="Export functionality not available")
    
    db = get_db_manager()
    project = db.get_project(project_id)
    if not project:
        raise HTTPException(status_code=404, detail="Project not found")
    
    # 获取实体数据
    entities_data = db.get_project_entities(project_id)
    
    entities = []
    for e in entities_data:
        attrs = db.get_entity_attributes(e.id)
        entities.append(ExportEntity(
            id=e.id,
            name=e.name,
            type=e.type,
            definition=e.definition or "",
            aliases=json.loads(e.aliases) if e.aliases else [],
            mention_count=e.mention_count,
            attributes={a.template_name: a.value for a in attrs}
        ))
    
    export_mgr = get_export_manager()
    csv_content = export_mgr.export_entities_csv(entities)
    
    return StreamingResponse(
        io.BytesIO(csv_content.encode('utf-8')),
        media_type="text/csv",
        headers={"Content-Disposition": f"attachment; filename=insightflow-entities-{project_id}.csv"}
    )


@app.get("/api/v1/projects/{project_id}/export/relations-csv")
async def export_relations_csv_endpoint(project_id: str, _=Depends(verify_api_key)):
    """导出关系数据为 CSV"""
    if not DB_AVAILABLE or not EXPORT_AVAILABLE:
        raise HTTPException(status_code=500, detail="Export functionality not available")
    
    db = get_db_manager()
    project = db.get_project(project_id)
    if not project:
        raise HTTPException(status_code=404, detail="Project not found")
    
    # 获取关系数据
    relations_data = db.get_project_relations(project_id)
    
    relations = []
    for r in relations_data:
        relations.append(ExportRelation(
            id=r.id,
            source=r.source_name,
            target=r.target_name,
            relation_type=r.relation_type,
            confidence=r.confidence,
            evidence=r.evidence or ""
        ))
    
    export_mgr = get_export_manager()
    csv_content = export_mgr.export_relations_csv(relations)
    
    return StreamingResponse(
        io.BytesIO(csv_content.encode('utf-8')),
        media_type="text/csv",
        headers={"Content-Disposition": f"attachment; filename=insightflow-relations-{project_id}.csv"}
    )


@app.get("/api/v1/projects/{project_id}/export/report-pdf")
async def export_report_pdf_endpoint(project_id: str, _=Depends(verify_api_key)):
    """导出项目报告为 PDF"""
    if not DB_AVAILABLE or not EXPORT_AVAILABLE:
        raise HTTPException(status_code=500, detail="Export functionality not available")
    
    db = get_db_manager()
    project = db.get_project(project_id)
    if not project:
        raise HTTPException(status_code=404, detail="Project not found")
    
    # 获取项目数据
    entities_data = db.get_project_entities(project_id)
    relations_data = db.get_project_relations(project_id)
    transcripts_data = db.get_project_transcripts(project_id)
    
    # 转换为导出格式
    entities = []
    for e in entities_data:
        attrs = db.get_entity_attributes(e.id)
        entities.append(ExportEntity(
            id=e.id,
            name=e.name,
            type=e.type,
            definition=e.definition or "",
            aliases=json.loads(e.aliases) if e.aliases else [],
            mention_count=e.mention_count,
            attributes={a.template_name: a.value for a in attrs}
        ))
    
    relations = []
    for r in relations_data:
        relations.append(ExportRelation(
            id=r.id,
            source=r.source_name,
            target=r.target_name,
            relation_type=r.relation_type,
            confidence=r.confidence,
            evidence=r.evidence or ""
        ))
    
    transcripts = []
    for t in transcripts_data:
        segments = json.loads(t.segments) if t.segments else []
        transcripts.append(ExportTranscript(
            id=t.id,
            name=t.name,
            type=t.type,
            content=t.full_text or "",
            segments=segments,
            entity_mentions=[]
        ))
    
    # 获取项目总结
    summary = ""
    if REASONER_AVAILABLE:
        try:
            reasoner = get_knowledge_reasoner()
            summary_result = reasoner.generate_project_summary(project_id, db)
            summary = summary_result.get("summary", "")
        except:
            pass
    
    export_mgr = get_export_manager()
    pdf_bytes = export_mgr.export_project_report_pdf(
        project_id, project.name, entities, relations, transcripts, summary
    )
    
    return StreamingResponse(
        io.BytesIO(pdf_bytes),
        media_type="application/pdf",
        headers={"Content-Disposition": f"attachment; filename=insightflow-report-{project_id}.pdf"}
    )


@app.get("/api/v1/projects/{project_id}/export/project-json")
async def export_project_json_endpoint(project_id: str, _=Depends(verify_api_key)):
    """导出完整项目数据为 JSON"""
    if not DB_AVAILABLE or not EXPORT_AVAILABLE:
        raise HTTPException(status_code=500, detail="Export functionality not available")
    
    db = get_db_manager()
    project = db.get_project(project_id)
    if not project:
        raise HTTPException(status_code=404, detail="Project not found")
    
    # 获取项目数据
    entities_data = db.get_project_entities(project_id)
    relations_data = db.get_project_relations(project_id)
    transcripts_data = db.get_project_transcripts(project_id)
    
    # 转换为导出格式
    entities = []
    for e in entities_data:
        attrs = db.get_entity_attributes(e.id)
        entities.append(ExportEntity(
            id=e.id,
            name=e.name,
            type=e.type,
            definition=e.definition or "",
            aliases=json.loads(e.aliases) if e.aliases else [],
            mention_count=e.mention_count,
            attributes={a.template_name: a.value for a in attrs}
        ))
    
    relations = []
    for r in relations_data:
        relations.append(ExportRelation(
            id=r.id,
            source=r.source_name,
            target=r.target_name,
            relation_type=r.relation_type,
            confidence=r.confidence,
            evidence=r.evidence or ""
        ))
    
    transcripts = []
    for t in transcripts_data:
        segments = json.loads(t.segments) if t.segments else []
        transcripts.append(ExportTranscript(
            id=t.id,
            name=t.name,
            type=t.type,
            content=t.full_text or "",
            segments=segments,
            entity_mentions=[]
        ))
    
    export_mgr = get_export_manager()
    json_content = export_mgr.export_project_json(
        project_id, project.name, entities, relations, transcripts
    )
    
    return StreamingResponse(
        io.BytesIO(json_content.encode('utf-8')),
        media_type="application/json",
        headers={"Content-Disposition": f"attachment; filename=insightflow-project-{project_id}.json"}
    )


@app.get("/api/v1/transcripts/{transcript_id}/export/markdown")
async def export_transcript_markdown_endpoint(transcript_id: str, _=Depends(verify_api_key)):
    """导出转录文本为 Markdown"""
    if not DB_AVAILABLE or not EXPORT_AVAILABLE:
        raise HTTPException(status_code=500, detail="Export functionality not available")
    
    db = get_db_manager()
    transcript = db.get_transcript(transcript_id)
    if not transcript:
        raise HTTPException(status_code=404, detail="Transcript not found")
    
    # 获取实体提及
    mentions = db.get_transcript_entity_mentions(transcript_id)
    
    # 获取项目实体用于映射
    entities_data = db.get_project_entities(transcript.project_id)
    entities_map = {e.id: ExportEntity(
        id=e.id,
        name=e.name,
        type=e.type,
        definition=e.definition or "",
        aliases=json.loads(e.aliases) if e.aliases else [],
        mention_count=e.mention_count,
        attributes={}
    ) for e in entities_data}
    
    segments = json.loads(transcript.segments) if transcript.segments else []
    
    export_transcript = ExportTranscript(
        id=transcript.id,
        name=transcript.name,
        type=transcript.type,
        content=transcript.full_text or "",
        segments=segments,
        entity_mentions=[{
            "entity_id": m.entity_id,
            "entity_name": m.entity_name,
            "position": m.position,
            "context": m.context
        } for m in mentions]
    )
    
    export_mgr = get_export_manager()
    markdown_content = export_mgr.export_transcript_markdown(export_transcript, entities_map)
    
    return StreamingResponse(
        io.BytesIO(markdown_content.encode('utf-8')),
        media_type="text/markdown",
        headers={"Content-Disposition": f"attachment; filename=insightflow-transcript-{transcript_id}.md"}
    )


# ==================== Neo4j Graph Database API ====================

class Neo4jSyncRequest(BaseModel):
    project_id: str

class PathQueryRequest(BaseModel):
    source_entity_id: str
    target_entity_id: str
    max_depth: int = 10

class GraphQueryRequest(BaseModel):
    entity_ids: List[str]
    depth: int = 1

@app.get("/api/v1/neo4j/status")
async def neo4j_status(_=Depends(verify_api_key)):
    """获取 Neo4j 连接状态"""
    if not NEO4J_AVAILABLE:
        return {
            "available": False,
            "connected": False,
            "message": "Neo4j driver not installed"
        }
    
    try:
        manager = get_neo4j_manager()
        connected = manager.is_connected()
        return {
            "available": True,
            "connected": connected,
            "uri": manager.uri if connected else None,
            "message": "Connected" if connected else "Not connected"
        }
    except Exception as e:
        return {
            "available": True,
            "connected": False,
            "message": str(e)
        }

@app.post("/api/v1/neo4j/sync")
async def neo4j_sync_project(request: Neo4jSyncRequest, _=Depends(verify_api_key)):
    """同步项目数据到 Neo4j"""
    if not NEO4J_AVAILABLE:
        raise HTTPException(status_code=503, detail="Neo4j not available")
    
    if not DB_AVAILABLE:
        raise HTTPException(status_code=500, detail="Database not available")
    
    manager = get_neo4j_manager()
    if not manager.is_connected():
        raise HTTPException(status_code=503, detail="Neo4j not connected")
    
    db = get_db_manager()
    project = db.get_project(request.project_id)
    if not project:
        raise HTTPException(status_code=404, detail="Project not found")
    
    # 获取项目所有实体
    entities = db.get_project_entities(request.project_id)
    entities_data = []
    for e in entities:
        entities_data.append({
            "id": e.id,
            "name": e.name,
            "type": e.type,
            "definition": e.definition,
            "aliases": json.loads(e.aliases) if e.aliases else [],
            "properties": e.attributes if hasattr(e, 'attributes') else {}
        })
    
    # 获取项目所有关系
    relations = db.get_project_relations(request.project_id)
    relations_data = []
    for r in relations:
        relations_data.append({
            "id": r.id,
            "source_entity_id": r.source_entity_id,
            "target_entity_id": r.target_entity_id,
            "relation_type": r.relation_type,
            "evidence": r.evidence,
            "properties": {}
        })
    
    # 同步到 Neo4j
    sync_project_to_neo4j(
        project_id=request.project_id,
        project_name=project.name,
        entities=entities_data,
        relations=relations_data
    )
    
    return {
        "success": True,
        "project_id": request.project_id,
        "entities_synced": len(entities_data),
        "relations_synced": len(relations_data),
        "message": f"Synced {len(entities_data)} entities and {len(relations_data)} relations to Neo4j"
    }

@app.get("/api/v1/projects/{project_id}/graph/stats")
async def get_graph_stats(project_id: str, _=Depends(verify_api_key)):
    """获取项目图统计信息"""
    if not NEO4J_AVAILABLE:
        raise HTTPException(status_code=503, detail="Neo4j not available")
    
    manager = get_neo4j_manager()
    if not manager.is_connected():
        raise HTTPException(status_code=503, detail="Neo4j not connected")
    
    stats = manager.get_graph_stats(project_id)
    return stats

@app.post("/api/v1/graph/shortest-path")
async def find_shortest_path(request: PathQueryRequest, _=Depends(verify_api_key)):
    """查找两个实体之间的最短路径"""
    if not NEO4J_AVAILABLE:
        raise HTTPException(status_code=503, detail="Neo4j not available")
    
    manager = get_neo4j_manager()
    if not manager.is_connected():
        raise HTTPException(status_code=503, detail="Neo4j not connected")
    
    path = manager.find_shortest_path(
        request.source_entity_id,
        request.target_entity_id,
        request.max_depth
    )
    
    if not path:
        return {
            "found": False,
            "message": "No path found between entities"
        }
    
    return {
        "found": True,
        "path": {
            "nodes": path.nodes,
            "relationships": path.relationships,
            "length": path.length
        }
    }

@app.post("/api/v1/graph/paths")
async def find_all_paths(request: PathQueryRequest, _=Depends(verify_api_key)):
    """查找两个实体之间的所有路径"""
    if not NEO4J_AVAILABLE:
        raise HTTPException(status_code=503, detail="Neo4j not available")
    
    manager = get_neo4j_manager()
    if not manager.is_connected():
        raise HTTPException(status_code=503, detail="Neo4j not connected")
    
    paths = manager.find_all_paths(
        request.source_entity_id,
        request.target_entity_id,
        request.max_depth
    )
    
    return {
        "count": len(paths),
        "paths": [
            {
                "nodes": p.nodes,
                "relationships": p.relationships,
                "length": p.length
            }
            for p in paths
        ]
    }

@app.get("/api/v1/entities/{entity_id}/neighbors")
async def get_entity_neighbors(
    entity_id: str,
    relation_type: str = None,
    limit: int = 50,
    _=Depends(verify_api_key)
):
    """获取实体的邻居节点"""
    if not NEO4J_AVAILABLE:
        raise HTTPException(status_code=503, detail="Neo4j not available")
    
    manager = get_neo4j_manager()
    if not manager.is_connected():
        raise HTTPException(status_code=503, detail="Neo4j not connected")
    
    neighbors = manager.find_neighbors(entity_id, relation_type, limit)
    return {
        "entity_id": entity_id,
        "count": len(neighbors),
        "neighbors": neighbors
    }

@app.get("/api/v1/entities/{entity_id1}/common-neighbors/{entity_id2}")
async def get_common_neighbors(entity_id1: str, entity_id2: str, _=Depends(verify_api_key)):
    """获取两个实体的共同邻居"""
    if not NEO4J_AVAILABLE:
        raise HTTPException(status_code=503, detail="Neo4j not available")
    
    manager = get_neo4j_manager()
    if not manager.is_connected():
        raise HTTPException(status_code=503, detail="Neo4j not connected")
    
    common = manager.find_common_neighbors(entity_id1, entity_id2)
    return {
        "entity_id1": entity_id1,
        "entity_id2": entity_id2,
        "count": len(common),
        "common_neighbors": common
    }

@app.get("/api/v1/projects/{project_id}/graph/centrality")
async def get_centrality_analysis(
    project_id: str,
    metric: str = "degree",
    _=Depends(verify_api_key)
):
    """获取中心性分析结果"""
    if not NEO4J_AVAILABLE:
        raise HTTPException(status_code=503, detail="Neo4j not available")
    
    manager = get_neo4j_manager()
    if not manager.is_connected():
        raise HTTPException(status_code=503, detail="Neo4j not connected")
    
    rankings = manager.find_central_entities(project_id, metric)
    return {
        "metric": metric,
        "count": len(rankings),
        "rankings": [
            {
                "entity_id": r.entity_id,
                "entity_name": r.entity_name,
                "score": r.score,
                "rank": r.rank
            }
            for r in rankings
        ]
    }

@app.get("/api/v1/projects/{project_id}/graph/communities")
async def get_communities(project_id: str, _=Depends(verify_api_key)):
    """获取社区发现结果"""
    if not NEO4J_AVAILABLE:
        raise HTTPException(status_code=503, detail="Neo4j not available")
    
    manager = get_neo4j_manager()
    if not manager.is_connected():
        raise HTTPException(status_code=503, detail="Neo4j not connected")
    
    communities = manager.detect_communities(project_id)
    return {
        "count": len(communities),
        "communities": [
            {
                "community_id": c.community_id,
                "size": c.size,
                "density": c.density,
                "nodes": c.nodes
            }
            for c in communities
        ]
    }

@app.post("/api/v1/graph/subgraph")
async def get_subgraph(request: GraphQueryRequest, _=Depends(verify_api_key)):
    """获取子图"""
    if not NEO4J_AVAILABLE:
        raise HTTPException(status_code=503, detail="Neo4j not available")
    
    manager = get_neo4j_manager()
    if not manager.is_connected():
        raise HTTPException(status_code=503, detail="Neo4j not connected")
    
    subgraph = manager.get_subgraph(request.entity_ids, request.depth)
    return subgraph


# ==================== Phase 6: API Key Management Endpoints ====================

@app.post("/api/v1/api-keys", response_model=ApiKeyCreateResponse, tags=["API Keys"])
async def create_api_key(request: ApiKeyCreate, _=Depends(verify_api_key)):
    """
    创建新的 API Key
    
    - **name**: API Key 的名称/描述
    - **permissions**: 权限列表，可选值: read, write, delete
    - **rate_limit**: 每分钟请求限制，默认 60
    - **expires_days**: 过期天数（可选，不设置则永不过期）
    """
    if not API_KEY_AVAILABLE:
        raise HTTPException(status_code=503, detail="API Key management not available")
    
    key_manager = get_api_key_manager()
    raw_key, api_key = key_manager.create_key(
        name=request.name,
        permissions=request.permissions,
        rate_limit=request.rate_limit,
        expires_days=request.expires_days
    )
    
    return ApiKeyCreateResponse(
        api_key=raw_key,
        info=ApiKeyResponse(
            id=api_key.id,
            key_preview=api_key.key_preview,
            name=api_key.name,
            permissions=api_key.permissions,
            rate_limit=api_key.rate_limit,
            status=api_key.status,
            created_at=api_key.created_at,
            expires_at=api_key.expires_at,
            last_used_at=api_key.last_used_at,
            total_calls=api_key.total_calls
        )
    )


@app.get("/api/v1/api-keys", response_model=ApiKeyListResponse, tags=["API Keys"])
async def list_api_keys(
    status: Optional[str] = None,
    limit: int = 100,
    offset: int = 0,
    _=Depends(verify_api_key)
):
    """
    列出所有 API Keys
    
    - **status**: 按状态筛选 (active, revoked, expired)
    - **limit**: 返回数量限制
    - **offset**: 分页偏移
    """
    if not API_KEY_AVAILABLE:
        raise HTTPException(status_code=503, detail="API Key management not available")
    
    key_manager = get_api_key_manager()
    keys = key_manager.list_keys(status=status, limit=limit, offset=offset)
    
    return ApiKeyListResponse(
        keys=[
            ApiKeyResponse(
                id=k.id,
                key_preview=k.key_preview,
                name=k.name,
                permissions=k.permissions,
                rate_limit=k.rate_limit,
                status=k.status,
                created_at=k.created_at,
                expires_at=k.expires_at,
                last_used_at=k.last_used_at,
                total_calls=k.total_calls
            )
            for k in keys
        ],
        total=len(keys)
    )


@app.get("/api/v1/api-keys/{key_id}", response_model=ApiKeyResponse, tags=["API Keys"])
async def get_api_key(key_id: str, _=Depends(verify_api_key)):
    """获取单个 API Key 详情"""
    if not API_KEY_AVAILABLE:
        raise HTTPException(status_code=503, detail="API Key management not available")
    
    key_manager = get_api_key_manager()
    key = key_manager.get_key_by_id(key_id)
    
    if not key:
        raise HTTPException(status_code=404, detail="API Key not found")
    
    return ApiKeyResponse(
        id=key.id,
        key_preview=key.key_preview,
        name=key.name,
        permissions=key.permissions,
        rate_limit=key.rate_limit,
        status=key.status,
        created_at=key.created_at,
        expires_at=key.expires_at,
        last_used_at=key.last_used_at,
        total_calls=key.total_calls
    )


@app.patch("/api/v1/api-keys/{key_id}", response_model=ApiKeyResponse, tags=["API Keys"])
async def update_api_key(key_id: str, request: ApiKeyUpdate, _=Depends(verify_api_key)):
    """
    更新 API Key 信息
    
    可以更新的字段：name, permissions, rate_limit
    """
    if not API_KEY_AVAILABLE:
        raise HTTPException(status_code=503, detail="API Key management not available")
    
    key_manager = get_api_key_manager()
    
    # 构建更新数据
    updates = {}
    if request.name is not None:
        updates["name"] = request.name
    if request.permissions is not None:
        updates["permissions"] = request.permissions
    if request.rate_limit is not None:
        updates["rate_limit"] = request.rate_limit
    
    if not updates:
        raise HTTPException(status_code=400, detail="No fields to update")
    
    success = key_manager.update_key(key_id, **updates)
    
    if not success:
        raise HTTPException(status_code=404, detail="API Key not found")
    
    # 返回更新后的 key
    key = key_manager.get_key_by_id(key_id)
    return ApiKeyResponse(
        id=key.id,
        key_preview=key.key_preview,
        name=key.name,
        permissions=key.permissions,
        rate_limit=key.rate_limit,
        status=key.status,
        created_at=key.created_at,
        expires_at=key.expires_at,
        last_used_at=key.last_used_at,
        total_calls=key.total_calls
    )


@app.delete("/api/v1/api-keys/{key_id}", tags=["API Keys"])
async def revoke_api_key(key_id: str, reason: str = "", _=Depends(verify_api_key)):
    """
    撤销 API Key
    
    撤销后的 Key 将无法再使用，但记录会保留用于审计
    """
    if not API_KEY_AVAILABLE:
        raise HTTPException(status_code=503, detail="API Key management not available")
    
    key_manager = get_api_key_manager()
    success = key_manager.revoke_key(key_id, reason=reason)
    
    if not success:
        raise HTTPException(status_code=404, detail="API Key not found or already revoked")
    
    return {"success": True, "message": f"API Key {key_id} revoked"}


@app.get("/api/v1/api-keys/{key_id}/stats", response_model=ApiStatsResponse, tags=["API Keys"])
async def get_api_key_stats(key_id: str, days: int = 30, _=Depends(verify_api_key)):
    """
    获取 API Key 的调用统计
    
    - **days**: 统计天数，默认 30 天
    """
    if not API_KEY_AVAILABLE:
        raise HTTPException(status_code=503, detail="API Key management not available")
    
    key_manager = get_api_key_manager()
    
    # 验证 key 存在
    key = key_manager.get_key_by_id(key_id)
    if not key:
        raise HTTPException(status_code=404, detail="API Key not found")
    
    stats = key_manager.get_call_stats(key_id, days=days)
    
    return ApiStatsResponse(
        summary=ApiCallStats(**stats["summary"]),
        endpoints=stats["endpoints"],
        daily=stats["daily"]
    )


@app.get("/api/v1/api-keys/{key_id}/logs", response_model=ApiLogsResponse, tags=["API Keys"])
async def get_api_key_logs(
    key_id: str,
    limit: int = 100,
    offset: int = 0,
    _=Depends(verify_api_key)
):
    """
    获取 API Key 的调用日志
    
    - **limit**: 返回数量限制
    - **offset**: 分页偏移
    """
    if not API_KEY_AVAILABLE:
        raise HTTPException(status_code=503, detail="API Key management not available")
    
    key_manager = get_api_key_manager()
    
    # 验证 key 存在
    key = key_manager.get_key_by_id(key_id)
    if not key:
        raise HTTPException(status_code=404, detail="API Key not found")
    
    logs = key_manager.get_call_logs(key_id, limit=limit, offset=offset)
    
    return ApiLogsResponse(
        logs=[
            ApiCallLog(
                id=log["id"],
                endpoint=log["endpoint"],
                method=log["method"],
                status_code=log["status_code"],
                response_time_ms=log["response_time_ms"],
                ip_address=log["ip_address"],
                user_agent=log["user_agent"],
                error_message=log["error_message"],
                created_at=log["created_at"]
            )
            for log in logs
        ],
        total=len(logs)
    )


@app.get("/api/v1/rate-limit/status", response_model=RateLimitStatus, tags=["API Keys"])
async def get_rate_limit_status(request: Request, _=Depends(verify_api_key)):
    """获取当前请求的限流状态"""
    if not RATE_LIMITER_AVAILABLE:
        return RateLimitStatus(
            limit=60,
            remaining=60,
            reset_time=int(time.time()) + 60,
            window="minute"
        )
    
    limiter = get_rate_limiter()
    
    # 获取限流键
    if hasattr(request.state, 'api_key') and request.state.api_key:
        api_key = request.state.api_key
        limit_key = f"api_key:{api_key.id}"
        limit = api_key.rate_limit
    else:
        client_ip = request.client.host if request.client else "unknown"
        limit_key = f"ip:{client_ip}"
        limit = 10
    
    info = await limiter.get_limit_info(limit_key)
    
    return RateLimitStatus(
        limit=limit,
        remaining=info.remaining,
        reset_time=info.reset_time,
        window="minute"
    )


# ==================== Phase 6: System Endpoints ====================

@app.get("/api/v1/health", tags=["System"])
async def health_check():
    """健康检查端点"""
    return {
        "status": "healthy",
        "version": "0.7.0",
        "timestamp": datetime.now().isoformat()
    }


@app.get("/api/v1/status", tags=["System"])
async def system_status():
    """系统状态信息"""
    status = {
        "version": "0.7.0",
        "phase": "Phase 7 - Plugin & Integration",
        "features": {
            "database": DB_AVAILABLE,
            "oss": OSS_AVAILABLE,
            "tingwu": TINGWU_AVAILABLE,
            "llm": LLM_CLIENT_AVAILABLE,
            "neo4j": NEO4J_AVAILABLE,
            "export": EXPORT_AVAILABLE,
            "api_keys": API_KEY_AVAILABLE,
            "rate_limiting": RATE_LIMITER_AVAILABLE,
            "workflow": WORKFLOW_AVAILABLE,
            "multimodal": MULTIMODAL_AVAILABLE,
            "multimodal_linker": MULTIMODAL_LINKER_AVAILABLE,
            "plugin_manager": PLUGIN_MANAGER_AVAILABLE,
        },
        "api": {
            "documentation": "/docs",
            "openapi": "/openapi.json",
        },
        "timestamp": datetime.now().isoformat()
    }
    
    return status


# ==================== Phase 7: Workflow Automation Endpoints ====================

# Workflow Manager singleton
_workflow_manager = None

def get_workflow_manager_instance():
    global _workflow_manager
    if _workflow_manager is None and WORKFLOW_AVAILABLE and DB_AVAILABLE:
        from workflow_manager import WorkflowManager
        db = get_db_manager()
        _workflow_manager = WorkflowManager(db)
        _workflow_manager.start()
    return _workflow_manager


@app.post("/api/v1/workflows", response_model=WorkflowResponse, tags=["Workflows"])
async def create_workflow_endpoint(request: WorkflowCreate, _=Depends(verify_api_key)):
    """
    创建工作流
    
    工作流类型:
    - **auto_analyze**: 自动分析新上传的文件
    - **auto_align**: 自动实体对齐
    - **auto_relation**: 自动关系发现
    - **scheduled_report**: 定时报告
    - **custom**: 自定义工作流
    
    调度类型:
    - **manual**: 手动触发
    - **cron**: Cron 表达式调度
    - **interval**: 间隔调度（分钟数）
    
    定时规则示例:
    - `0 9 * * *` - 每天上午9点 (cron)
    - `60` - 每60分钟执行一次 (interval)
    """
    if not WORKFLOW_AVAILABLE:
        raise HTTPException(status_code=503, detail="Workflow automation not available")
    
    manager = get_workflow_manager_instance()
    
    try:
        workflow = Workflow(
            id=str(uuid.uuid4())[:8],
            name=request.name,
            description=request.description,
            workflow_type=request.workflow_type,
            project_id=request.project_id,
            schedule=request.schedule,
            schedule_type=request.schedule_type,
            config=request.config,
            webhook_ids=request.webhook_ids
        )
        
        created = manager.create_workflow(workflow)
        
        return WorkflowResponse(
            id=created.id,
            name=created.name,
            description=created.description,
            workflow_type=created.workflow_type,
            project_id=created.project_id,
            status=created.status,
            schedule=created.schedule,
            schedule_type=created.schedule_type,
            config=created.config,
            webhook_ids=created.webhook_ids,
            is_active=created.is_active,
            created_at=created.created_at,
            updated_at=created.updated_at,
            last_run_at=created.last_run_at,
            next_run_at=created.next_run_at,
            run_count=created.run_count,
            success_count=created.success_count,
            fail_count=created.fail_count
        )
    except ValueError as e:
        raise HTTPException(status_code=400, detail=str(e))


@app.get("/api/v1/workflows", response_model=WorkflowListResponse, tags=["Workflows"])
async def list_workflows_endpoint(
    project_id: Optional[str] = None,
    status: Optional[str] = None,
    workflow_type: Optional[str] = None,
    _=Depends(verify_api_key)
):
    """获取工作流列表"""
    if not WORKFLOW_AVAILABLE:
        raise HTTPException(status_code=503, detail="Workflow automation not available")
    
    manager = get_workflow_manager_instance()
    workflows = manager.list_workflows(project_id, status, workflow_type)
    
    return WorkflowListResponse(
        workflows=[
            WorkflowResponse(
                id=w.id,
                name=w.name,
                description=w.description,
                workflow_type=w.workflow_type,
                project_id=w.project_id,
                status=w.status,
                schedule=w.schedule,
                schedule_type=w.schedule_type,
                config=w.config,
                webhook_ids=w.webhook_ids,
                is_active=w.is_active,
                created_at=w.created_at,
                updated_at=w.updated_at,
                last_run_at=w.last_run_at,
                next_run_at=w.next_run_at,
                run_count=w.run_count,
                success_count=w.success_count,
                fail_count=w.fail_count
            )
            for w in workflows
        ],
        total=len(workflows)
    )


@app.get("/api/v1/workflows/{workflow_id}", response_model=WorkflowResponse, tags=["Workflows"])
async def get_workflow_endpoint(workflow_id: str, _=Depends(verify_api_key)):
    """获取单个工作流详情"""
    if not WORKFLOW_AVAILABLE:
        raise HTTPException(status_code=503, detail="Workflow automation not available")
    
    manager = get_workflow_manager_instance()
    workflow = manager.get_workflow(workflow_id)
    
    if not workflow:
        raise HTTPException(status_code=404, detail="Workflow not found")
    
    return WorkflowResponse(
        id=workflow.id,
        name=workflow.name,
        description=workflow.description,
        workflow_type=workflow.workflow_type,
        project_id=workflow.project_id,
        status=workflow.status,
        schedule=workflow.schedule,
        schedule_type=workflow.schedule_type,
        config=workflow.config,
        webhook_ids=workflow.webhook_ids,
        is_active=workflow.is_active,
        created_at=workflow.created_at,
        updated_at=workflow.updated_at,
        last_run_at=workflow.last_run_at,
        next_run_at=workflow.next_run_at,
        run_count=workflow.run_count,
        success_count=workflow.success_count,
        fail_count=workflow.fail_count
    )


@app.patch("/api/v1/workflows/{workflow_id}", response_model=WorkflowResponse, tags=["Workflows"])
async def update_workflow_endpoint(workflow_id: str, request: WorkflowUpdate, _=Depends(verify_api_key)):
    """更新工作流"""
    if not WORKFLOW_AVAILABLE:
        raise HTTPException(status_code=503, detail="Workflow automation not available")
    
    manager = get_workflow_manager_instance()
    
    update_data = {k: v for k, v in request.dict().items() if v is not None}
    updated = manager.update_workflow(workflow_id, **update_data)
    
    if not updated:
        raise HTTPException(status_code=404, detail="Workflow not found")
    
    return WorkflowResponse(
        id=updated.id,
        name=updated.name,
        description=updated.description,
        workflow_type=updated.workflow_type,
        project_id=updated.project_id,
        status=updated.status,
        schedule=updated.schedule,
        schedule_type=updated.schedule_type,
        config=updated.config,
        webhook_ids=updated.webhook_ids,
        is_active=updated.is_active,
        created_at=updated.created_at,
        updated_at=updated.updated_at,
        last_run_at=updated.last_run_at,
        next_run_at=updated.next_run_at,
        run_count=updated.run_count,
        success_count=updated.success_count,
        fail_count=updated.fail_count
    )


@app.delete("/api/v1/workflows/{workflow_id}", tags=["Workflows"])
async def delete_workflow_endpoint(workflow_id: str, _=Depends(verify_api_key)):
    """删除工作流"""
    if not WORKFLOW_AVAILABLE:
        raise HTTPException(status_code=503, detail="Workflow automation not available")
    
    manager = get_workflow_manager_instance()
    success = manager.delete_workflow(workflow_id)
    
    if not success:
        raise HTTPException(status_code=404, detail="Workflow not found")
    
    return {"success": True, "message": "Workflow deleted successfully"}


@app.post("/api/v1/workflows/{workflow_id}/trigger", response_model=WorkflowTriggerResponse, tags=["Workflows"])
async def trigger_workflow_endpoint(workflow_id: str, request: WorkflowTriggerRequest = None, _=Depends(verify_api_key)):
    """手动触发工作流"""
    if not WORKFLOW_AVAILABLE:
        raise HTTPException(status_code=503, detail="Workflow automation not available")
    
    manager = get_workflow_manager_instance()
    
    try:
        result = await manager.execute_workflow(
            workflow_id,
            input_data=request.input_data if request else {}
        )
        
        return WorkflowTriggerResponse(
            success=result["success"],
            workflow_id=result["workflow_id"],
            log_id=result["log_id"],
            results=result["results"],
            duration_ms=result["duration_ms"]
        )
    except ValueError as e:
        raise HTTPException(status_code=404, detail=str(e))
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))


@app.get("/api/v1/workflows/{workflow_id}/logs", response_model=WorkflowLogListResponse, tags=["Workflows"])
async def get_workflow_logs_endpoint(
    workflow_id: str,
    status: Optional[str] = None,
    limit: int = 100,
    offset: int = 0,
    _=Depends(verify_api_key)
):
    """获取工作流执行日志"""
    if not WORKFLOW_AVAILABLE:
        raise HTTPException(status_code=503, detail="Workflow automation not available")
    
    manager = get_workflow_manager_instance()
    logs = manager.list_logs(workflow_id=workflow_id, status=status, limit=limit, offset=offset)
    
    return WorkflowLogListResponse(
        logs=[
            WorkflowLogResponse(
                id=log.id,
                workflow_id=log.workflow_id,
                task_id=log.task_id,
                status=log.status,
                start_time=log.start_time,
                end_time=log.end_time,
                duration_ms=log.duration_ms,
                input_data=log.input_data,
                output_data=log.output_data,
                error_message=log.error_message,
                created_at=log.created_at
            )
            for log in logs
        ],
        total=len(logs)
    )


@app.get("/api/v1/workflows/{workflow_id}/stats", response_model=WorkflowStatsResponse, tags=["Workflows"])
async def get_workflow_stats_endpoint(workflow_id: str, days: int = 30, _=Depends(verify_api_key)):
    """获取工作流执行统计"""
    if not WORKFLOW_AVAILABLE:
        raise HTTPException(status_code=503, detail="Workflow automation not available")
    
    manager = get_workflow_manager_instance()
    stats = manager.get_workflow_stats(workflow_id, days)
    
    return WorkflowStatsResponse(**stats)


# ==================== Phase 7: Webhook Endpoints ====================

@app.post("/api/v1/webhooks", response_model=WebhookResponse, tags=["Webhooks"])
async def create_webhook_endpoint(request: WebhookCreate, _=Depends(verify_api_key)):
    """
    创建 Webhook 配置
    
    Webhook 类型:
    - **feishu**: 飞书机器人
    - **dingtalk**: 钉钉机器人
    - **slack**: Slack Incoming Webhook
    - **custom**: 自定义 Webhook
    """
    if not WORKFLOW_AVAILABLE:
        raise HTTPException(status_code=503, detail="Workflow automation not available")
    
    manager = get_workflow_manager_instance()
    
    try:
        webhook = WebhookConfig(
            id=str(uuid.uuid4())[:8],
            name=request.name,
            webhook_type=request.webhook_type,
            url=request.url,
            secret=request.secret,
            headers=request.headers,
            template=request.template
        )
        
        created = manager.create_webhook(webhook)
        
        return WebhookResponse(
            id=created.id,
            name=created.name,
            webhook_type=created.webhook_type,
            url=created.url,
            headers=created.headers,
            template=created.template,
            is_active=created.is_active,
            created_at=created.created_at,
            updated_at=created.updated_at,
            last_used_at=created.last_used_at,
            success_count=created.success_count,
            fail_count=created.fail_count
        )
    except ValueError as e:
        raise HTTPException(status_code=400, detail=str(e))


@app.get("/api/v1/webhooks", response_model=WebhookListResponse, tags=["Webhooks"])
async def list_webhooks_endpoint(_=Depends(verify_api_key)):
    """获取 Webhook 列表"""
    if not WORKFLOW_AVAILABLE:
        raise HTTPException(status_code=503, detail="Workflow automation not available")
    
    manager = get_workflow_manager_instance()
    webhooks = manager.list_webhooks()
    
    return WebhookListResponse(
        webhooks=[
            WebhookResponse(
                id=w.id,
                name=w.name,
                webhook_type=w.webhook_type,
                url=w.url,
                headers=w.headers,
                template=w.template,
                is_active=w.is_active,
                created_at=w.created_at,
                updated_at=w.updated_at,
                last_used_at=w.last_used_at,
                success_count=w.success_count,
                fail_count=w.fail_count
            )
            for w in webhooks
        ],
        total=len(webhooks)
    )


@app.get("/api/v1/webhooks/{webhook_id}", response_model=WebhookResponse, tags=["Webhooks"])
async def get_webhook_endpoint(webhook_id: str, _=Depends(verify_api_key)):
    """获取单个 Webhook 详情"""
    if not WORKFLOW_AVAILABLE:
        raise HTTPException(status_code=503, detail="Workflow automation not available")
    
    manager = get_workflow_manager_instance()
    webhook = manager.get_webhook(webhook_id)
    
    if not webhook:
        raise HTTPException(status_code=404, detail="Webhook not found")
    
    return WebhookResponse(
        id=webhook.id,
        name=webhook.name,
        webhook_type=webhook.webhook_type,
        url=webhook.url,
        headers=webhook.headers,
        template=webhook.template,
        is_active=webhook.is_active,
        created_at=webhook.created_at,
        updated_at=webhook.updated_at,
        last_used_at=webhook.last_used_at,
        success_count=webhook.success_count,
        fail_count=webhook.fail_count
    )


@app.patch("/api/v1/webhooks/{webhook_id}", response_model=WebhookResponse, tags=["Webhooks"])
async def update_webhook_endpoint(webhook_id: str, request: WebhookUpdate, _=Depends(verify_api_key)):
    """更新 Webhook 配置"""
    if not WORKFLOW_AVAILABLE:
        raise HTTPException(status_code=503, detail="Workflow automation not available")
    
    manager = get_workflow_manager_instance()
    
    update_data = {k: v for k, v in request.dict().items() if v is not None}
    updated = manager.update_webhook(webhook_id, **update_data)
    
    if not updated:
        raise HTTPException(status_code=404, detail="Webhook not found")
    
    return WebhookResponse(
        id=updated.id,
        name=updated.name,
        webhook_type=updated.webhook_type,
        url=updated.url,
        headers=updated.headers,
        template=updated.template,
        is_active=updated.is_active,
        created_at=updated.created_at,
        updated_at=updated.updated_at,
        last_used_at=updated.last_used_at,
        success_count=updated.success_count,
        fail_count=updated.fail_count
    )


@app.delete("/api/v1/webhooks/{webhook_id}", tags=["Webhooks"])
async def delete_webhook_endpoint(webhook_id: str, _=Depends(verify_api_key)):
    """删除 Webhook 配置"""
    if not WORKFLOW_AVAILABLE:
        raise HTTPException(status_code=503, detail="Workflow automation not available")
    
    manager = get_workflow_manager_instance()
    success = manager.delete_webhook(webhook_id)
    
    if not success:
        raise HTTPException(status_code=404, detail="Webhook not found")
    
    return {"success": True, "message": "Webhook deleted successfully"}


@app.post("/api/v1/webhooks/{webhook_id}/test", tags=["Webhooks"])
async def test_webhook_endpoint(webhook_id: str, _=Depends(verify_api_key)):
    """测试 Webhook 配置"""
    if not WORKFLOW_AVAILABLE:
        raise HTTPException(status_code=503, detail="Workflow automation not available")
    
    manager = get_workflow_manager_instance()
    webhook = manager.get_webhook(webhook_id)
    
    if not webhook:
        raise HTTPException(status_code=404, detail="Webhook not found")
    
    # 构建测试消息
    test_message = {
        "content": "🔔 这是来自 InsightFlow 的 Webhook 测试消息\n\n如果您收到这条消息，说明 Webhook 配置正确！"
    }
    
    if webhook.webhook_type == "slack":
        test_message = {"text": "🔔 这是来自 InsightFlow 的 Webhook 测试消息\n\n如果您收到这条消息，说明 Webhook 配置正确！"}
    
    success = await manager.notifier.send(webhook, test_message)
    manager.update_webhook_stats(webhook_id, success)
    
    if success:
        return {"success": True, "message": "Webhook test sent successfully"}
    else:
        raise HTTPException(status_code=400, detail="Webhook test failed")


# ==================== Phase 7: Multimodal Support Endpoints ====================

# Pydantic Models for Multimodal API
class VideoUploadResponse(BaseModel):
    video_id: str
    project_id: str
    filename: str
    status: str
    audio_extracted: bool
    frame_count: int
    ocr_text_preview: str
    message: str


class ImageUploadResponse(BaseModel):
    image_id: str
    project_id: str
    filename: str
    image_type: str
    ocr_text_preview: str
    description: str
    entity_count: int
    status: str


class MultimodalEntityLinkResponse(BaseModel):
    link_id: str
    source_entity_id: str
    target_entity_id: str
    source_modality: str
    target_modality: str
    link_type: str
    confidence: float
    evidence: str


class MultimodalAlignmentRequest(BaseModel):
    project_id: str
    threshold: float = 0.85


class MultimodalAlignmentResponse(BaseModel):
    project_id: str
    aligned_count: int
    links: List[MultimodalEntityLinkResponse]
    message: str


class MultimodalStatsResponse(BaseModel):
    project_id: str
    video_count: int
    image_count: int
    multimodal_entity_count: int
    cross_modal_links: int
    modality_distribution: Dict[str, int]


@app.post("/api/v1/projects/{project_id}/upload-video", response_model=VideoUploadResponse, tags=["Multimodal"])
async def upload_video_endpoint(
    project_id: str,
    file: UploadFile = File(...),
    extract_interval: int = Form(5),
    _=Depends(verify_api_key)
):
    """
    上传视频文件进行处理
    
    - 提取音频轨道
    - 提取关键帧（每 N 秒一帧）
    - 对关键帧进行 OCR 识别
    - 将视频、音频、OCR 结果整合
    
    **参数:**
    - **extract_interval**: 关键帧提取间隔（秒），默认 5 秒
    """
    if not MULTIMODAL_AVAILABLE:
        raise HTTPException(status_code=503, detail="Multimodal processing not available")
    
    if not DB_AVAILABLE:
        raise HTTPException(status_code=500, detail="Database not available")
    
    db = get_db_manager()
    project = db.get_project(project_id)
    if not project:
        raise HTTPException(status_code=404, detail="Project not found")
    
    # 读取视频文件
    video_data = await file.read()
    
    # 创建视频处理器
    processor = get_multimodal_processor(frame_interval=extract_interval)
    
    # 处理视频
    video_id = str(uuid.uuid4())[:8]
    result = processor.process_video(video_data, file.filename, project_id, video_id)
    
    if not result.success:
        raise HTTPException(status_code=500, detail=f"Video processing failed: {result.error_message}")
    
    # 保存视频信息到数据库
    conn = db.get_conn()
    now = datetime.now().isoformat()
    
    # 获取视频信息
    video_info = processor.extract_video_info(os.path.join(processor.video_dir, f"{video_id}_{file.filename}"))
    
    conn.execute(
        """INSERT INTO videos 
           (id, project_id, filename, duration, fps, resolution, 
            audio_transcript_id, full_ocr_text, extracted_entities, 
            extracted_relations, status, created_at, updated_at)
           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
        (video_id, project_id, file.filename, video_info.get('duration', 0),
         video_info.get('fps', 0), 
         json.dumps({'width': video_info.get('width', 0), 'height': video_info.get('height', 0)}),
         None, result.full_text, '[]', '[]', 'completed', now, now)
    )
    
    # 保存关键帧信息
    for frame in result.frames:
        conn.execute(
            """INSERT INTO video_frames 
               (id, video_id, frame_number, timestamp, image_url, ocr_text, extracted_entities, created_at)
               VALUES (?, ?, ?, ?, ?, ?, ?, ?)""",
            (frame.id, frame.video_id, frame.frame_number, frame.timestamp,
             frame.frame_path, frame.ocr_text, json.dumps(frame.entities_detected), now)
        )
    
    conn.commit()
    conn.close()
    
    # 提取实体和关系（复用现有的 LLM 提取逻辑）
    if result.full_text:
        raw_entities, raw_relations = extract_entities_with_llm(result.full_text)
        
        # 实体对齐并保存
        entity_name_to_id = {}
        for raw_ent in raw_entities:
            existing = align_entity(project_id, raw_ent["name"], db, raw_ent.get("definition", ""))
            
            if existing:
                entity_name_to_id[raw_ent["name"]] = existing.id
            else:
                new_ent = db.create_entity(Entity(
                    id=str(uuid.uuid4())[:8],
                    project_id=project_id,
                    name=raw_ent["name"],
                    type=raw_ent.get("type", "OTHER"),
                    definition=raw_ent.get("definition", "")
                ))
                entity_name_to_id[raw_ent["name"]] = new_ent.id
            
            # 保存多模态实体提及
            conn = db.get_conn()
            conn.execute(
                """INSERT OR REPLACE INTO multimodal_mentions 
                   (id, project_id, entity_id, modality, source_id, source_type, text_snippet, confidence, created_at)
                   VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)""",
                (str(uuid.uuid4())[:8], project_id, entity_name_to_id[raw_ent["name"]], 
                 'video', video_id, 'video_frame', raw_ent.get("name", ""), 1.0, now)
            )
            conn.commit()
            conn.close()
        
        # 保存关系
        for rel in raw_relations:
            source_id = entity_name_to_id.get(rel.get("source", ""))
            target_id = entity_name_to_id.get(rel.get("target", ""))
            if source_id and target_id:
                db.create_relation(
                    project_id=project_id,
                    source_entity_id=source_id,
                    target_entity_id=target_id,
                    relation_type=rel.get("type", "related"),
                    evidence=result.full_text[:200]
                )
        
        # 更新视频的实体和关系信息
        conn = db.get_conn()
        conn.execute(
            "UPDATE videos SET extracted_entities = ?, extracted_relations = ? WHERE id = ?",
            (json.dumps(raw_entities), json.dumps(raw_relations), video_id)
        )
        conn.commit()
        conn.close()
    
    return VideoUploadResponse(
        video_id=video_id,
        project_id=project_id,
        filename=file.filename,
        status="completed",
        audio_extracted=bool(result.audio_path),
        frame_count=len(result.frames),
        ocr_text_preview=result.full_text[:200] + "..." if len(result.full_text) > 200 else result.full_text,
        message="Video processed successfully"
    )


@app.post("/api/v1/projects/{project_id}/upload-image", response_model=ImageUploadResponse, tags=["Multimodal"])
async def upload_image_endpoint(
    project_id: str,
    file: UploadFile = File(...),
    detect_type: bool = Form(True),
    _=Depends(verify_api_key)
):
    """
    上传图片文件进行处理
    
    - 图片内容识别（白板、PPT、手写笔记）
    - 使用 OCR 识别图片中的文字
    - 提取图片中的实体和关系
    
    **参数:**
    - **detect_type**: 是否自动检测图片类型，默认 True
    """
    if not IMAGE_PROCESSOR_AVAILABLE:
        raise HTTPException(status_code=503, detail="Image processing not available")
    
    if not DB_AVAILABLE:
        raise HTTPException(status_code=500, detail="Database not available")
    
    db = get_db_manager()
    project = db.get_project(project_id)
    if not project:
        raise HTTPException(status_code=404, detail="Project not found")
    
    # 读取图片文件
    image_data = await file.read()
    
    # 创建图片处理器
    processor = get_image_processor()
    
    # 处理图片
    image_id = str(uuid.uuid4())[:8]
    result = processor.process_image(image_data, file.filename, image_id, detect_type)
    
    if not result.success:
        raise HTTPException(status_code=500, detail=f"Image processing failed: {result.error_message}")
    
    # 保存图片信息到数据库
    conn = db.get_conn()
    now = datetime.now().isoformat()
    
    conn.execute(
        """INSERT INTO images 
           (id, project_id, filename, ocr_text, description, 
            extracted_entities, extracted_relations, status, created_at, updated_at)
           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
        (image_id, project_id, file.filename, result.ocr_text, result.description,
         json.dumps([{"name": e.name, "type": e.type, "confidence": e.confidence} for e in result.entities]),
         json.dumps([{"source": r.source, "target": r.target, "type": r.relation_type} for r in result.relations]),
         'completed', now, now)
    )
    conn.commit()
    conn.close()
    
    # 保存提取的实体
    for entity in result.entities:
        existing = align_entity(project_id, entity.name, db, "")
        
        if not existing:
            new_ent = db.create_entity(Entity(
                id=str(uuid.uuid4())[:8],
                project_id=project_id,
                name=entity.name,
                type=entity.type,
                definition=""
            ))
            entity_id = new_ent.id
        else:
            entity_id = existing.id
        
        # 保存多模态实体提及
        conn = db.get_conn()
        conn.execute(
            """INSERT OR REPLACE INTO multimodal_mentions 
               (id, project_id, entity_id, modality, source_id, source_type, text_snippet, confidence, created_at)
               VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)""",
            (str(uuid.uuid4())[:8], project_id, entity_id, 
             'image', image_id, result.image_type, entity.name, entity.confidence, now)
        )
        conn.commit()
        conn.close()
    
    # 保存提取的关系
    for relation in result.relations:
        source_entity = db.get_entity_by_name(project_id, relation.source)
        target_entity = db.get_entity_by_name(project_id, relation.target)
        
        if source_entity and target_entity:
            db.create_relation(
                project_id=project_id,
                source_entity_id=source_entity.id,
                target_entity_id=target_entity.id,
                relation_type=relation.relation_type,
                evidence=result.ocr_text[:200]
            )
    
    return ImageUploadResponse(
        image_id=image_id,
        project_id=project_id,
        filename=file.filename,
        image_type=result.image_type,
        ocr_text_preview=result.ocr_text[:200] + "..." if len(result.ocr_text) > 200 else result.ocr_text,
        description=result.description,
        entity_count=len(result.entities),
        status="completed"
    )


@app.post("/api/v1/projects/{project_id}/upload-images-batch", tags=["Multimodal"])
async def upload_images_batch_endpoint(
    project_id: str,
    files: List[UploadFile] = File(...),
    _=Depends(verify_api_key)
):
    """
    批量上传图片文件进行处理
    
    支持一次上传多张图片，每张图片都会进行 OCR 和实体提取
    """
    if not IMAGE_PROCESSOR_AVAILABLE:
        raise HTTPException(status_code=503, detail="Image processing not available")
    
    if not DB_AVAILABLE:
        raise HTTPException(status_code=500, detail="Database not available")
    
    db = get_db_manager()
    project = db.get_project(project_id)
    if not project:
        raise HTTPException(status_code=404, detail="Project not found")
    
    # 读取所有图片
    images_data = []
    for file in files:
        image_data = await file.read()
        images_data.append((image_data, file.filename))
    
    # 批量处理
    processor = get_image_processor()
    batch_result = processor.process_batch(images_data, project_id)
    
    # 保存结果
    results = []
    for result in batch_result.results:
        if result.success:
            image_id = result.image_id
            
            # 保存到数据库
            conn = db.get_conn()
            now = datetime.now().isoformat()
            
            conn.execute(
                """INSERT INTO images 
                   (id, project_id, filename, ocr_text, description, 
                    extracted_entities, extracted_relations, status, created_at, updated_at)
                   VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
                (image_id, project_id, "batch_image", result.ocr_text, result.description,
                 json.dumps([{"name": e.name, "type": e.type} for e in result.entities]),
                 json.dumps([{"source": r.source, "target": r.target} for r in result.relations]),
                 'completed', now, now)
            )
            conn.commit()
            conn.close()
            
            results.append({
                "image_id": image_id,
                "status": "success",
                "image_type": result.image_type,
                "entity_count": len(result.entities)
            })
        else:
            results.append({
                "image_id": result.image_id,
                "status": "failed",
                "error": result.error_message
            })
    
    return {
        "project_id": project_id,
        "total_count": batch_result.total_count,
        "success_count": batch_result.success_count,
        "failed_count": batch_result.failed_count,
        "results": results
    }


@app.post("/api/v1/projects/{project_id}/multimodal/align", response_model=MultimodalAlignmentResponse, tags=["Multimodal"])
async def align_multimodal_entities_endpoint(
    project_id: str,
    threshold: float = 0.85,
    _=Depends(verify_api_key)
):
    """
    跨模态实体对齐
    
    对齐同一实体在不同模态（音频、视频、图片、文档）中的提及
    
    **参数:**
    - **threshold**: 相似度阈值，默认 0.85
    """
    if not MULTIMODAL_LINKER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Multimodal entity linker not available")
    
    if not DB_AVAILABLE:
        raise HTTPException(status_code=500, detail="Database not available")
    
    db = get_db_manager()
    project = db.get_project(project_id)
    if not project:
        raise HTTPException(status_code=404, detail="Project not found")
    
    # 获取所有实体
    entities = db.list_project_entities(project_id)
    
    # 获取多模态提及
    conn = db.get_conn()
    mentions = conn.execute(
        """SELECT * FROM multimodal_mentions WHERE project_id = ?""",
        (project_id,)
    ).fetchall()
    conn.close()
    
    # 按模态分组实体
    modality_entities = {"audio": [], "video": [], "image": [], "document": []}
    
    for mention in mentions:
        modality = mention['modality']
        entity = db.get_entity(mention['entity_id'])
        if entity and entity.id not in [e.get('id') for e in modality_entities[modality]]:
            modality_entities[modality].append({
                'id': entity.id,
                'name': entity.name,
                'type': entity.type,
                'definition': entity.definition,
                'aliases': entity.aliases
            })
    
    # 跨模态对齐
    linker = get_multimodal_entity_linker(similarity_threshold=threshold)
    links = linker.align_cross_modal_entities(
        project_id=project_id,
        audio_entities=modality_entities['audio'],
        video_entities=modality_entities['video'],
        image_entities=modality_entities['image'],
        document_entities=modality_entities['document']
    )
    
    # 保存关联到数据库
    conn = db.get_conn()
    now = datetime.now().isoformat()
    
    saved_links = []
    for link in links:
        conn.execute(
            """INSERT OR REPLACE INTO multimodal_entity_links 
               (id, entity_id, linked_entity_id, link_type, confidence, evidence, modalities, created_at)
               VALUES (?, ?, ?, ?, ?, ?, ?, ?)""",
            (link.id, link.source_entity_id, link.target_entity_id, link.link_type,
             link.confidence, link.evidence, 
             json.dumps([link.source_modality, link.target_modality]), now)
        )
        saved_links.append(MultimodalEntityLinkResponse(
            link_id=link.id,
            source_entity_id=link.source_entity_id,
            target_entity_id=link.target_entity_id,
            source_modality=link.source_modality,
            target_modality=link.target_modality,
            link_type=link.link_type,
            confidence=link.confidence,
            evidence=link.evidence
        ))
    
    conn.commit()
    conn.close()
    
    return MultimodalAlignmentResponse(
        project_id=project_id,
        aligned_count=len(saved_links),
        links=saved_links,
        message=f"Successfully aligned {len(saved_links)} cross-modal entity pairs"
    )


@app.get("/api/v1/projects/{project_id}/multimodal/stats", response_model=MultimodalStatsResponse, tags=["Multimodal"])
async def get_multimodal_stats_endpoint(project_id: str, _=Depends(verify_api_key)):
    """
    获取项目多模态统计信息
    
    返回项目中视频、图片数量，以及跨模态实体关联统计
    """
    if not DB_AVAILABLE:
        raise HTTPException(status_code=500, detail="Database not available")
    
    db = get_db_manager()
    project = db.get_project(project_id)
    if not project:
        raise HTTPException(status_code=404, detail="Project not found")
    
    conn = db.get_conn()
    
    # 统计视频数量
    video_count = conn.execute(
        "SELECT COUNT(*) as count FROM videos WHERE project_id = ?",
        (project_id,)
    ).fetchone()['count']
    
    # 统计图片数量
    image_count = conn.execute(
        "SELECT COUNT(*) as count FROM images WHERE project_id = ?",
        (project_id,)
    ).fetchone()['count']
    
    # 统计多模态实体提及
    multimodal_count = conn.execute(
        "SELECT COUNT(DISTINCT entity_id) as count FROM multimodal_mentions WHERE project_id = ?",
        (project_id,)
    ).fetchone()['count']
    
    # 统计跨模态关联
    cross_modal_count = conn.execute(
        "SELECT COUNT(*) as count FROM multimodal_entity_links WHERE entity_id IN (SELECT id FROM entities WHERE project_id = ?)",
        (project_id,)
    ).fetchone()['count']
    
    # 模态分布
    modality_dist = {}
    for modality in ['audio', 'video', 'image', 'document']:
        count = conn.execute(
            "SELECT COUNT(*) as count FROM multimodal_mentions WHERE project_id = ? AND modality = ?",
            (project_id, modality)
        ).fetchone()['count']
        modality_dist[modality] = count
    
    conn.close()
    
    return MultimodalStatsResponse(
        project_id=project_id,
        video_count=video_count,
        image_count=image_count,
        multimodal_entity_count=multimodal_count,
        cross_modal_links=cross_modal_count,
        modality_distribution=modality_dist
    )


@app.get("/api/v1/projects/{project_id}/videos", tags=["Multimodal"])
async def list_project_videos_endpoint(project_id: str, _=Depends(verify_api_key)):
    """获取项目的视频列表"""
    if not DB_AVAILABLE:
        raise HTTPException(status_code=500, detail="Database not available")
    
    db = get_db_manager()
    conn = db.get_conn()
    
    videos = conn.execute(
        """SELECT id, filename, duration, fps, resolution, 
                  full_ocr_text, status, created_at 
           FROM videos WHERE project_id = ? ORDER BY created_at DESC""",
        (project_id,)
    ).fetchall()
    
    conn.close()
    
    return [{
        "id": v['id'],
        "filename": v['filename'],
        "duration": v['duration'],
        "fps": v['fps'],
        "resolution": json.loads(v['resolution']) if v['resolution'] else None,
        "ocr_preview": v['full_ocr_text'][:200] + "..." if v['full_ocr_text'] and len(v['full_ocr_text']) > 200 else v['full_ocr_text'],
        "status": v['status'],
        "created_at": v['created_at']
    } for v in videos]


@app.get("/api/v1/projects/{project_id}/images", tags=["Multimodal"])
async def list_project_images_endpoint(project_id: str, _=Depends(verify_api_key)):
    """获取项目的图片列表"""
    if not DB_AVAILABLE:
        raise HTTPException(status_code=500, detail="Database not available")
    
    db = get_db_manager()
    conn = db.get_conn()
    
    images = conn.execute(
        """SELECT id, filename, ocr_text, description, 
                  extracted_entities, status, created_at 
           FROM images WHERE project_id = ? ORDER BY created_at DESC""",
        (project_id,)
    ).fetchall()
    
    conn.close()
    
    return [{
        "id": img['id'],
        "filename": img['filename'],
        "ocr_preview": img['ocr_text'][:200] + "..." if img['ocr_text'] and len(img['ocr_text']) > 200 else img['ocr_text'],
        "description": img['description'],
        "entity_count": len(json.loads(img['extracted_entities'])) if img['extracted_entities'] else 0,
        "status": img['status'],
        "created_at": img['created_at']
    } for img in images]


@app.get("/api/v1/videos/{video_id}/frames", tags=["Multimodal"])
async def get_video_frames_endpoint(video_id: str, _=Depends(verify_api_key)):
    """获取视频的关键帧列表"""
    if not DB_AVAILABLE:
        raise HTTPException(status_code=500, detail="Database not available")
    
    db = get_db_manager()
    conn = db.get_conn()
    
    frames = conn.execute(
        """SELECT id, frame_number, timestamp, image_url, ocr_text, extracted_entities
           FROM video_frames WHERE video_id = ? ORDER BY timestamp""",
        (video_id,)
    ).fetchall()
    
    conn.close()
    
    return [{
        "id": f['id'],
        "frame_number": f['frame_number'],
        "timestamp": f['timestamp'],
        "image_url": f['image_url'],
        "ocr_text": f['ocr_text'],
        "entities": json.loads(f['extracted_entities']) if f['extracted_entities'] else []
    } for f in frames]


@app.get("/api/v1/entities/{entity_id}/multimodal-mentions", tags=["Multimodal"])
async def get_entity_multimodal_mentions_endpoint(entity_id: str, _=Depends(verify_api_key)):
    """获取实体的多模态提及信息"""
    if not DB_AVAILABLE:
        raise HTTPException(status_code=500, detail="Database not available")
    
    db = get_db_manager()
    conn = db.get_conn()
    
    mentions = conn.execute(
        """SELECT m.*, e.name as entity_name
           FROM multimodal_mentions m
           JOIN entities e ON m.entity_id = e.id
           WHERE m.entity_id = ? ORDER BY m.created_at DESC""",
        (entity_id,)
    ).fetchall()
    
    conn.close()
    
    return [{
        "id": m['id'],
        "entity_id": m['entity_id'],
        "entity_name": m['entity_name'],
        "modality": m['modality'],
        "source_id": m['source_id'],
        "source_type": m['source_type'],
        "text_snippet": m['text_snippet'],
        "confidence": m['confidence'],
        "created_at": m['created_at']
    } for m in mentions]


@app.get("/api/v1/projects/{project_id}/multimodal/suggest-merges", tags=["Multimodal"])
async def suggest_multimodal_merges_endpoint(project_id: str, _=Depends(verify_api_key)):
    """
    建议多模态实体合并
    
    分析不同模态中的实体，建议可以合并的实体对
    """
    if not MULTIMODAL_LINKER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Multimodal entity linker not available")
    
    if not DB_AVAILABLE:
        raise HTTPException(status_code=500, detail="Database not available")
    
    db = get_db_manager()
    project = db.get_project(project_id)
    if not project:
        raise HTTPException(status_code=404, detail="Project not found")
    
    # 获取所有实体
    entities = db.list_project_entities(project_id)
    entity_dicts = [{
        'id': e.id,
        'name': e.name,
        'type': e.type,
        'definition': e.definition,
        'aliases': e.aliases
    } for e in entities]
    
    # 获取现有链接
    conn = db.get_conn()
    existing_links = conn.execute(
        """SELECT * FROM multimodal_entity_links 
           WHERE entity_id IN (SELECT id FROM entities WHERE project_id = ?)""",
        (project_id,)
    ).fetchall()
    conn.close()
    
    existing_link_objects = []
    for row in existing_links:
        existing_link_objects.append(EntityLink(
            id=row['id'],
            project_id=project_id,
            source_entity_id=row['entity_id'],
            target_entity_id=row['linked_entity_id'],
            link_type=row['link_type'],
            source_modality='unknown',
            target_modality='unknown',
            confidence=row['confidence'],
            evidence=row['evidence'] or ""
        ))
    
    # 获取建议
    linker = get_multimodal_entity_linker()
    suggestions = linker.suggest_entity_merges(entity_dicts, existing_link_objects)
    
    return {
        "project_id": project_id,
        "suggestion_count": len(suggestions),
        "suggestions": [
            {
                "entity1": {
                    "id": s['entity1'].get('id'),
                    "name": s['entity1'].get('name'),
                    "type": s['entity1'].get('type')
                },
                "entity2": {
                    "id": s['entity2'].get('id'),
                    "name": s['entity2'].get('name'),
                    "type": s['entity2'].get('type')
                },
                "similarity": s['similarity'],
                "match_type": s['match_type'],
                "suggested_action": s['suggested_action']
            }
            for s in suggestions[:20]  # 最多返回20个建议
        ]
    }


# ==================== Phase 7: Multimodal Support API ====================

class VideoUploadResponse(BaseModel):
    video_id: str
    filename: str
    duration: float
    fps: float
    resolution: Dict[str, int]
    frames_extracted: int
    audio_extracted: bool
    ocr_text_length: int
    status: str
    message: str


class ImageUploadResponse(BaseModel):
    image_id: str
    filename: str
    ocr_text_length: int
    description: str
    status: str
    message: str


class MultimodalEntityLinkResponse(BaseModel):
    link_id: str
    entity_id: str
    linked_entity_id: str
    link_type: str
    confidence: float
    evidence: str
    modalities: List[str]


class MultimodalProfileResponse(BaseModel):
    entity_id: str
    entity_name: str


# ==================== Phase 7 Task 7: Plugin Management Pydantic Models ====================

class PluginCreate(BaseModel):
    name: str = Field(..., description="插件名称")
    plugin_type: str = Field(..., description="插件类型: chrome_extension, feishu_bot, dingtalk_bot, zapier, make, webdav, custom")
    project_id: str = Field(..., description="关联项目ID")
    config: Dict = Field(default_factory=dict, description="插件配置")


class PluginUpdate(BaseModel):
    name: Optional[str] = None
    status: Optional[str] = None  # active, inactive, error, pending
    config: Optional[Dict] = None


class PluginResponse(BaseModel):
    id: str
    name: str
    plugin_type: str
    project_id: str
    status: str
    config: Dict
    created_at: str
    updated_at: str
    last_used_at: Optional[str]
    use_count: int


class PluginListResponse(BaseModel):
    plugins: List[PluginResponse]
    total: int


class ChromeExtensionTokenCreate(BaseModel):
    name: str = Field(..., description="令牌名称")
    project_id: Optional[str] = Field(default=None, description="关联项目ID")
    permissions: List[str] = Field(default=["read"], description="权限列表: read, write, delete")
    expires_days: Optional[int] = Field(default=None, description="过期天数")


class ChromeExtensionTokenResponse(BaseModel):
    id: str
    token: str = Field(..., description="令牌（仅显示一次）")
    name: str
    project_id: Optional[str]
    permissions: List[str]
    expires_at: Optional[str]
    created_at: str


class ChromeExtensionImportRequest(BaseModel):
    token: str = Field(..., description="Chrome扩展令牌")
    url: str = Field(..., description="网页URL")
    title: str = Field(..., description="网页标题")
    content: str = Field(..., description="网页正文内容")
    html_content: Optional[str] = Field(default=None, description="HTML内容（可选）")


class BotSessionCreate(BaseModel):
    session_id: str = Field(..., description="群ID或会话ID")
    session_name: str = Field(..., description="会话名称")
    project_id: Optional[str] = Field(default=None, description="关联项目ID")
    webhook_url: str = Field(default="", description="Webhook URL")
    secret: str = Field(default="", description="签名密钥")


class BotSessionResponse(BaseModel):
    id: str
    bot_type: str
    session_id: str
    session_name: str
    project_id: Optional[str]
    webhook_url: str
    is_active: bool
    created_at: str
    last_message_at: Optional[str]
    message_count: int


class BotMessageRequest(BaseModel):
    session_id: str = Field(..., description="会话ID")
    msg_type: str = Field(default="text", description="消息类型: text, audio, file")
    content: Dict = Field(default_factory=dict, description="消息内容")


class BotMessageResponse(BaseModel):
    success: bool
    response: str
    error: Optional[str] = None


class WebhookEndpointCreate(BaseModel):
    name: str = Field(..., description="端点名称")
    endpoint_type: str = Field(..., description="端点类型: zapier, make, custom")
    endpoint_url: str = Field(..., description="Webhook URL")
    project_id: Optional[str] = Field(default=None, description="关联项目ID")
    auth_type: str = Field(default="none", description="认证类型: none, api_key, oauth, custom")
    auth_config: Dict = Field(default_factory=dict, description="认证配置")
    trigger_events: List[str] = Field(default_factory=list, description="触发事件列表")


class WebhookEndpointResponse(BaseModel):
    id: str
    name: str
    endpoint_type: str
    endpoint_url: str
    project_id: Optional[str]
    auth_type: str
    trigger_events: List[str]
    is_active: bool
    created_at: str
    last_triggered_at: Optional[str]
    trigger_count: int


class WebhookTestResponse(BaseModel):
    success: bool
    endpoint_id: str
    message: str


class WebDAVSyncCreate(BaseModel):
    name: str = Field(..., description="同步配置名称")
    project_id: str = Field(..., description="关联项目ID")
    server_url: str = Field(..., description="WebDAV服务器URL")
    username: str = Field(..., description="用户名")
    password: str = Field(..., description="密码")
    remote_path: str = Field(default="/insightflow", description="远程路径")
    sync_mode: str = Field(default="bidirectional", description="同步模式: bidirectional, upload_only, download_only")
    sync_interval: int = Field(default=3600, description="同步间隔（秒）")


class WebDAVSyncResponse(BaseModel):
    id: str
    name: str
    project_id: str
    server_url: str
    username: str
    remote_path: str
    sync_mode: str
    sync_interval: int
    last_sync_at: Optional[str]
    last_sync_status: str
    is_active: bool
    created_at: str
    sync_count: int


class WebDAVTestResponse(BaseModel):
    success: bool
    message: str


class WebDAVSyncResult(BaseModel):
    success: bool
    message: str
    entities_count: Optional[int] = None
    relations_count: Optional[int] = None
    remote_path: Optional[str] = None
    error: Optional[str] = None


# Plugin Manager singleton
_plugin_manager_instance = None

def get_plugin_manager_instance():
    global _plugin_manager_instance
    if _plugin_manager_instance is None and PLUGIN_MANAGER_AVAILABLE and DB_AVAILABLE:
        db = get_db_manager()
        _plugin_manager_instance = get_plugin_manager(db)
    return _plugin_manager_instance


# ==================== Phase 7 Task 7: Plugin Management Endpoints ====================

@app.post("/api/v1/plugins", response_model=PluginResponse, tags=["Plugins"])
async def create_plugin_endpoint(request: PluginCreate, _=Depends(verify_api_key)):
    """
    创建插件
    
    插件类型:
    - **chrome_extension**: Chrome 扩展
    - **feishu_bot**: 飞书机器人
    - **dingtalk_bot**: 钉钉机器人
    - **zapier**: Zapier 集成
    - **make**: Make (Integromat) 集成
    - **webdav**: WebDAV 同步
    - **custom**: 自定义插件
    """
    if not PLUGIN_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Plugin manager not available")
    
    manager = get_plugin_manager_instance()
    
    plugin = Plugin(
        id=str(uuid.uuid4())[:8],
        name=request.name,
        plugin_type=request.plugin_type,
        project_id=request.project_id,
        config=request.config
    )
    
    created = manager.create_plugin(plugin)
    
    return PluginResponse(
        id=created.id,
        name=created.name,
        plugin_type=created.plugin_type,
        project_id=created.project_id,
        status=created.status,
        config=created.config,
        created_at=created.created_at,
        updated_at=created.updated_at,
        last_used_at=created.last_used_at,
        use_count=created.use_count
    )


@app.get("/api/v1/plugins", response_model=PluginListResponse, tags=["Plugins"])
async def list_plugins_endpoint(
    project_id: Optional[str] = None,
    plugin_type: Optional[str] = None,
    status: Optional[str] = None,
    _=Depends(verify_api_key)
):
    """获取插件列表"""
    if not PLUGIN_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Plugin manager not available")
    
    manager = get_plugin_manager_instance()
    plugins = manager.list_plugins(project_id, plugin_type, status)
    
    return PluginListResponse(
        plugins=[
            PluginResponse(
                id=p.id,
                name=p.name,
                plugin_type=p.plugin_type,
                project_id=p.project_id,
                status=p.status,
                config=p.config,
                created_at=p.created_at,
                updated_at=p.updated_at,
                last_used_at=p.last_used_at,
                use_count=p.use_count
            )
            for p in plugins
        ],
        total=len(plugins)
    )


@app.get("/api/v1/plugins/{plugin_id}", response_model=PluginResponse, tags=["Plugins"])
async def get_plugin_endpoint(plugin_id: str, _=Depends(verify_api_key)):
    """获取插件详情"""
    if not PLUGIN_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Plugin manager not available")
    
    manager = get_plugin_manager_instance()
    plugin = manager.get_plugin(plugin_id)
    
    if not plugin:
        raise HTTPException(status_code=404, detail="Plugin not found")
    
    return PluginResponse(
        id=plugin.id,
        name=plugin.name,
        plugin_type=plugin.plugin_type,
        project_id=plugin.project_id,
        status=plugin.status,
        config=plugin.config,
        created_at=plugin.created_at,
        updated_at=plugin.updated_at,
        last_used_at=plugin.last_used_at,
        use_count=plugin.use_count
    )


@app.patch("/api/v1/plugins/{plugin_id}", response_model=PluginResponse, tags=["Plugins"])
async def update_plugin_endpoint(plugin_id: str, request: PluginUpdate, _=Depends(verify_api_key)):
    """更新插件"""
    if not PLUGIN_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Plugin manager not available")
    
    manager = get_plugin_manager_instance()
    
    update_data = {k: v for k, v in request.dict().items() if v is not None}
    updated = manager.update_plugin(plugin_id, **update_data)
    
    if not updated:
        raise HTTPException(status_code=404, detail="Plugin not found")
    
    return PluginResponse(
        id=updated.id,
        name=updated.name,
        plugin_type=updated.plugin_type,
        project_id=updated.project_id,
        status=updated.status,
        config=updated.config,
        created_at=updated.created_at,
        updated_at=updated.updated_at,
        last_used_at=updated.last_used_at,
        use_count=updated.use_count
    )


@app.delete("/api/v1/plugins/{plugin_id}", tags=["Plugins"])
async def delete_plugin_endpoint(plugin_id: str, _=Depends(verify_api_key)):
    """删除插件"""
    if not PLUGIN_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Plugin manager not available")
    
    manager = get_plugin_manager_instance()
    success = manager.delete_plugin(plugin_id)
    
    if not success:
        raise HTTPException(status_code=404, detail="Plugin not found")
    
    return {"success": True, "message": "Plugin deleted successfully"}


# ==================== Phase 7 Task 7: Chrome Extension Endpoints ====================

@app.post("/api/v1/plugins/chrome/tokens", response_model=ChromeExtensionTokenResponse, tags=["Chrome Extension"])
async def create_chrome_token_endpoint(request: ChromeExtensionTokenCreate, _=Depends(verify_api_key)):
    """
    创建 Chrome 扩展令牌
    
    用于 Chrome 扩展验证和授权
    """
    if not PLUGIN_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Plugin manager not available")
    
    manager = get_plugin_manager_instance()
    handler = manager.get_handler(PluginType.CHROME_EXTENSION)
    
    if not handler:
        raise HTTPException(status_code=503, detail="Chrome extension handler not available")
    
    token = handler.create_token(
        name=request.name,
        project_id=request.project_id,
        permissions=request.permissions,
        expires_days=request.expires_days
    )
    
    return ChromeExtensionTokenResponse(
        id=token.id,
        token=token.token,
        name=token.name,
        project_id=token.project_id,
        permissions=token.permissions,
        expires_at=token.expires_at,
        created_at=token.created_at
    )


@app.get("/api/v1/plugins/chrome/tokens", tags=["Chrome Extension"])
async def list_chrome_tokens_endpoint(
    project_id: Optional[str] = None,
    _=Depends(verify_api_key)
):
    """列出 Chrome 扩展令牌"""
    if not PLUGIN_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Plugin manager not available")
    
    manager = get_plugin_manager_instance()
    handler = manager.get_handler(PluginType.CHROME_EXTENSION)
    
    if not handler:
        raise HTTPException(status_code=503, detail="Chrome extension handler not available")
    
    tokens = handler.list_tokens(project_id=project_id)
    
    return {
        "tokens": [
            {
                "id": t.id,
                "name": t.name,
                "project_id": t.project_id,
                "permissions": t.permissions,
                "expires_at": t.expires_at,
                "created_at": t.created_at,
                "last_used_at": t.last_used_at,
                "use_count": t.use_count,
                "is_revoked": t.is_revoked
            }
            for t in tokens
        ],
        "total": len(tokens)
    }


@app.delete("/api/v1/plugins/chrome/tokens/{token_id}", tags=["Chrome Extension"])
async def revoke_chrome_token_endpoint(token_id: str, _=Depends(verify_api_key)):
    """撤销 Chrome 扩展令牌"""
    if not PLUGIN_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Plugin manager not available")
    
    manager = get_plugin_manager_instance()
    handler = manager.get_handler(PluginType.CHROME_EXTENSION)
    
    if not handler:
        raise HTTPException(status_code=503, detail="Chrome extension handler not available")
    
    success = handler.revoke_token(token_id)
    
    if not success:
        raise HTTPException(status_code=404, detail="Token not found")
    
    return {"success": True, "message": "Token revoked successfully"}


@app.post("/api/v1/plugins/chrome/import", tags=["Chrome Extension"])
async def chrome_import_webpage_endpoint(request: ChromeExtensionImportRequest):
    """
    Chrome 扩展导入网页内容
    
    无需 API Key，使用 Chrome 扩展令牌验证
    """
    if not PLUGIN_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Plugin manager not available")
    
    manager = get_plugin_manager_instance()
    handler = manager.get_handler(PluginType.CHROME_EXTENSION)
    
    if not handler:
        raise HTTPException(status_code=503, detail="Chrome extension handler not available")
    
    # 验证令牌
    token = handler.validate_token(request.token)
    if not token:
        raise HTTPException(status_code=401, detail="Invalid or expired token")
    
    # 导入网页
    result = await handler.import_webpage(
        token=token,
        url=request.url,
        title=request.title,
        content=request.content,
        html_content=request.html_content
    )
    
    if not result["success"]:
        raise HTTPException(status_code=400, detail=result.get("error", "Import failed"))
    
    return result


# ==================== Phase 7 Task 7: Bot Endpoints ====================

@app.post("/api/v1/plugins/bot/feishu/sessions", response_model=BotSessionResponse, tags=["Bot"])
async def create_feishu_session_endpoint(request: BotSessionCreate, _=Depends(verify_api_key)):
    """创建飞书机器人会话"""
    if not PLUGIN_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Plugin manager not available")
    
    manager = get_plugin_manager_instance()
    handler = manager.get_handler(PluginType.FEISHU_BOT)
    
    if not handler:
        raise HTTPException(status_code=503, detail="Feishu bot handler not available")
    
    session = handler.create_session(
        session_id=request.session_id,
        session_name=request.session_name,
        project_id=request.project_id,
        webhook_url=request.webhook_url,
        secret=request.secret
    )
    
    return BotSessionResponse(
        id=session.id,
        bot_type=session.bot_type,
        session_id=session.session_id,
        session_name=session.session_name,
        project_id=session.project_id,
        webhook_url=session.webhook_url,
        is_active=session.is_active,
        created_at=session.created_at,
        last_message_at=session.last_message_at,
        message_count=session.message_count
    )


@app.post("/api/v1/plugins/bot/dingtalk/sessions", response_model=BotSessionResponse, tags=["Bot"])
async def create_dingtalk_session_endpoint(request: BotSessionCreate, _=Depends(verify_api_key)):
    """创建钉钉机器人会话"""
    if not PLUGIN_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Plugin manager not available")
    
    manager = get_plugin_manager_instance()
    handler = manager.get_handler(PluginType.DINGTALK_BOT)
    
    if not handler:
        raise HTTPException(status_code=503, detail="DingTalk bot handler not available")
    
    session = handler.create_session(
        session_id=request.session_id,
        session_name=request.session_name,
        project_id=request.project_id,
        webhook_url=request.webhook_url,
        secret=request.secret
    )
    
    return BotSessionResponse(
        id=session.id,
        bot_type=session.bot_type,
        session_id=session.session_id,
        session_name=session.session_name,
        project_id=session.project_id,
        webhook_url=session.webhook_url,
        is_active=session.is_active,
        created_at=session.created_at,
        last_message_at=session.last_message_at,
        message_count=session.message_count
    )


@app.get("/api/v1/plugins/bot/{bot_type}/sessions", tags=["Bot"])
async def list_bot_sessions_endpoint(
    bot_type: str,
    project_id: Optional[str] = None,
    _=Depends(verify_api_key)
):
    """列出机器人会话"""
    if not PLUGIN_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Plugin manager not available")
    
    manager = get_plugin_manager_instance()
    
    if bot_type == "feishu":
        handler = manager.get_handler(PluginType.FEISHU_BOT)
    elif bot_type == "dingtalk":
        handler = manager.get_handler(PluginType.DINGTALK_BOT)
    else:
        raise HTTPException(status_code=400, detail="Invalid bot type. Must be feishu or dingtalk")
    
    if not handler:
        raise HTTPException(status_code=503, detail=f"{bot_type} bot handler not available")
    
    sessions = handler.list_sessions(project_id=project_id)
    
    return {
        "sessions": [
            {
                "id": s.id,
                "bot_type": s.bot_type,
                "session_id": s.session_id,
                "session_name": s.session_name,
                "project_id": s.project_id,
                "is_active": s.is_active,
                "created_at": s.created_at,
                "last_message_at": s.last_message_at,
                "message_count": s.message_count
            }
            for s in sessions
        ],
        "total": len(sessions)
    }


@app.post("/api/v1/plugins/bot/{bot_type}/webhook", tags=["Bot"])
async def bot_webhook_endpoint(bot_type: str, request: Request):
    """
    机器人 Webhook 接收端点
    
    接收飞书/钉钉机器人的消息
    """
    if not PLUGIN_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Plugin manager not available")
    
    manager = get_plugin_manager_instance()
    
    if bot_type == "feishu":
        handler = manager.get_handler(PluginType.FEISHU_BOT)
    elif bot_type == "dingtalk":
        handler = manager.get_handler(PluginType.DINGTALK_BOT)
    else:
        raise HTTPException(status_code=400, detail="Invalid bot type")
    
    if not handler:
        raise HTTPException(status_code=503, detail=f"{bot_type} bot handler not available")
    
    # 获取消息内容
    message = await request.json()
    
    # 获取会话ID（飞书和钉钉的格式不同）
    if bot_type == "feishu":
        session_id = message.get('chat_id') or message.get('open_chat_id')
    else:  # dingtalk
        session_id = message.get('conversationId') or message.get('senderStaffId')
    
    if not session_id:
        raise HTTPException(status_code=400, detail="Cannot identify session")
    
    # 获取会话
    session = handler.get_session(session_id)
    if not session:
        # 自动创建会话
        session = handler.create_session(
            session_id=session_id,
            session_name=f"Auto-{session_id[:8]}",
            webhook_url=""
        )
    
    # 处理消息
    result = await handler.handle_message(session, message)
    
    # 如果配置了 webhook，发送回复
    if session.webhook_url and result.get("response"):
        await handler.send_message(session, result["response"])
    
    return result


@app.post("/api/v1/plugins/bot/{bot_type}/sessions/{session_id}/send", tags=["Bot"])
async def send_bot_message_endpoint(
    bot_type: str,
    session_id: str,
    message: str,
    _=Depends(verify_api_key)
):
    """发送消息到机器人会话"""
    if not PLUGIN_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Plugin manager not available")
    
    manager = get_plugin_manager_instance()
    
    if bot_type == "feishu":
        handler = manager.get_handler(PluginType.FEISHU_BOT)
    elif bot_type == "dingtalk":
        handler = manager.get_handler(PluginType.DINGTALK_BOT)
    else:
        raise HTTPException(status_code=400, detail="Invalid bot type")
    
    if not handler:
        raise HTTPException(status_code=503, detail=f"{bot_type} bot handler not available")
    
    session = handler.get_session(session_id)
    if not session:
        raise HTTPException(status_code=404, detail="Session not found")
    
    success = await handler.send_message(session, message)
    
    return {"success": success, "message": "Message sent" if success else "Failed to send message"}


# ==================== Phase 7 Task 7: Integration Endpoints ====================

@app.post("/api/v1/plugins/integrations/zapier", response_model=WebhookEndpointResponse, tags=["Integrations"])
async def create_zapier_endpoint(request: WebhookEndpointCreate, _=Depends(verify_api_key)):
    """创建 Zapier Webhook 端点"""
    if not PLUGIN_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Plugin manager not available")
    
    manager = get_plugin_manager_instance()
    handler = manager.get_handler(PluginType.ZAPIER)
    
    if not handler:
        raise HTTPException(status_code=503, detail="Zapier handler not available")
    
    endpoint = handler.create_endpoint(
        name=request.name,
        endpoint_url=request.endpoint_url,
        project_id=request.project_id,
        auth_type=request.auth_type,
        auth_config=request.auth_config,
        trigger_events=request.trigger_events
    )
    
    return WebhookEndpointResponse(
        id=endpoint.id,
        name=endpoint.name,
        endpoint_type=endpoint.endpoint_type,
        endpoint_url=endpoint.endpoint_url,
        project_id=endpoint.project_id,
        auth_type=endpoint.auth_type,
        trigger_events=endpoint.trigger_events,
        is_active=endpoint.is_active,
        created_at=endpoint.created_at,
        last_triggered_at=endpoint.last_triggered_at,
        trigger_count=endpoint.trigger_count
    )


@app.post("/api/v1/plugins/integrations/make", response_model=WebhookEndpointResponse, tags=["Integrations"])
async def create_make_endpoint(request: WebhookEndpointCreate, _=Depends(verify_api_key)):
    """创建 Make (Integromat) Webhook 端点"""
    if not PLUGIN_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Plugin manager not available")
    
    manager = get_plugin_manager_instance()
    handler = manager.get_handler(PluginType.MAKE)
    
    if not handler:
        raise HTTPException(status_code=503, detail="Make handler not available")
    
    endpoint = handler.create_endpoint(
        name=request.name,
        endpoint_url=request.endpoint_url,
        project_id=request.project_id,
        auth_type=request.auth_type,
        auth_config=request.auth_config,
        trigger_events=request.trigger_events
    )
    
    return WebhookEndpointResponse(
        id=endpoint.id,
        name=endpoint.name,
        endpoint_type=endpoint.endpoint_type,
        endpoint_url=endpoint.endpoint_url,
        project_id=endpoint.project_id,
        auth_type=endpoint.auth_type,
        trigger_events=endpoint.trigger_events,
        is_active=endpoint.is_active,
        created_at=endpoint.created_at,
        last_triggered_at=endpoint.last_triggered_at,
        trigger_count=endpoint.trigger_count
    )


@app.get("/api/v1/plugins/integrations/{endpoint_type}", tags=["Integrations"])
async def list_integration_endpoints_endpoint(
    endpoint_type: str,
    project_id: Optional[str] = None,
    _=Depends(verify_api_key)
):
    """列出集成端点"""
    if not PLUGIN_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Plugin manager not available")
    
    manager = get_plugin_manager_instance()
    
    if endpoint_type == "zapier":
        handler = manager.get_handler(PluginType.ZAPIER)
    elif endpoint_type == "make":
        handler = manager.get_handler(PluginType.MAKE)
    else:
        raise HTTPException(status_code=400, detail="Invalid endpoint type")
    
    if not handler:
        raise HTTPException(status_code=503, detail=f"{endpoint_type} handler not available")
    
    endpoints = handler.list_endpoints(project_id=project_id)
    
    return {
        "endpoints": [
            {
                "id": e.id,
                "name": e.name,
                "endpoint_type": e.endpoint_type,
                "endpoint_url": e.endpoint_url,
                "project_id": e.project_id,
                "auth_type": e.auth_type,
                "trigger_events": e.trigger_events,
                "is_active": e.is_active,
                "created_at": e.created_at,
                "last_triggered_at": e.last_triggered_at,
                "trigger_count": e.trigger_count
            }
            for e in endpoints
        ],
        "total": len(endpoints)
    }


@app.post("/api/v1/plugins/integrations/{endpoint_id}/test", response_model=WebhookTestResponse, tags=["Integrations"])
async def test_integration_endpoint(endpoint_id: str, _=Depends(verify_api_key)):
    """测试集成端点"""
    if not PLUGIN_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Plugin manager not available")
    
    manager = get_plugin_manager_instance()
    
    # 尝试获取端点（可能是 Zapier 或 Make）
    handler = manager.get_handler(PluginType.ZAPIER)
    endpoint = handler.get_endpoint(endpoint_id) if handler else None
    
    if not endpoint:
        handler = manager.get_handler(PluginType.MAKE)
        endpoint = handler.get_endpoint(endpoint_id) if handler else None
    
    if not endpoint:
        raise HTTPException(status_code=404, detail="Endpoint not found")
    
    result = await handler.test_endpoint(endpoint)
    
    return WebhookTestResponse(
        success=result["success"],
        endpoint_id=endpoint_id,
        message=result["message"]
    )


@app.post("/api/v1/plugins/integrations/{endpoint_id}/trigger", tags=["Integrations"])
async def trigger_integration_endpoint(
    endpoint_id: str,
    event_type: str,
    data: Dict,
    _=Depends(verify_api_key)
):
    """手动触发集成端点"""
    if not PLUGIN_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Plugin manager not available")
    
    manager = get_plugin_manager_instance()
    
    # 尝试获取端点（可能是 Zapier 或 Make）
    handler = manager.get_handler(PluginType.ZAPIER)
    endpoint = handler.get_endpoint(endpoint_id) if handler else None
    
    if not endpoint:
        handler = manager.get_handler(PluginType.MAKE)
        endpoint = handler.get_endpoint(endpoint_id) if handler else None
    
    if not endpoint:
        raise HTTPException(status_code=404, detail="Endpoint not found")
    
    success = await handler.trigger(endpoint, event_type, data)
    
    return {"success": success, "message": "Triggered successfully" if success else "Trigger failed"}


# ==================== Phase 7 Task 7: WebDAV Endpoints ====================

@app.post("/api/v1/plugins/webdav", response_model=WebDAVSyncResponse, tags=["WebDAV"])
async def create_webdav_sync_endpoint(request: WebDAVSyncCreate, _=Depends(verify_api_key)):
    """
    创建 WebDAV 同步配置
    
    支持与坚果云等 WebDAV 网盘同步项目数据
    """
    if not PLUGIN_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Plugin manager not available")
    
    manager = get_plugin_manager_instance()
    handler = manager.get_handler(PluginType.WEBDAV)
    
    if not handler:
        raise HTTPException(status_code=503, detail="WebDAV handler not available")
    
    sync = handler.create_sync(
        name=request.name,
        project_id=request.project_id,
        server_url=request.server_url,
        username=request.username,
        password=request.password,
        remote_path=request.remote_path,
        sync_mode=request.sync_mode,
        sync_interval=request.sync_interval
    )
    
    return WebDAVSyncResponse(
        id=sync.id,
        name=sync.name,
        project_id=sync.project_id,
        server_url=sync.server_url,
        username=sync.username,
        remote_path=sync.remote_path,
        sync_mode=sync.sync_mode,
        sync_interval=sync.sync_interval,
        last_sync_at=sync.last_sync_at,
        last_sync_status=sync.last_sync_status,
        is_active=sync.is_active,
        created_at=sync.created_at,
        sync_count=sync.sync_count
    )


@app.get("/api/v1/plugins/webdav", tags=["WebDAV"])
async def list_webdav_syncs_endpoint(
    project_id: Optional[str] = None,
    _=Depends(verify_api_key)
):
    """列出 WebDAV 同步配置"""
    if not PLUGIN_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Plugin manager not available")
    
    manager = get_plugin_manager_instance()
    handler = manager.get_handler(PluginType.WEBDAV)
    
    if not handler:
        raise HTTPException(status_code=503, detail="WebDAV handler not available")
    
    syncs = handler.list_syncs(project_id=project_id)
    
    return {
        "syncs": [
            {
                "id": s.id,
                "name": s.name,
                "project_id": s.project_id,
                "server_url": s.server_url,
                "username": s.username,
                "remote_path": s.remote_path,
                "sync_mode": s.sync_mode,
                "sync_interval": s.sync_interval,
                "last_sync_at": s.last_sync_at,
                "last_sync_status": s.last_sync_status,
                "is_active": s.is_active,
                "created_at": s.created_at,
                "sync_count": s.sync_count
            }
            for s in syncs
        ],
        "total": len(syncs)
    }


@app.post("/api/v1/plugins/webdav/{sync_id}/test", response_model=WebDAVTestResponse, tags=["WebDAV"])
async def test_webdav_connection_endpoint(sync_id: str, _=Depends(verify_api_key)):
    """测试 WebDAV 连接"""
    if not PLUGIN_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Plugin manager not available")
    
    manager = get_plugin_manager_instance()
    handler = manager.get_handler(PluginType.WEBDAV)
    
    if not handler:
        raise HTTPException(status_code=503, detail="WebDAV handler not available")
    
    sync = handler.get_sync(sync_id)
    if not sync:
        raise HTTPException(status_code=404, detail="Sync configuration not found")
    
    result = await handler.test_connection(sync)
    
    return WebDAVTestResponse(
        success=result["success"],
        message=result.get("message") or result.get("error", "Unknown result")
    )


@app.post("/api/v1/plugins/webdav/{sync_id}/sync", response_model=WebDAVSyncResult, tags=["WebDAV"])
async def sync_webdav_endpoint(sync_id: str, _=Depends(verify_api_key)):
    """执行 WebDAV 同步"""
    if not PLUGIN_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Plugin manager not available")
    
    manager = get_plugin_manager_instance()
    handler = manager.get_handler(PluginType.WEBDAV)
    
    if not handler:
        raise HTTPException(status_code=503, detail="WebDAV handler not available")
    
    sync = handler.get_sync(sync_id)
    if not sync:
        raise HTTPException(status_code=404, detail="Sync configuration not found")
    
    result = await handler.sync_project(sync)
    
    return WebDAVSyncResult(
        success=result["success"],
        message=result.get("message") or result.get("error", "Sync completed"),
        entities_count=result.get("entities_count"),
        relations_count=result.get("relations_count"),
        remote_path=result.get("remote_path"),
        error=result.get("error")
    )


@app.delete("/api/v1/plugins/webdav/{sync_id}", tags=["WebDAV"])
async def delete_webdav_sync_endpoint(sync_id: str, _=Depends(verify_api_key)):
    """删除 WebDAV 同步配置"""
    if not PLUGIN_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Plugin manager not available")
    
    manager = get_plugin_manager_instance()
    handler = manager.get_handler(PluginType.WEBDAV)
    
    if not handler:
        raise HTTPException(status_code=503, detail="WebDAV handler not available")
    
    success = handler.delete_sync(sync_id)
    
    if not success:
        raise HTTPException(status_code=404, detail="Sync configuration not found")
    
    return {"success": True, "message": "WebDAV sync configuration deleted"}


@app.get("/api/v1/openapi.json", include_in_schema=False)
async def get_openapi():
    """获取 OpenAPI 规范"""
    from fastapi.openapi.utils import get_openapi
    return get_openapi(
        title=app.title,
        version=app.version,
        description=app.description,
        routes=app.routes,
        tags=app.openapi_tags
    )


# Serve frontend - MUST be last to not override API routes
app.mount("/", StaticFiles(directory="frontend", html=True), name="frontend")

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

class PluginCreateRequest(BaseModel):
    name: str
    plugin_type: str
    project_id: Optional[str] = None
    config: Optional[Dict] = {}


class PluginResponse(BaseModel):
    id: str
    name: str
    plugin_type: str
    project_id: Optional[str]
    status: str
    api_key: str
    created_at: str


class BotSessionResponse(BaseModel):
    id: str
    plugin_id: str
    platform: str
    session_id: str
    user_id: Optional[str]
    user_name: Optional[str]
    project_id: Optional[str]
    message_count: int
    created_at: str
    last_message_at: Optional[str]


class WebhookEndpointResponse(BaseModel):
    id: str
    plugin_id: str
    name: str
    endpoint_path: str
    endpoint_type: str
    target_project_id: Optional[str]
    is_active: bool
    trigger_count: int
    created_at: str


class WebDAVSyncResponse(BaseModel):
    id: str
    plugin_id: str
    name: str
    server_url: str
    username: str
    remote_path: str
    local_path: str
    sync_direction: str
    sync_mode: str
    auto_analyze: bool
    is_active: bool
    last_sync_at: Optional[str]
    created_at: str


class ChromeClipRequest(BaseModel):
    url: str
    title: str
    content: str
    content_type: str = "page"
    meta: Optional[Dict] = {}
    project_id: Optional[str] = None


class ChromeClipResponse(BaseModel):
    clip_id: str
    project_id: str
    url: str
    title: str
    status: str
    message: str


class BotMessageRequest(BaseModel):
    platform: str
    session_id: str
    user_id: Optional[str] = None
    user_name: Optional[str] = None
    message_type: str
    content: str
    project_id: Optional[str] = None


class BotMessageResponse(BaseModel):
    success: bool
    reply: Optional[str] = None
    session_id: str
    action: Optional[str] = None


class WebhookPayload(BaseModel):
    event: str
    data: Dict


@app.post("/api/v1/plugins", response_model=PluginResponse, tags=["Plugins"])
async def create_plugin(
    request: PluginCreateRequest,
    api_key: str = Depends(verify_api_key)
):
    """创建插件"""
    if not PLUGIN_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Plugin manager not available")
    
    manager = get_plugin_manager()
    plugin = manager.create_plugin(
        name=request.name,
        plugin_type=request.plugin_type,
        project_id=request.project_id,
        config=request.config
    )
    
    return PluginResponse(
        id=plugin.id,
        name=plugin.name,
        plugin_type=plugin.plugin_type,
        project_id=plugin.project_id,
        status=plugin.status,
        api_key=plugin.api_key,
        created_at=plugin.created_at
    )


@app.get("/api/v1/plugins", tags=["Plugins"])
async def list_plugins(
    project_id: Optional[str] = None,
    plugin_type: Optional[str] = None,
    api_key: str = Depends(verify_api_key)
):
    """列出插件"""
    if not PLUGIN_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Plugin manager not available")
    
    manager = get_plugin_manager()
    plugins = manager.list_plugins(project_id=project_id, plugin_type=plugin_type)
    
    return {
        "plugins": [
            {
                "id": p.id,
                "name": p.name,
                "plugin_type": p.plugin_type,
                "project_id": p.project_id,
                "status": p.status,
                "use_count": p.use_count,
                "created_at": p.created_at
            }
            for p in plugins
        ]
    }


@app.get("/api/v1/plugins/{plugin_id}", response_model=PluginResponse, tags=["Plugins"])
async def get_plugin(
    plugin_id: str,
    api_key: str = Depends(verify_api_key)
):
    """获取插件详情"""
    if not PLUGIN_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Plugin manager not available")
    
    manager = get_plugin_manager()
    plugin = manager.get_plugin(plugin_id)
    
    if not plugin:
        raise HTTPException(status_code=404, detail="Plugin not found")
    
    return PluginResponse(
        id=plugin.id,
        name=plugin.name,
        plugin_type=plugin.plugin_type,
        project_id=plugin.project_id,
        status=plugin.status,
        api_key=plugin.api_key,
        created_at=plugin.created_at
    )


@app.delete("/api/v1/plugins/{plugin_id}", tags=["Plugins"])
async def delete_plugin(
    plugin_id: str,
    api_key: str = Depends(verify_api_key)
):
    """删除插件"""
    if not PLUGIN_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Plugin manager not available")
    
    manager = get_plugin_manager()
    manager.delete_plugin(plugin_id)
    
    return {"success": True, "message": "Plugin deleted"}


@app.post("/api/v1/plugins/{plugin_id}/regenerate-key", tags=["Plugins"])
async def regenerate_plugin_key(
    plugin_id: str,
    api_key: str = Depends(verify_api_key)
):
    """重新生成插件 API Key"""
    if not PLUGIN_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Plugin manager not available")
    
    manager = get_plugin_manager()
    new_key = manager.regenerate_api_key(plugin_id)
    
    return {"success": True, "api_key": new_key}


# ==================== Chrome Extension API ====================

@app.post("/api/v1/plugins/chrome/clip", response_model=ChromeClipResponse, tags=["Chrome Extension"])
async def chrome_clip(
    request: ChromeClipRequest,
    x_api_key: Optional[str] = Header(None, alias="X-API-Key")
):
    """Chrome 插件保存网页内容"""
    if not PLUGIN_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Plugin manager not available")
    
    if not x_api_key:
        raise HTTPException(status_code=401, detail="API Key required")
    
    manager = get_plugin_manager()
    plugin = manager.get_plugin_by_api_key(x_api_key)
    
    if not plugin or plugin.plugin_type != "chrome_extension":
        raise HTTPException(status_code=401, detail="Invalid API Key")
    
    # 确定目标项目
    project_id = request.project_id or plugin.project_id
    if not project_id:
        raise HTTPException(status_code=400, detail="Project ID required")
    
    # 创建转录记录（将网页内容作为文档处理）
    db = get_db_manager()
    
    # 生成文档内容
    doc_content = f"""# {request.title}

URL: {request.url}

## 内容

{request.content}

## 元数据

{json.dumps(request.meta, ensure_ascii=False, indent=2)}
"""
    
    # 创建转录记录
    transcript_id = db.create_transcript(
        project_id=project_id,
        filename=f"clip_{request.title[:50]}.md",
        full_text=doc_content,
        transcript_type="document"
    )
    
    # 记录活动
    manager.log_activity(
        plugin_id=plugin.id,
        activity_type="clip",
        source="chrome_extension",
        details={
            "url": request.url,
            "title": request.title,
            "project_id": project_id,
            "transcript_id": transcript_id
        }
    )
    
    return ChromeClipResponse(
        clip_id=str(uuid.uuid4()),
        project_id=project_id,
        url=request.url,
        title=request.title,
        status="success",
        message="Content saved successfully"
    )


# ==================== Bot API ====================

@app.post("/api/v1/bots/webhook/{platform}", response_model=BotMessageResponse, tags=["Bot"])
async def bot_webhook(
    platform: str,
    request: Request,
    x_signature: Optional[str] = Header(None, alias="X-Signature")
):
    """接收机器人 Webhook 消息（飞书/钉钉/Slack）"""
    if not PLUGIN_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Plugin manager not available")
    
    body = await request.body()
    payload = json.loads(body)
    
    manager = get_plugin_manager()
    handler = BotHandler(manager)
    
    # 解析消息
    if platform == "feishu":
        message = handler.parse_feishu_message(payload)
    elif platform == "dingtalk":
        message = handler.parse_dingtalk_message(payload)
    elif platform == "slack":
        message = handler.parse_slack_message(payload)
    else:
        raise HTTPException(status_code=400, detail=f"Unsupported platform: {platform}")
    
    # 查找或创建会话
    # 这里简化处理，实际应该根据 plugin_id 查找
    # 暂时返回简单的回复
    
    return BotMessageResponse(
        success=True,
        reply="收到消息！请使用 InsightFlow 控制台查看更多功能。",
        session_id=message.get("session_id", ""),
        action="reply"
    )


@app.get("/api/v1/bots/sessions", response_model=List[BotSessionResponse], tags=["Bot"])
async def list_bot_sessions(
    plugin_id: Optional[str] = None,
    project_id: Optional[str] = None,
    api_key: str = Depends(verify_api_key)
):
    """列出机器人会话"""
    if not PLUGIN_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Plugin manager not available")
    
    manager = get_plugin_manager()
    sessions = manager.list_bot_sessions(plugin_id=plugin_id, project_id=project_id)
    
    return [
        BotSessionResponse(
            id=s.id,
            plugin_id=s.plugin_id,
            platform=s.platform,
            session_id=s.session_id,
            user_id=s.user_id,
            user_name=s.user_name,
            project_id=s.project_id,
            message_count=s.message_count,
            created_at=s.created_at,
            last_message_at=s.last_message_at
        )
        for s in sessions
    ]


# ==================== Webhook Integration API ====================

@app.post("/api/v1/webhook-endpoints", response_model=WebhookEndpointResponse, tags=["Integrations"])
async def create_webhook_endpoint(
    plugin_id: str,
    name: str,
    endpoint_type: str,
    target_project_id: Optional[str] = None,
    allowed_events: Optional[List[str]] = None,
    api_key: str = Depends(verify_api_key)
):
    """创建 Webhook 端点（用于 Zapier/Make 集成）"""
    if not PLUGIN_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Plugin manager not available")
    
    manager = get_plugin_manager()
    endpoint = manager.create_webhook_endpoint(
        plugin_id=plugin_id,
        name=name,
        endpoint_type=endpoint_type,
        target_project_id=target_project_id,
        allowed_events=allowed_events
    )
    
    return WebhookEndpointResponse(
        id=endpoint.id,
        plugin_id=endpoint.plugin_id,
        name=endpoint.name,
        endpoint_path=endpoint.endpoint_path,
        endpoint_type=endpoint.endpoint_type,
        target_project_id=endpoint.target_project_id,
        is_active=endpoint.is_active,
        trigger_count=endpoint.trigger_count,
        created_at=endpoint.created_at
    )


@app.get("/api/v1/webhook-endpoints", response_model=List[WebhookEndpointResponse], tags=["Integrations"])
async def list_webhook_endpoints(
    plugin_id: Optional[str] = None,
    api_key: str = Depends(verify_api_key)
):
    """列出 Webhook 端点"""
    if not PLUGIN_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Plugin manager not available")
    
    manager = get_plugin_manager()
    endpoints = manager.list_webhook_endpoints(plugin_id=plugin_id)
    
    return [
        WebhookEndpointResponse(
            id=e.id,
            plugin_id=e.plugin_id,
            name=e.name,
            endpoint_path=e.endpoint_path,
            endpoint_type=e.endpoint_type,
            target_project_id=e.target_project_id,
            is_active=e.is_active,
            trigger_count=e.trigger_count,
            created_at=e.created_at
        )
        for e in endpoints
    ]


@app.post("/webhook/{endpoint_type}/{token}", tags=["Integrations"])
async def receive_webhook(
    endpoint_type: str,
    token: str,
    request: Request,
    x_signature: Optional[str] = Header(None, alias="X-Signature")
):
    """接收外部 Webhook 调用（Zapier/Make/Custom）"""
    if not PLUGIN_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Plugin manager not available")
    
    manager = get_plugin_manager()
    
    # 构建完整路径查找端点
    path = f"/webhook/{endpoint_type}/{token}"
    endpoint = manager.get_webhook_endpoint_by_path(path)
    
    if not endpoint or not endpoint.is_active:
        raise HTTPException(status_code=404, detail="Webhook endpoint not found")
    
    # 验证签名（如果有）
    if endpoint.secret and x_signature:
        body = await request.body()
        integration = WebhookIntegration(manager)
        if not integration.validate_signature(body, x_signature, endpoint.secret):
            raise HTTPException(status_code=401, detail="Invalid signature")
    
    # 解析请求体
    body = await request.json()
    
    # 更新触发统计
    manager.update_webhook_trigger(endpoint.id)
    
    # 记录活动
    manager.log_activity(
        plugin_id=endpoint.plugin_id,
        activity_type="webhook",
        source=endpoint_type,
        details={
            "endpoint_id": endpoint.id,
            "event": body.get("event"),
            "data_keys": list(body.get("data", {}).keys())
        }
    )
    
    # 处理数据（简化版本）
    # 实际应该根据 endpoint.target_project_id 和 body 内容创建文档/实体等
    
    return {
        "success": True,
        "endpoint_id": endpoint.id,
        "received_at": datetime.now().isoformat()
    }


# ==================== WebDAV API ====================

@app.post("/api/v1/webdav-syncs", response_model=WebDAVSyncResponse, tags=["WebDAV"])
async def create_webdav_sync(
    plugin_id: str,
    name: str,
    server_url: str,
    username: str,
    password: str,
    remote_path: str = "/",
    local_path: str = "./sync",
    sync_direction: str = "bidirectional",
    sync_mode: str = "manual",
    auto_analyze: bool = True,
    api_key: str = Depends(verify_api_key)
):
    """创建 WebDAV 同步配置"""
    if not PLUGIN_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Plugin manager not available")
    
    manager = get_plugin_manager()
    sync = manager.create_webdav_sync(
        plugin_id=plugin_id,
        name=name,
        server_url=server_url,
        username=username,
        password=password,
        remote_path=remote_path,
        local_path=local_path,
        sync_direction=sync_direction,
        sync_mode=sync_mode,
        auto_analyze=auto_analyze
    )
    
    return WebDAVSyncResponse(
        id=sync.id,
        plugin_id=sync.plugin_id,
        name=sync.name,
        server_url=sync.server_url,
        username=sync.username,
        remote_path=sync.remote_path,
        local_path=sync.local_path,
        sync_direction=sync.sync_direction,
        sync_mode=sync.sync_mode,
        auto_analyze=sync.auto_analyze,
        is_active=sync.is_active,
        last_sync_at=sync.last_sync_at,
        created_at=sync.created_at
    )


@app.get("/api/v1/webdav-syncs", response_model=List[WebDAVSyncResponse], tags=["WebDAV"])
async def list_webdav_syncs(
    plugin_id: Optional[str] = None,
    api_key: str = Depends(verify_api_key)
):
    """列出 WebDAV 同步配置"""
    if not PLUGIN_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Plugin manager not available")
    
    manager = get_plugin_manager()
    syncs = manager.list_webdav_syncs(plugin_id=plugin_id)
    
    return [
        WebDAVSyncResponse(
            id=s.id,
            plugin_id=s.plugin_id,
            name=s.name,
            server_url=s.server_url,
            username=s.username,
            remote_path=s.remote_path,
            local_path=s.local_path,
            sync_direction=s.sync_direction,
            sync_mode=s.sync_mode,
            auto_analyze=s.auto_analyze,
            is_active=s.is_active,
            last_sync_at=s.last_sync_at,
            created_at=s.created_at
        )
        for s in syncs
    ]


@app.post("/api/v1/webdav-syncs/{sync_id}/test", tags=["WebDAV"])
async def test_webdav_connection(
    sync_id: str,
    api_key: str = Depends(verify_api_key)
):
    """测试 WebDAV 连接"""
    if not PLUGIN_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Plugin manager not available")
    
    manager = get_plugin_manager()
    sync = manager.get_webdav_sync(sync_id)
    
    if not sync:
        raise HTTPException(status_code=404, detail="WebDAV sync not found")
    
    from plugin_manager import WebDAVSync as WebDAVSyncHandler
    handler = WebDAVSyncHandler(manager)
    
    success, message = await handler.test_connection(
        sync.server_url,
        sync.username,
        sync.password
    )
    
    return {"success": success, "message": message}


@app.post("/api/v1/webdav-syncs/{sync_id}/sync", tags=["WebDAV"])
async def trigger_webdav_sync(
    sync_id: str,
    api_key: str = Depends(verify_api_key)
):
    """手动触发 WebDAV 同步"""
    if not PLUGIN_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Plugin manager not available")
    
    manager = get_plugin_manager()
    sync = manager.get_webdav_sync(sync_id)
    
    if not sync:
        raise HTTPException(status_code=404, detail="WebDAV sync not found")
    
    # 这里应该启动异步同步任务
    # 简化版本，仅返回成功
    
    manager.update_webdav_sync(
        sync_id,
        last_sync_at=datetime.now().isoformat(),
        last_sync_status="running"
    )
    
    return {
        "success": True,
        "sync_id": sync_id,
        "status": "running",
        "message": "Sync started"
    }


# ==================== Plugin Activity Logs ====================

@app.get("/api/v1/plugins/{plugin_id}/logs", tags=["Plugins"])
async def get_plugin_logs(
    plugin_id: str,
    activity_type: Optional[str] = None,
    limit: int = 100,
    api_key: str = Depends(verify_api_key)
):
    """获取插件活动日志"""
    if not PLUGIN_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Plugin manager not available")
    
    manager = get_plugin_manager()
    logs = manager.get_activity_logs(
        plugin_id=plugin_id,
        activity_type=activity_type,
        limit=limit
    )
    
    return {
        "logs": [
            {
                "id": log.id,
                "activity_type": log.activity_type,
                "source": log.source,
                "details": log.details,
                "created_at": log.created_at
            }
            for log in logs
        ]
    }


# ==================== Phase 7 Task 3: Security & Compliance API ====================

# Pydantic models for security API
class AuditLogResponse(BaseModel):
    id: str
    action_type: str
    user_id: Optional[str] = None
    user_ip: Optional[str] = None
    resource_type: Optional[str] = None
    resource_id: Optional[str] = None
    action_details: Optional[str] = None
    success: bool = True
    error_message: Optional[str] = None
    created_at: str


class AuditStatsResponse(BaseModel):
    total_actions: int
    success_count: int
    failure_count: int
    action_breakdown: Dict[str, Dict[str, int]]


class EncryptionEnableRequest(BaseModel):
    master_password: str


class EncryptionConfigResponse(BaseModel):
    id: str
    project_id: str
    is_enabled: bool
    encryption_type: str
    created_at: str
    updated_at: str


class MaskingRuleCreateRequest(BaseModel):
    name: str
    rule_type: str  # phone, email, id_card, bank_card, name, address, custom
    pattern: Optional[str] = None
    replacement: Optional[str] = None
    description: Optional[str] = None
    priority: int = 0


class MaskingRuleResponse(BaseModel):
    id: str
    project_id: str
    name: str
    rule_type: str
    pattern: str
    replacement: str
    is_active: bool
    priority: int
    description: Optional[str] = None
    created_at: str
    updated_at: str


class MaskingApplyRequest(BaseModel):
    text: str
    rule_types: Optional[List[str]] = None


class MaskingApplyResponse(BaseModel):
    original_text: str
    masked_text: str
    applied_rules: List[str]


class AccessPolicyCreateRequest(BaseModel):
    name: str
    description: Optional[str] = None
    allowed_users: Optional[List[str]] = None
    allowed_roles: Optional[List[str]] = None
    allowed_ips: Optional[List[str]] = None
    time_restrictions: Optional[Dict] = None
    max_access_count: Optional[int] = None
    require_approval: bool = False


class AccessPolicyResponse(BaseModel):
    id: str
    project_id: str
    name: str
    description: Optional[str] = None
    allowed_users: Optional[List[str]] = None
    allowed_roles: Optional[List[str]] = None
    allowed_ips: Optional[List[str]] = None
    time_restrictions: Optional[Dict] = None
    max_access_count: Optional[int] = None
    require_approval: bool = False
    is_active: bool = True
    created_at: str
    updated_at: str


class AccessRequestCreateRequest(BaseModel):
    policy_id: str
    request_reason: Optional[str] = None
    expires_hours: int = 24


class AccessRequestResponse(BaseModel):
    id: str
    policy_id: str
    user_id: str
    request_reason: Optional[str] = None
    status: str
    approved_by: Optional[str] = None
    approved_at: Optional[str] = None
    expires_at: Optional[str] = None
    created_at: str


# ==================== Audit Logs API ====================

@app.get("/api/v1/audit-logs", response_model=List[AuditLogResponse], tags=["Security"])
async def get_audit_logs(
    user_id: Optional[str] = None,
    resource_type: Optional[str] = None,
    resource_id: Optional[str] = None,
    action_type: Optional[str] = None,
    start_time: Optional[str] = None,
    end_time: Optional[str] = None,
    success: Optional[bool] = None,
    limit: int = 100,
    offset: int = 0,
    api_key: str = Depends(verify_api_key)
):
    """查询审计日志"""
    if not SECURITY_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Security manager not available")
    
    manager = get_security_manager()
    logs = manager.get_audit_logs(
        user_id=user_id,
        resource_type=resource_type,
        resource_id=resource_id,
        action_type=action_type,
        start_time=start_time,
        end_time=end_time,
        success=success,
        limit=limit,
        offset=offset
    )
    
    return [
        AuditLogResponse(
            id=log.id,
            action_type=log.action_type,
            user_id=log.user_id,
            user_ip=log.user_ip,
            resource_type=log.resource_type,
            resource_id=log.resource_id,
            action_details=log.action_details,
            success=log.success,
            error_message=log.error_message,
            created_at=log.created_at
        )
        for log in logs
    ]


@app.get("/api/v1/audit-logs/stats", response_model=AuditStatsResponse, tags=["Security"])
async def get_audit_stats(
    start_time: Optional[str] = None,
    end_time: Optional[str] = None,
    api_key: str = Depends(verify_api_key)
):
    """获取审计统计"""
    if not SECURITY_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Security manager not available")
    
    manager = get_security_manager()
    stats = manager.get_audit_stats(start_time=start_time, end_time=end_time)
    
    return AuditStatsResponse(**stats)


# ==================== Encryption API ====================

@app.post("/api/v1/projects/{project_id}/encryption/enable", response_model=EncryptionConfigResponse, tags=["Security"])
async def enable_project_encryption(
    project_id: str,
    request: EncryptionEnableRequest,
    api_key: str = Depends(verify_api_key)
):
    """启用项目端到端加密"""
    if not SECURITY_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Security manager not available")
    
    manager = get_security_manager()
    
    try:
        config = manager.enable_encryption(project_id, request.master_password)
        return EncryptionConfigResponse(
            id=config.id,
            project_id=config.project_id,
            is_enabled=config.is_enabled,
            encryption_type=config.encryption_type,
            created_at=config.created_at,
            updated_at=config.updated_at
        )
    except RuntimeError as e:
        raise HTTPException(status_code=400, detail=str(e))


@app.post("/api/v1/projects/{project_id}/encryption/disable", tags=["Security"])
async def disable_project_encryption(
    project_id: str,
    request: EncryptionEnableRequest,
    api_key: str = Depends(verify_api_key)
):
    """禁用项目加密"""
    if not SECURITY_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Security manager not available")
    
    manager = get_security_manager()
    success = manager.disable_encryption(project_id, request.master_password)
    
    if not success:
        raise HTTPException(status_code=400, detail="Invalid password or encryption not enabled")
    
    return {"success": True, "message": "Encryption disabled successfully"}


@app.post("/api/v1/projects/{project_id}/encryption/verify", tags=["Security"])
async def verify_encryption_password(
    project_id: str,
    request: EncryptionEnableRequest,
    api_key: str = Depends(verify_api_key)
):
    """验证加密密码"""
    if not SECURITY_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Security manager not available")
    
    manager = get_security_manager()
    is_valid = manager.verify_encryption_password(project_id, request.master_password)
    
    return {"valid": is_valid}


@app.get("/api/v1/projects/{project_id}/encryption", response_model=Optional[EncryptionConfigResponse], tags=["Security"])
async def get_encryption_config(
    project_id: str,
    api_key: str = Depends(verify_api_key)
):
    """获取项目加密配置"""
    if not SECURITY_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Security manager not available")
    
    manager = get_security_manager()
    config = manager.get_encryption_config(project_id)
    
    if not config:
        return None
    
    return EncryptionConfigResponse(
        id=config.id,
        project_id=config.project_id,
        is_enabled=config.is_enabled,
        encryption_type=config.encryption_type,
        created_at=config.created_at,
        updated_at=config.updated_at
    )


# ==================== Data Masking API ====================

@app.post("/api/v1/projects/{project_id}/masking-rules", response_model=MaskingRuleResponse, tags=["Security"])
async def create_masking_rule(
    project_id: str,
    request: MaskingRuleCreateRequest,
    api_key: str = Depends(verify_api_key)
):
    """创建数据脱敏规则"""
    if not SECURITY_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Security manager not available")
    
    manager = get_security_manager()
    
    try:
        rule_type = MaskingRuleType(request.rule_type)
    except ValueError:
        raise HTTPException(status_code=400, detail=f"Invalid rule type: {request.rule_type}")
    
    rule = manager.create_masking_rule(
        project_id=project_id,
        name=request.name,
        rule_type=rule_type,
        pattern=request.pattern,
        replacement=request.replacement,
        description=request.description,
        priority=request.priority
    )
    
    return MaskingRuleResponse(
        id=rule.id,
        project_id=rule.project_id,
        name=rule.name,
        rule_type=rule.rule_type,
        pattern=rule.pattern,
        replacement=rule.replacement,
        is_active=rule.is_active,
        priority=rule.priority,
        description=rule.description,
        created_at=rule.created_at,
        updated_at=rule.updated_at
    )


@app.get("/api/v1/projects/{project_id}/masking-rules", response_model=List[MaskingRuleResponse], tags=["Security"])
async def get_masking_rules(
    project_id: str,
    active_only: bool = True,
    api_key: str = Depends(verify_api_key)
):
    """获取项目脱敏规则"""
    if not SECURITY_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Security manager not available")
    
    manager = get_security_manager()
    rules = manager.get_masking_rules(project_id, active_only=active_only)
    
    return [
        MaskingRuleResponse(
            id=rule.id,
            project_id=rule.project_id,
            name=rule.name,
            rule_type=rule.rule_type,
            pattern=rule.pattern,
            replacement=rule.replacement,
            is_active=rule.is_active,
            priority=rule.priority,
            description=rule.description,
            created_at=rule.created_at,
            updated_at=rule.updated_at
        )
        for rule in rules
    ]


@app.put("/api/v1/masking-rules/{rule_id}", response_model=MaskingRuleResponse, tags=["Security"])
async def update_masking_rule(
    rule_id: str,
    name: Optional[str] = None,
    pattern: Optional[str] = None,
    replacement: Optional[str] = None,
    is_active: Optional[bool] = None,
    priority: Optional[int] = None,
    description: Optional[str] = None,
    api_key: str = Depends(verify_api_key)
):
    """更新脱敏规则"""
    if not SECURITY_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Security manager not available")
    
    manager = get_security_manager()
    
    kwargs = {}
    if name is not None:
        kwargs["name"] = name
    if pattern is not None:
        kwargs["pattern"] = pattern
    if replacement is not None:
        kwargs["replacement"] = replacement
    if is_active is not None:
        kwargs["is_active"] = is_active
    if priority is not None:
        kwargs["priority"] = priority
    if description is not None:
        kwargs["description"] = description
    
    rule = manager.update_masking_rule(rule_id, **kwargs)
    
    if not rule:
        raise HTTPException(status_code=404, detail="Masking rule not found")
    
    return MaskingRuleResponse(
        id=rule.id,
        project_id=rule.project_id,
        name=rule.name,
        rule_type=rule.rule_type,
        pattern=rule.pattern,
        replacement=rule.replacement,
        is_active=rule.is_active,
        priority=rule.priority,
        description=rule.description,
        created_at=rule.created_at,
        updated_at=rule.updated_at
    )


@app.delete("/api/v1/masking-rules/{rule_id}", tags=["Security"])
async def delete_masking_rule(
    rule_id: str,
    api_key: str = Depends(verify_api_key)
):
    """删除脱敏规则"""
    if not SECURITY_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Security manager not available")
    
    manager = get_security_manager()
    success = manager.delete_masking_rule(rule_id)
    
    if not success:
        raise HTTPException(status_code=404, detail="Masking rule not found")
    
    return {"success": True, "message": "Masking rule deleted"}


@app.post("/api/v1/projects/{project_id}/masking/apply", response_model=MaskingApplyResponse, tags=["Security"])
async def apply_masking(
    project_id: str,
    request: MaskingApplyRequest,
    api_key: str = Depends(verify_api_key)
):
    """应用脱敏规则到文本"""
    if not SECURITY_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Security manager not available")
    
    manager = get_security_manager()
    
    # 转换规则类型
    rule_types = None
    if request.rule_types:
        rule_types = [MaskingRuleType(rt) for rt in request.rule_types]
    
    masked_text = manager.apply_masking(request.text, project_id, rule_types)
    
    # 获取应用的规则
    rules = manager.get_masking_rules(project_id)
    applied_rules = [r.name for r in rules if r.is_active]
    
    return MaskingApplyResponse(
        original_text=request.text,
        masked_text=masked_text,
        applied_rules=applied_rules
    )


# ==================== Data Access Policy API ====================

@app.post("/api/v1/projects/{project_id}/access-policies", response_model=AccessPolicyResponse, tags=["Security"])
async def create_access_policy(
    project_id: str,
    request: AccessPolicyCreateRequest,
    api_key: str = Depends(verify_api_key)
):
    """创建数据访问策略"""
    if not SECURITY_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Security manager not available")
    
    manager = get_security_manager()
    
    policy = manager.create_access_policy(
        project_id=project_id,
        name=request.name,
        description=request.description,
        allowed_users=request.allowed_users,
        allowed_roles=request.allowed_roles,
        allowed_ips=request.allowed_ips,
        time_restrictions=request.time_restrictions,
        max_access_count=request.max_access_count,
        require_approval=request.require_approval
    )
    
    return AccessPolicyResponse(
        id=policy.id,
        project_id=policy.project_id,
        name=policy.name,
        description=policy.description,
        allowed_users=json.loads(policy.allowed_users) if policy.allowed_users else None,
        allowed_roles=json.loads(policy.allowed_roles) if policy.allowed_roles else None,
        allowed_ips=json.loads(policy.allowed_ips) if policy.allowed_ips else None,
        time_restrictions=json.loads(policy.time_restrictions) if policy.time_restrictions else None,
        max_access_count=policy.max_access_count,
        require_approval=policy.require_approval,
        is_active=policy.is_active,
        created_at=policy.created_at,
        updated_at=policy.updated_at
    )


@app.get("/api/v1/projects/{project_id}/access-policies", response_model=List[AccessPolicyResponse], tags=["Security"])
async def get_access_policies(
    project_id: str,
    active_only: bool = True,
    api_key: str = Depends(verify_api_key)
):
    """获取项目访问策略"""
    if not SECURITY_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Security manager not available")
    
    manager = get_security_manager()
    policies = manager.get_access_policies(project_id, active_only=active_only)
    
    return [
        AccessPolicyResponse(
            id=policy.id,
            project_id=policy.project_id,
            name=policy.name,
            description=policy.description,
            allowed_users=json.loads(policy.allowed_users) if policy.allowed_users else None,
            allowed_roles=json.loads(policy.allowed_roles) if policy.allowed_roles else None,
            allowed_ips=json.loads(policy.allowed_ips) if policy.allowed_ips else None,
            time_restrictions=json.loads(policy.time_restrictions) if policy.time_restrictions else None,
            max_access_count=policy.max_access_count,
            require_approval=policy.require_approval,
            is_active=policy.is_active,
            created_at=policy.created_at,
            updated_at=policy.updated_at
        )
        for policy in policies
    ]


@app.post("/api/v1/access-policies/{policy_id}/check", tags=["Security"])
async def check_access_permission(
    policy_id: str,
    user_id: str,
    user_ip: Optional[str] = None,
    api_key: str = Depends(verify_api_key)
):
    """检查访问权限"""
    if not SECURITY_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Security manager not available")
    
    manager = get_security_manager()
    allowed, reason = manager.check_access_permission(policy_id, user_id, user_ip)
    
    return {
        "allowed": allowed,
        "reason": reason if not allowed else None
    }


# ==================== Access Request API ====================

@app.post("/api/v1/access-requests", response_model=AccessRequestResponse, tags=["Security"])
async def create_access_request(
    request: AccessRequestCreateRequest,
    user_id: str,  # 实际应该从认证信息中获取
    api_key: str = Depends(verify_api_key)
):
    """创建访问请求"""
    if not SECURITY_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Security manager not available")
    
    manager = get_security_manager()
    
    access_request = manager.create_access_request(
        policy_id=request.policy_id,
        user_id=user_id,
        request_reason=request.request_reason,
        expires_hours=request.expires_hours
    )
    
    return AccessRequestResponse(
        id=access_request.id,
        policy_id=access_request.policy_id,
        user_id=access_request.user_id,
        request_reason=access_request.request_reason,
        status=access_request.status,
        approved_by=access_request.approved_by,
        approved_at=access_request.approved_at,
        expires_at=access_request.expires_at,
        created_at=access_request.created_at
    )


@app.post("/api/v1/access-requests/{request_id}/approve", response_model=AccessRequestResponse, tags=["Security"])
async def approve_access_request(
    request_id: str,
    approved_by: str,
    expires_hours: int = 24,
    api_key: str = Depends(verify_api_key)
):
    """批准访问请求"""
    if not SECURITY_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Security manager not available")
    
    manager = get_security_manager()
    access_request = manager.approve_access_request(request_id, approved_by, expires_hours)
    
    if not access_request:
        raise HTTPException(status_code=404, detail="Access request not found")
    
    return AccessRequestResponse(
        id=access_request.id,
        policy_id=access_request.policy_id,
        user_id=access_request.user_id,
        request_reason=access_request.request_reason,
        status=access_request.status,
        approved_by=access_request.approved_by,
        approved_at=access_request.approved_at,
        expires_at=access_request.expires_at,
        created_at=access_request.created_at
    )


@app.post("/api/v1/access-requests/{request_id}/reject", response_model=AccessRequestResponse, tags=["Security"])
async def reject_access_request(
    request_id: str,
    rejected_by: str,
    api_key: str = Depends(verify_api_key)
):
    """拒绝访问请求"""
    if not SECURITY_MANAGER_AVAILABLE:
        raise HTTPException(status_code=503, detail="Security manager not available")
    
    manager = get_security_manager()
    access_request = manager.reject_access_request(request_id, rejected_by)
    
    if not access_request:
        raise HTTPException(status_code=404, detail="Access request not found")
    
    return AccessRequestResponse(
        id=access_request.id,
        policy_id=access_request.policy_id,
        user_id=access_request.user_id,
        request_reason=access_request.request_reason,
        status=access_request.status,
        approved_by=access_request.approved_by,
        approved_at=access_request.approved_at,
        expires_at=access_request.expires_at,
        created_at=access_request.created_at
    )


# ==========================================
# Phase 7 Task 4: 协作与共享 API
# ==========================================

# ----- 请求模型 -----

class ShareLinkCreate(BaseModel):
    permission: str = "read_only"  # read_only, comment, edit, admin
    expires_in_days: Optional[int] = None
    max_uses: Optional[int] = None
    password: Optional[str] = None
    allow_download: bool = False
    allow_export: bool = False

class ShareLinkVerify(BaseModel):
    token: str
    password: Optional[str] = None

class CommentCreate(BaseModel):
    target_type: str  # entity, relation, transcript, project
    target_id: str
    parent_id: Optional[str] = None
    content: str
    mentions: Optional[List[str]] = None

class CommentUpdate(BaseModel):
    content: str

class CommentResolve(BaseModel):
    resolved: bool

class TeamMemberInvite(BaseModel):
    user_id: str
    user_name: str
    user_email: str
    role: str = "viewer"  # owner, admin, editor, viewer, commenter

class TeamMemberRoleUpdate(BaseModel):
    role: str


# ----- 项目分享 -----

@app.post("/api/v1/projects/{project_id}/shares")
async def create_share_link(project_id: str, request: ShareLinkCreate, created_by: str = "current_user"):
    """创建项目分享链接"""
    if not COLLABORATION_AVAILABLE:
        raise HTTPException(status_code=503, detail="Collaboration module not available")
    
    manager = get_collab_manager()
    share = manager.create_share_link(
        project_id=project_id,
        created_by=created_by,
        permission=request.permission,
        expires_in_days=request.expires_in_days,
        max_uses=request.max_uses,
        password=request.password,
        allow_download=request.allow_download,
        allow_export=request.allow_export
    )
    
    return {
        "id": share.id,
        "token": share.token,
        "permission": share.permission,
        "created_at": share.created_at,
        "expires_at": share.expires_at,
        "max_uses": share.max_uses,
        "share_url": f"/share/{share.token}"
    }

@app.get("/api/v1/projects/{project_id}/shares")
async def list_project_shares(project_id: str):
    """列出项目的所有分享链接"""
    if not COLLABORATION_AVAILABLE:
        raise HTTPException(status_code=503, detail="Collaboration module not available")
    
    manager = get_collab_manager()
    shares = manager.list_project_shares(project_id)
    
    return {
        "shares": [
            {
                "id": s.id,
                "token": s.token,
                "permission": s.permission,
                "created_at": s.created_at,
                "expires_at": s.expires_at,
                "use_count": s.use_count,
                "max_uses": s.max_uses,
                "is_active": s.is_active,
                "has_password": s.password_hash is not None,
                "allow_download": s.allow_download,
                "allow_export": s.allow_export
            }
            for s in shares
        ]
    }

@app.post("/api/v1/shares/verify")
async def verify_share_link(request: ShareLinkVerify):
    """验证分享链接"""
    if not COLLABORATION_AVAILABLE:
        raise HTTPException(status_code=503, detail="Collaboration module not available")
    
    manager = get_collab_manager()
    share = manager.validate_share_token(request.token, request.password)
    
    if not share:
        raise HTTPException(status_code=401, detail="Invalid or expired share link")
    
    # 增加使用次数
    manager.increment_share_usage(request.token)
    
    return {
        "valid": True,
        "project_id": share.project_id,
        "permission": share.permission,
        "allow_download": share.allow_download,
        "allow_export": share.allow_export
    }

@app.get("/api/v1/shares/{token}/access")
async def access_shared_project(token: str, password: Optional[str] = None):
    """通过分享链接访问项目"""
    if not COLLABORATION_AVAILABLE:
        raise HTTPException(status_code=503, detail="Collaboration module not available")
    
    manager = get_collab_manager()
    share = manager.validate_share_token(token, password)
    
    if not share:
        raise HTTPException(status_code=401, detail="Invalid or expired share link")
    
    # 增加使用次数
    manager.increment_share_usage(token)
    
    # 获取项目信息
    if not DB_AVAILABLE:
        raise HTTPException(status_code=503, detail="Database not available")
    
    db = get_db_manager()
    project = db.get_project(share.project_id)
    
    if not project:
        raise HTTPException(status_code=404, detail="Project not found")
    
    return {
        "project": {
            "id": project.id,
            "name": project.name,
            "description": project.description,
            "created_at": project.created_at
        },
        "permission": share.permission,
        "allow_download": share.allow_download,
        "allow_export": share.allow_export
    }

@app.delete("/api/v1/shares/{share_id}")
async def revoke_share_link(share_id: str, revoked_by: str = "current_user"):
    """撤销分享链接"""
    if not COLLABORATION_AVAILABLE:
        raise HTTPException(status_code=503, detail="Collaboration module not available")
    
    manager = get_collab_manager()
    success = manager.revoke_share_link(share_id, revoked_by)
    
    if not success:
        raise HTTPException(status_code=404, detail="Share link not found")
    
    return {"success": True, "message": "Share link revoked"}

# ----- 评论和批注 -----

@app.post("/api/v1/projects/{project_id}/comments")
async def add_comment(project_id: str, request: CommentCreate, author: str = "current_user", author_name: str = "User"):
    """添加评论"""
    if not COLLABORATION_AVAILABLE:
        raise HTTPException(status_code=503, detail="Collaboration module not available")
    
    manager = get_collab_manager()
    comment = manager.add_comment(
        project_id=project_id,
        target_type=request.target_type,
        target_id=request.target_id,
        author=author,
        author_name=author_name,
        content=request.content,
        parent_id=request.parent_id,
        mentions=request.mentions
    )
    
    return {
        "id": comment.id,
        "target_type": comment.target_type,
        "target_id": comment.target_id,
        "parent_id": comment.parent_id,
        "author": comment.author,
        "author_name": comment.author_name,
        "content": comment.content,
        "created_at": comment.created_at,
        "resolved": comment.resolved
    }

@app.get("/api/v1/{target_type}/{target_id}/comments")
async def get_comments(target_type: str, target_id: str, include_resolved: bool = True):
    """获取评论列表"""
    if not COLLABORATION_AVAILABLE:
        raise HTTPException(status_code=503, detail="Collaboration module not available")
    
    manager = get_collab_manager()
    comments = manager.get_comments(target_type, target_id, include_resolved)
    
    return {
        "count": len(comments),
        "comments": [
            {
                "id": c.id,
                "parent_id": c.parent_id,
                "author": c.author,
                "author_name": c.author_name,
                "content": c.content,
                "created_at": c.created_at,
                "updated_at": c.updated_at,
                "resolved": c.resolved,
                "resolved_by": c.resolved_by,
                "resolved_at": c.resolved_at
            }
            for c in comments
        ]
    }

@app.get("/api/v1/projects/{project_id}/comments")
async def get_project_comments(project_id: str, limit: int = 50, offset: int = 0):
    """获取项目下的所有评论"""
    if not COLLABORATION_AVAILABLE:
        raise HTTPException(status_code=503, detail="Collaboration module not available")
    
    manager = get_collab_manager()
    comments = manager.get_project_comments(project_id, limit, offset)
    
    return {
        "count": len(comments),
        "comments": [
            {
                "id": c.id,
                "target_type": c.target_type,
                "target_id": c.target_id,
                "parent_id": c.parent_id,
                "author": c.author,
                "author_name": c.author_name,
                "content": c.content,
                "created_at": c.created_at,
                "resolved": c.resolved
            }
            for c in comments
        ]
    }

@app.put("/api/v1/comments/{comment_id}")
async def update_comment(comment_id: str, request: CommentUpdate, updated_by: str = "current_user"):
    """更新评论"""
    if not COLLABORATION_AVAILABLE:
        raise HTTPException(status_code=503, detail="Collaboration module not available")
    
    manager = get_collab_manager()
    comment = manager.update_comment(comment_id, request.content, updated_by)
    
    if not comment:
        raise HTTPException(status_code=404, detail="Comment not found or not authorized")
    
    return {
        "id": comment.id,
        "content": comment.content,
        "updated_at": comment.updated_at
    }

@app.post("/api/v1/comments/{comment_id}/resolve")
async def resolve_comment(comment_id: str, resolved_by: str = "current_user"):
    """标记评论为已解决"""
    if not COLLABORATION_AVAILABLE:
        raise HTTPException(status_code=503, detail="Collaboration module not available")
    
    manager = get_collab_manager()
    success = manager.resolve_comment(comment_id, resolved_by)
    
    if not success:
        raise HTTPException(status_code=404, detail="Comment not found")
    
    return {"success": True, "message": "Comment resolved"}

@app.delete("/api/v1/comments/{comment_id}")
async def delete_comment(comment_id: str, deleted_by: str = "current_user"):
    """删除评论"""
    if not COLLABORATION_AVAILABLE:
        raise HTTPException(status_code=503, detail="Collaboration module not available")
    
    manager = get_collab_manager()
    success = manager.delete_comment(comment_id, deleted_by)
    
    if not success:
        raise HTTPException(status_code=404, detail="Comment not found or not authorized")
    
    return {"success": True, "message": "Comment deleted"}

# ----- 变更历史 -----

@app.get("/api/v1/projects/{project_id}/history")
async def get_change_history(
    project_id: str,
    entity_type: Optional[str] = None,
    entity_id: Optional[str] = None,
    limit: int = 50,
    offset: int = 0
):
    """获取变更历史"""
    if not COLLABORATION_AVAILABLE:
        raise HTTPException(status_code=503, detail="Collaboration module not available")
    
    manager = get_collab_manager()
    records = manager.get_change_history(project_id, entity_type, entity_id, limit, offset)
    
    return {
        "count": len(records),
        "history": [
            {
                "id": r.id,
                "change_type": r.change_type,
                "entity_type": r.entity_type,
                "entity_id": r.entity_id,
                "entity_name": r.entity_name,
                "changed_by": r.changed_by,
                "changed_by_name": r.changed_by_name,
                "changed_at": r.changed_at,
                "old_value": r.old_value,
                "new_value": r.new_value,
                "description": r.description,
                "reverted": r.reverted
            }
            for r in records
        ]
    }

@app.get("/api/v1/projects/{project_id}/history/stats")
async def get_change_history_stats(project_id: str):
    """获取变更统计"""
    if not COLLABORATION_AVAILABLE:
        raise HTTPException(status_code=503, detail="Collaboration module not available")
    
    manager = get_collab_manager()
    stats = manager.get_change_stats(project_id)
    
    return stats

@app.get("/api/v1/{entity_type}/{entity_id}/versions")
async def get_entity_versions(entity_type: str, entity_id: str):
    """获取实体版本历史"""
    if not COLLABORATION_AVAILABLE:
        raise HTTPException(status_code=503, detail="Collaboration module not available")
    
    manager = get_collab_manager()
    records = manager.get_entity_version_history(entity_type, entity_id)
    
    return {
        "count": len(records),
        "versions": [
            {
                "id": r.id,
                "change_type": r.change_type,
                "changed_by": r.changed_by,
                "changed_by_name": r.changed_by_name,
                "changed_at": r.changed_at,
                "old_value": r.old_value,
                "new_value": r.new_value,
                "description": r.description
            }
            for r in records
        ]
    }

@app.post("/api/v1/history/{record_id}/revert")
async def revert_change(record_id: str, reverted_by: str = "current_user"):
    """回滚变更"""
    if not COLLABORATION_AVAILABLE:
        raise HTTPException(status_code=503, detail="Collaboration module not available")
    
    manager = get_collab_manager()
    success = manager.revert_change(record_id, reverted_by)
    
    if not success:
        raise HTTPException(status_code=404, detail="Change record not found or already reverted")
    
    return {"success": True, "message": "Change reverted"}

# ----- 团队成员 -----

@app.post("/api/v1/projects/{project_id}/members")
async def invite_team_member(project_id: str, request: TeamMemberInvite, invited_by: str = "current_user"):
    """邀请团队成员"""
    if not COLLABORATION_AVAILABLE:
        raise HTTPException(status_code=503, detail="Collaboration module not available")
    
    manager = get_collab_manager()
    member = manager.add_team_member(
        project_id=project_id,
        user_id=request.user_id,
        user_name=request.user_name,
        user_email=request.user_email,
        role=request.role,
        invited_by=invited_by
    )
    
    return {
        "id": member.id,
        "user_id": member.user_id,
        "user_name": member.user_name,
        "user_email": member.user_email,
        "role": member.role,
        "joined_at": member.joined_at,
        "permissions": member.permissions
    }

@app.get("/api/v1/projects/{project_id}/members")
async def list_team_members(project_id: str):
    """列出团队成员"""
    if not COLLABORATION_AVAILABLE:
        raise HTTPException(status_code=503, detail="Collaboration module not available")
    
    manager = get_collab_manager()
    members = manager.get_team_members(project_id)
    
    return {
        "count": len(members),
        "members": [
            {
                "id": m.id,
                "user_id": m.user_id,
                "user_name": m.user_name,
                "user_email": m.user_email,
                "role": m.role,
                "joined_at": m.joined_at,
                "last_active_at": m.last_active_at,
                "permissions": m.permissions
            }
            for m in members
        ]
    }

@app.put("/api/v1/members/{member_id}/role")
async def update_member_role(member_id: str, request: TeamMemberRoleUpdate, updated_by: str = "current_user"):
    """更新成员角色"""
    if not COLLABORATION_AVAILABLE:
        raise HTTPException(status_code=503, detail="Collaboration module not available")
    
    manager = get_collab_manager()
    success = manager.update_member_role(member_id, request.role, updated_by)
    
    if not success:
        raise HTTPException(status_code=404, detail="Member not found")
    
    return {"success": True, "message": "Member role updated"}

@app.delete("/api/v1/members/{member_id}")
async def remove_team_member(member_id: str, removed_by: str = "current_user"):
    """移除团队成员"""
    if not COLLABORATION_AVAILABLE:
        raise HTTPException(status_code=503, detail="Collaboration module not available")
    
    manager = get_collab_manager()
    success = manager.remove_team_member(member_id, removed_by)
    
    if not success:
        raise HTTPException(status_code=404, detail="Member not found")
    
    return {"success": True, "message": "Member removed"}

@app.get("/api/v1/projects/{project_id}/permissions")
async def check_project_permissions(project_id: str, user_id: str = "current_user"):
    """检查用户权限"""
    if not COLLABORATION_AVAILABLE:
        raise HTTPException(status_code=503, detail="Collaboration module not available")
    
    manager = get_collab_manager()
    members = manager.get_team_members(project_id)
    
    user_member = None
    for m in members:
        if m.user_id == user_id:
            user_member = m
            break
    
    if not user_member:
        return {
            "has_access": False,
            "role": None,
            "permissions": []
        }
    
    return {
        "has_access": True,
        "role": user_member.role,
        "permissions": user_member.permissions
    }


# ==================== Phase 7 Task 6: Advanced Search & Discovery ====================

class FullTextSearchRequest(BaseModel):
    """全文搜索请求"""
    query: str
    content_types: Optional[List[str]] = None
    operator: str = "AND"  # AND, OR, NOT
    limit: int = 20


class SemanticSearchRequest(BaseModel):
    """语义搜索请求"""
    query: str
    content_types: Optional[List[str]] = None
    threshold: float = 0.7
    limit: int = 20


@app.post("/api/v1/search/fulltext", tags=["Search"])
async def fulltext_search(
    project_id: str,
    request: FullTextSearchRequest,
    _=Depends(verify_api_key)
):
    """全文搜索"""
    if not SEARCH_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Search manager not available")
    
    search_manager = get_search_manager()
    
    try:
        operator = SearchOperator(request.operator.upper())
    except ValueError:
        operator = SearchOperator.AND
    
    results = search_manager.fulltext_search.search(
        query=request.query,
        project_id=project_id,
        content_types=request.content_types,
        operator=operator,
        limit=request.limit
    )
    
    return {
        "query": request.query,
        "operator": request.operator,
        "total": len(results),
        "results": [{
            "id": r.id,
            "type": r.type,
            "title": r.title,
            "content": r.content,
            "highlights": r.highlights,
            "score": r.score
        } for r in results]
    }


@app.post("/api/v1/search/semantic", tags=["Search"])
async def semantic_search(
    project_id: str,
    request: SemanticSearchRequest,
    _=Depends(verify_api_key)
):
    """语义搜索"""
    if not SEARCH_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Search manager not available")
    
    search_manager = get_search_manager()
    
    results = search_manager.semantic_search.search(
        query=request.query,
        project_id=project_id,
        content_types=request.content_types,
        threshold=request.threshold,
        limit=request.limit
    )
    
    return {
        "query": request.query,
        "threshold": request.threshold,
        "total": len(results),
        "results": [{
            "id": r.id,
            "type": r.type,
            "text": r.text,
            "similarity": r.similarity
        } for r in results]
    }


@app.get("/api/v1/entities/{entity_id}/paths/{target_entity_id}", tags=["Search"])
async def find_entity_paths(
    entity_id: str,
    target_entity_id: str,
    max_depth: int = 5,
    find_all: bool = False,
    _=Depends(verify_api_key)
):
    """查找实体关系路径"""
    if not SEARCH_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Search manager not available")
    
    search_manager = get_search_manager()
    
    if find_all:
        paths = search_manager.path_discovery.find_all_paths(
            source_entity_id=entity_id,
            target_entity_id=target_entity_id,
            max_depth=max_depth
        )
    else:
        path = search_manager.path_discovery.find_shortest_path(
            source_entity_id=entity_id,
            target_entity_id=target_entity_id,
            max_depth=max_depth
        )
        paths = [path] if path else []
    
    return {
        "source_entity_id": entity_id,
        "target_entity_id": target_entity_id,
        "path_count": len(paths),
        "paths": [{
            "path_id": p.path_id,
            "path_length": p.path_length,
            "nodes": p.nodes,
            "edges": p.edges,
            "confidence": p.confidence
        } for p in paths]
    }


@app.get("/api/v1/entities/{entity_id}/network", tags=["Search"])
async def get_entity_network(
    entity_id: str,
    depth: int = 2,
    _=Depends(verify_api_key)
):
    """获取实体关系网络"""
    if not SEARCH_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Search manager not available")
    
    search_manager = get_search_manager()
    network = search_manager.path_discovery.get_entity_network(entity_id, depth)
    
    return network


@app.get("/api/v1/projects/{project_id}/knowledge-gaps", tags=["Search"])
async def detect_knowledge_gaps(
    project_id: str,
    _=Depends(verify_api_key)
):
    """检测知识缺口"""
    if not SEARCH_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Search manager not available")
    
    search_manager = get_search_manager()
    
    gaps = search_manager.gap_detector.detect_gaps(project_id)
    completeness = search_manager.gap_detector.get_completeness_score(project_id)
    
    return {
        "project_id": project_id,
        "completeness": completeness,
        "gap_count": len(gaps),
        "gaps": [{
            "gap_id": g.gap_id,
            "gap_type": g.gap_type,
            "entity_id": g.entity_id,
            "entity_name": g.entity_name,
            "description": g.description,
            "severity": g.severity,
            "suggestion": g.suggestion
        } for g in gaps]
    }


@app.post("/api/v1/projects/{project_id}/search/index", tags=["Search"])
async def index_project_for_search(
    project_id: str,
    _=Depends(verify_api_key)
):
    """为项目创建搜索索引"""
    if not SEARCH_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Search manager not available")
    
    search_manager = get_search_manager()
    success = search_manager.index_project_content(project_id)
    
    if success:
        return {"message": "Project indexed successfully", "project_id": project_id}
    else:
        raise HTTPException(status_code=500, detail="Failed to index project")


# ==================== Phase 7 Task 8: Performance & Scaling ====================

@app.get("/api/v1/cache/stats", tags=["Performance"])
async def get_cache_stats(
    _=Depends(verify_api_key)
):
    """获取缓存统计"""
    if not PERFORMANCE_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Performance manager not available")
    
    perf_manager = get_performance_manager()
    stats = perf_manager.cache.get_stats()
    
    return {
        "total_keys": stats.total_keys,
        "memory_usage_bytes": stats.memory_usage,
        "hit_count": stats.hit_count,
        "miss_count": stats.miss_count,
        "hit_rate": stats.hit_rate,
        "evicted_count": stats.evicted_count,
        "expired_count": stats.expired_count
    }


@app.post("/api/v1/cache/clear", tags=["Performance"])
async def clear_cache(
    pattern: Optional[str] = None,
    _=Depends(verify_api_key)
):
    """清除缓存"""
    if not PERFORMANCE_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Performance manager not available")
    
    perf_manager = get_performance_manager()
    success = perf_manager.cache.clear(pattern)
    
    if success:
        return {"message": "Cache cleared successfully", "pattern": pattern}
    else:
        raise HTTPException(status_code=500, detail="Failed to clear cache")


@app.get("/api/v1/performance/metrics", tags=["Performance"])
async def get_performance_metrics(
    metric_type: Optional[str] = None,
    endpoint: Optional[str] = None,
    hours: int = 24,
    limit: int = 1000,
    _=Depends(verify_api_key)
):
    """获取性能指标"""
    if not PERFORMANCE_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Performance manager not available")
    
    perf_manager = get_performance_manager()
    
    start_time = (datetime.now() - timedelta(hours=hours)).isoformat()
    
    metrics = perf_manager.monitor.get_metrics(
        metric_type=metric_type,
        endpoint=endpoint,
        start_time=start_time,
        limit=limit
    )
    
    return {
        "period_hours": hours,
        "total": len(metrics),
        "metrics": [{
            "id": m.id,
            "metric_type": m.metric_type,
            "endpoint": m.endpoint,
            "duration_ms": m.duration_ms,
            "status_code": m.status_code,
            "timestamp": m.timestamp
        } for m in metrics]
    }


@app.get("/api/v1/performance/summary", tags=["Performance"])
async def get_performance_summary(
    hours: int = 24,
    _=Depends(verify_api_key)
):
    """获取性能汇总统计"""
    if not PERFORMANCE_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Performance manager not available")
    
    perf_manager = get_performance_manager()
    summary = perf_manager.monitor.get_summary_stats(hours)
    
    return summary


@app.get("/api/v1/tasks/{task_id}/status", tags=["Performance"])
async def get_task_status(
    task_id: str,
    _=Depends(verify_api_key)
):
    """获取任务状态"""
    if not PERFORMANCE_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Performance manager not available")
    
    perf_manager = get_performance_manager()
    task = perf_manager.task_queue.get_task_status(task_id)
    
    if not task:
        raise HTTPException(status_code=404, detail="Task not found")
    
    return {
        "task_id": task.task_id,
        "task_type": task.task_type,
        "status": task.status,
        "project_id": task.project_id,
        "params": task.params,
        "result": task.result,
        "error": task.error,
        "created_at": task.created_at,
        "started_at": task.started_at,
        "completed_at": task.completed_at,
        "retry_count": task.retry_count,
        "priority": task.priority
    }


@app.get("/api/v1/tasks", tags=["Performance"])
async def list_tasks(
    project_id: Optional[str] = None,
    status: Optional[str] = None,
    limit: int = 50,
    _=Depends(verify_api_key)
):
    """列出任务"""
    if not PERFORMANCE_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Performance manager not available")
    
    perf_manager = get_performance_manager()
    tasks = perf_manager.task_queue.list_tasks(project_id, status, limit)
    
    return {
        "total": len(tasks),
        "tasks": [{
            "task_id": t.task_id,
            "task_type": t.task_type,
            "status": t.status,
            "project_id": t.project_id,
            "created_at": t.created_at,
            "retry_count": t.retry_count,
            "priority": t.priority
        } for t in tasks]
    }


@app.post("/api/v1/tasks/{task_id}/cancel", tags=["Performance"])
async def cancel_task(
    task_id: str,
    _=Depends(verify_api_key)
):
    """取消任务"""
    if not PERFORMANCE_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Performance manager not available")
    
    perf_manager = get_performance_manager()
    success = perf_manager.task_queue.cancel_task(task_id)
    
    if success:
        return {"message": "Task cancelled successfully", "task_id": task_id}
    else:
        raise HTTPException(status_code=400, detail="Failed to cancel task or task already completed")


@app.get("/api/v1/shards", tags=["Performance"])
async def list_shards(
    _=Depends(verify_api_key)
):
    """列出数据库分片"""
    if not PERFORMANCE_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Performance manager not available")
    
    perf_manager = get_performance_manager()
    shards = perf_manager.sharding.get_shard_stats()
    
    return {
        "shard_count": len(shards),
        "shards": [{
            "shard_id": s.shard_id,
            "entity_count": s.entity_count,
            "db_path": s.db_path,
            "created_at": s.created_at
        } for s in shards]
    }


# ============================================
# Phase 8: Multi-Tenant SaaS APIs
# ============================================

class CreateTenantRequest(BaseModel):
    name: str
    description: Optional[str] = None
    tier: str = "free"

class UpdateTenantRequest(BaseModel):
    name: Optional[str] = None
    description: Optional[str] = None
    tier: Optional[str] = None
    status: Optional[str] = None

class AddDomainRequest(BaseModel):
    domain: str
    is_primary: bool = False

class UpdateBrandingRequest(BaseModel):
    logo_url: Optional[str] = None
    favicon_url: Optional[str] = None
    primary_color: Optional[str] = None
    secondary_color: Optional[str] = None
    custom_css: Optional[str] = None
    custom_js: Optional[str] = None
    login_page_bg: Optional[str] = None

class InviteMemberRequest(BaseModel):
    email: str
    role: str = "member"

class UpdateMemberRequest(BaseModel):
    role: Optional[str] = None


# Tenant Management APIs
@app.post("/api/v1/tenants", tags=["Tenants"])
async def create_tenant(
    request: CreateTenantRequest,
    user_id: str = Header(..., description="当前用户ID"),
    _=Depends(verify_api_key)
):
    """创建新租户"""
    if not TENANT_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Tenant manager not available")
    
    manager = get_tenant_manager()
    try:
        tenant = manager.create_tenant(
            name=request.name,
            owner_id=user_id,
            tier=request.tier,
            description=request.description
        )
        return {
            "id": tenant.id,
            "name": tenant.name,
            "slug": tenant.slug,
            "tier": tenant.tier,
            "status": tenant.status,
            "created_at": tenant.created_at.isoformat()
        }
    except Exception as e:
        raise HTTPException(status_code=400, detail=str(e))


@app.get("/api/v1/tenants", tags=["Tenants"])
async def list_my_tenants(
    user_id: str = Header(..., description="当前用户ID"),
    _=Depends(verify_api_key)
):
    """获取当前用户的所有租户"""
    if not TENANT_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Tenant manager not available")
    
    manager = get_tenant_manager()
    tenants = manager.get_user_tenants(user_id)
    return {"tenants": tenants}


@app.get("/api/v1/tenants/{tenant_id}", tags=["Tenants"])
async def get_tenant(
    tenant_id: str,
    _=Depends(verify_api_key)
):
    """获取租户详情"""
    if not TENANT_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Tenant manager not available")
    
    manager = get_tenant_manager()
    tenant = manager.get_tenant(tenant_id)
    
    if not tenant:
        raise HTTPException(status_code=404, detail="Tenant not found")
    
    return {
        "id": tenant.id,
        "name": tenant.name,
        "slug": tenant.slug,
        "description": tenant.description,
        "tier": tenant.tier,
        "status": tenant.status,
        "owner_id": tenant.owner_id,
        "created_at": tenant.created_at.isoformat(),
        "settings": tenant.settings,
        "resource_limits": tenant.resource_limits
    }


@app.put("/api/v1/tenants/{tenant_id}", tags=["Tenants"])
async def update_tenant(
    tenant_id: str,
    request: UpdateTenantRequest,
    _=Depends(verify_api_key)
):
    """更新租户信息"""
    if not TENANT_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Tenant manager not available")
    
    manager = get_tenant_manager()
    tenant = manager.update_tenant(
        tenant_id=tenant_id,
        name=request.name,
        description=request.description,
        tier=request.tier,
        status=request.status
    )
    
    if not tenant:
        raise HTTPException(status_code=404, detail="Tenant not found")
    
    return {
        "id": tenant.id,
        "name": tenant.name,
        "slug": tenant.slug,
        "tier": tenant.tier,
        "status": tenant.status,
        "updated_at": tenant.updated_at.isoformat()
    }


@app.delete("/api/v1/tenants/{tenant_id}", tags=["Tenants"])
async def delete_tenant(
    tenant_id: str,
    _=Depends(verify_api_key)
):
    """删除租户"""
    if not TENANT_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Tenant manager not available")
    
    manager = get_tenant_manager()
    success = manager.delete_tenant(tenant_id)
    
    if not success:
        raise HTTPException(status_code=404, detail="Tenant not found")
    
    return {"message": "Tenant deleted successfully"}


# Domain Management APIs
@app.post("/api/v1/tenants/{tenant_id}/domains", tags=["Tenants"])
async def add_domain(
    tenant_id: str,
    request: AddDomainRequest,
    _=Depends(verify_api_key)
):
    """为租户添加自定义域名"""
    if not TENANT_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Tenant manager not available")
    
    manager = get_tenant_manager()
    try:
        domain = manager.add_domain(
            tenant_id=tenant_id,
            domain=request.domain,
            is_primary=request.is_primary
        )
        
        # 获取验证指导
        instructions = manager.get_domain_verification_instructions(domain.id)
        
        return {
            "id": domain.id,
            "domain": domain.domain,
            "status": domain.status,
            "is_primary": domain.is_primary,
            "verification_token": domain.verification_token,
            "verification_instructions": instructions,
            "created_at": domain.created_at.isoformat()
        }
    except Exception as e:
        raise HTTPException(status_code=400, detail=str(e))


@app.get("/api/v1/tenants/{tenant_id}/domains", tags=["Tenants"])
async def list_domains(
    tenant_id: str,
    _=Depends(verify_api_key)
):
    """列出租户的所有域名"""
    if not TENANT_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Tenant manager not available")
    
    manager = get_tenant_manager()
    domains = manager.list_domains(tenant_id)
    
    return {
        "domains": [{
            "id": d.id,
            "domain": d.domain,
            "status": d.status,
            "is_primary": d.is_primary,
            "ssl_enabled": d.ssl_enabled,
            "verified_at": d.verified_at.isoformat() if d.verified_at else None,
            "created_at": d.created_at.isoformat()
        } for d in domains]
    }


@app.post("/api/v1/tenants/{tenant_id}/domains/{domain_id}/verify", tags=["Tenants"])
async def verify_domain(
    tenant_id: str,
    domain_id: str,
    _=Depends(verify_api_key)
):
    """验证域名所有权"""
    if not TENANT_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Tenant manager not available")
    
    manager = get_tenant_manager()
    success = manager.verify_domain(tenant_id, domain_id)
    
    return {
        "success": success,
        "message": "Domain verified successfully" if success else "Domain verification failed"
    }


@app.delete("/api/v1/tenants/{tenant_id}/domains/{domain_id}", tags=["Tenants"])
async def remove_domain(
    tenant_id: str,
    domain_id: str,
    _=Depends(verify_api_key)
):
    """移除域名绑定"""
    if not TENANT_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Tenant manager not available")
    
    manager = get_tenant_manager()
    success = manager.remove_domain(tenant_id, domain_id)
    
    if not success:
        raise HTTPException(status_code=404, detail="Domain not found")
    
    return {"message": "Domain removed successfully"}


# Branding APIs
@app.get("/api/v1/tenants/{tenant_id}/branding", tags=["Tenants"])
async def get_branding(
    tenant_id: str,
    _=Depends(verify_api_key)
):
    """获取租户品牌配置"""
    if not TENANT_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Tenant manager not available")
    
    manager = get_tenant_manager()
    branding = manager.get_branding(tenant_id)
    
    if not branding:
        return {
            "tenant_id": tenant_id,
            "logo_url": None,
            "favicon_url": None,
            "primary_color": None,
            "secondary_color": None,
            "custom_css": None
        }
    
    return {
        "tenant_id": branding.tenant_id,
        "logo_url": branding.logo_url,
        "favicon_url": branding.favicon_url,
        "primary_color": branding.primary_color,
        "secondary_color": branding.secondary_color,
        "custom_css": branding.custom_css,
        "custom_js": branding.custom_js,
        "login_page_bg": branding.login_page_bg
    }


@app.put("/api/v1/tenants/{tenant_id}/branding", tags=["Tenants"])
async def update_branding(
    tenant_id: str,
    request: UpdateBrandingRequest,
    _=Depends(verify_api_key)
):
    """更新租户品牌配置"""
    if not TENANT_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Tenant manager not available")
    
    manager = get_tenant_manager()
    branding = manager.update_branding(
        tenant_id=tenant_id,
        logo_url=request.logo_url,
        favicon_url=request.favicon_url,
        primary_color=request.primary_color,
        secondary_color=request.secondary_color,
        custom_css=request.custom_css,
        custom_js=request.custom_js,
        login_page_bg=request.login_page_bg
    )
    
    return {
        "tenant_id": branding.tenant_id,
        "logo_url": branding.logo_url,
        "favicon_url": branding.favicon_url,
        "primary_color": branding.primary_color,
        "secondary_color": branding.secondary_color,
        "updated_at": branding.updated_at.isoformat()
    }


@app.get("/api/v1/tenants/{tenant_id}/branding.css", tags=["Tenants"])
async def get_branding_css(tenant_id: str):
    """获取租户品牌 CSS（公开端点，无需认证）"""
    if not TENANT_MANAGER_AVAILABLE:
        return ""
    
    manager = get_tenant_manager()
    css = manager.get_branding_css(tenant_id)
    
    from fastapi.responses import PlainTextResponse
    return PlainTextResponse(content=css, media_type="text/css")


# Member Management APIs
@app.post("/api/v1/tenants/{tenant_id}/members", tags=["Tenants"])
async def invite_member(
    tenant_id: str,
    request: InviteMemberRequest,
    user_id: str = Header(..., description="邀请者用户ID"),
    _=Depends(verify_api_key)
):
    """邀请成员加入租户"""
    if not TENANT_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Tenant manager not available")
    
    manager = get_tenant_manager()
    try:
        member = manager.invite_member(
            tenant_id=tenant_id,
            email=request.email,
            role=request.role,
            invited_by=user_id
        )
        
        return {
            "id": member.id,
            "email": member.email,
            "role": member.role,
            "status": member.status,
            "invited_at": member.invited_at.isoformat()
        }
    except Exception as e:
        raise HTTPException(status_code=400, detail=str(e))


@app.get("/api/v1/tenants/{tenant_id}/members", tags=["Tenants"])
async def list_members(
    tenant_id: str,
    status: Optional[str] = None,
    _=Depends(verify_api_key)
):
    """列出租户成员"""
    if not TENANT_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Tenant manager not available")
    
    manager = get_tenant_manager()
    members = manager.list_members(tenant_id, status)
    
    return {
        "members": [{
            "id": m.id,
            "user_id": m.user_id,
            "email": m.email,
            "role": m.role,
            "status": m.status,
            "permissions": m.permissions,
            "invited_at": m.invited_at.isoformat(),
            "joined_at": m.joined_at.isoformat() if m.joined_at else None,
            "last_active_at": m.last_active_at.isoformat() if m.last_active_at else None
        } for m in members]
    }


@app.put("/api/v1/tenants/{tenant_id}/members/{member_id}", tags=["Tenants"])
async def update_member(
    tenant_id: str,
    member_id: str,
    request: UpdateMemberRequest,
    _=Depends(verify_api_key)
):
    """更新成员角色"""
    if not TENANT_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Tenant manager not available")
    
    manager = get_tenant_manager()
    success = manager.update_member_role(tenant_id, member_id, request.role)
    
    if not success:
        raise HTTPException(status_code=404, detail="Member not found")
    
    return {"message": "Member updated successfully"}


@app.delete("/api/v1/tenants/{tenant_id}/members/{member_id}", tags=["Tenants"])
async def remove_member(
    tenant_id: str,
    member_id: str,
    _=Depends(verify_api_key)
):
    """移除成员"""
    if not TENANT_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Tenant manager not available")
    
    manager = get_tenant_manager()
    success = manager.remove_member(tenant_id, member_id)
    
    if not success:
        raise HTTPException(status_code=404, detail="Member not found")
    
    return {"message": "Member removed successfully"}


# Usage & Limits APIs
@app.get("/api/v1/tenants/{tenant_id}/usage", tags=["Tenants"])
async def get_tenant_usage(
    tenant_id: str,
    _=Depends(verify_api_key)
):
    """获取租户资源使用统计"""
    if not TENANT_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Tenant manager not available")
    
    manager = get_tenant_manager()
    stats = manager.get_usage_stats(tenant_id)
    
    return stats


@app.get("/api/v1/tenants/{tenant_id}/limits/{resource_type}", tags=["Tenants"])
async def check_resource_limit(
    tenant_id: str,
    resource_type: str,
    _=Depends(verify_api_key)
):
    """检查特定资源是否超限"""
    if not TENANT_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Tenant manager not available")
    
    manager = get_tenant_manager()
    allowed, current, limit = manager.check_resource_limit(tenant_id, resource_type)
    
    return {
        "resource_type": resource_type,
        "allowed": allowed,
        "current": current,
        "limit": limit,
        "usage_percentage": round(current / limit * 100, 2) if limit > 0 else 0
    }


# Public tenant resolution API (for custom domains)
@app.get("/api/v1/resolve-tenant", tags=["Tenants"])
async def resolve_tenant_by_domain(domain: str):
    """通过域名解析租户（用于自定义域名路由）"""
    if not TENANT_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Tenant manager not available")
    
    manager = get_tenant_manager()
    tenant = manager.get_tenant_by_domain(domain)
    
    if not tenant:
        raise HTTPException(status_code=404, detail="Tenant not found for this domain")
    
    branding = manager.get_branding(tenant.id)
    
    return {
        "tenant_id": tenant.id,
        "name": tenant.name,
        "slug": tenant.slug,
        "tier": tenant.tier,
        "branding": {
            "logo_url": branding.logo_url if branding else None,
            "primary_color": branding.primary_color if branding else None,
            "favicon_url": branding.favicon_url if branding else None
        }
    }


@app.get("/api/v1/health", tags=["System"])
async def health_check():
    """健康检查"""
    health = {
        "status": "healthy",
        "timestamp": datetime.now().isoformat(),
        "components": {}
    }
    
    # 数据库检查
    if DB_AVAILABLE:
        try:
            db = get_db_manager()
            conn = db.get_conn()
            conn.execute("SELECT 1")
            conn.close()
            health["components"]["database"] = "ok"
        except Exception as e:
            health["components"]["database"] = f"error: {str(e)}"
            health["status"] = "degraded"
    else:
        health["components"]["database"] = "unavailable"
    
    # 性能管理器检查
    if PERFORMANCE_MANAGER_AVAILABLE:
        try:
            perf_manager = get_performance_manager()
            perf_health = perf_manager.health_check()
            health["components"].update(perf_health)
            if perf_health.get("overall") != "healthy":
                health["status"] = "degraded"
        except Exception as e:
            health["components"]["performance"] = f"error: {str(e)}"
            health["status"] = "degraded"
    
    # 搜索管理器检查
    if SEARCH_MANAGER_AVAILABLE:
        health["components"]["search"] = "available"
    else:
        health["components"]["search"] = "unavailable"
    
    # 租户管理器检查
    if TENANT_MANAGER_AVAILABLE:
        health["components"]["tenant"] = "available"
    else:
        health["components"]["tenant"] = "unavailable"
    
    return health


# ==================== Phase 8: Multi-Tenant SaaS API ====================

# Pydantic Models for Tenant API
class TenantCreate(BaseModel):
    name: str = Field(..., description="租户名称")
    slug: str = Field(..., description="URL 友好的唯一标识（小写字母、数字、连字符）")
    description: str = Field(default="", description="租户描述")
    plan: str = Field(default="free", description="套餐类型: free, starter, professional, enterprise")
    billing_email: str = Field(default="", description="计费邮箱")


class TenantUpdate(BaseModel):
    name: Optional[str] = None
    description: Optional[str] = None
    status: Optional[str] = None
    plan: Optional[str] = None
    billing_email: Optional[str] = None
    max_projects: Optional[int] = None
    max_members: Optional[int] = None


class TenantResponse(BaseModel):
    id: str
    name: str
    slug: str
    description: str
    status: str
    plan: str
    max_projects: int
    max_members: int
    max_storage_gb: float
    max_api_calls_per_day: int
    billing_email: str
    created_at: str
    updated_at: str


class TenantDomainCreate(BaseModel):
    domain: str = Field(..., description="自定义域名")


class TenantDomainResponse(BaseModel):
    id: str
    tenant_id: str
    domain: str
    status: str
    verification_record: str
    verification_expires_at: Optional[str]
    ssl_enabled: bool
    created_at: str
    verified_at: Optional[str]


class TenantBrandingUpdate(BaseModel):
    logo_url: Optional[str] = None
    logo_dark_url: Optional[str] = None
    favicon_url: Optional[str] = None
    primary_color: Optional[str] = None
    secondary_color: Optional[str] = None
    accent_color: Optional[str] = None
    background_color: Optional[str] = None
    text_color: Optional[str] = None
    dark_primary_color: Optional[str] = None
    dark_background_color: Optional[str] = None
    dark_text_color: Optional[str] = None
    font_family: Optional[str] = None
    custom_css: Optional[str] = None
    custom_js: Optional[str] = None
    app_name: Optional[str] = None
    login_page_title: Optional[str] = None
    login_page_description: Optional[str] = None
    footer_text: Optional[str] = None


class TenantMemberInvite(BaseModel):
    email: str = Field(..., description="被邀请者邮箱")
    name: str = Field(default="", description="被邀请者姓名")
    role: str = Field(default="viewer", description="角色: owner, admin, editor, viewer, guest")


class TenantMemberResponse(BaseModel):
    id: str
    tenant_id: str
    user_id: str
    email: str
    name: str
    role: str
    status: str
    invited_by: Optional[str]
    invited_at: Optional[str]
    joined_at: Optional[str]
    last_active_at: Optional[str]
    created_at: str


class TenantRoleCreate(BaseModel):
    name: str = Field(..., description="角色名称")
    description: str = Field(default="", description="角色描述")
    permissions: List[str] = Field(default_factory=list, description="权限列表")


class TenantRoleResponse(BaseModel):
    id: str
    tenant_id: str
    name: str
    description: str
    permissions: List[str]
    is_system: bool
    created_at: str


class TenantStatsResponse(BaseModel):
    tenant_id: str
    project_count: int
    member_count: int
    storage_used_gb: float
    api_calls_today: int
    api_calls_month: int


# Tenant API Endpoints
@app.post("/api/v1/tenants", response_model=TenantResponse, tags=["Tenants"])
async def create_tenant_endpoint(tenant: TenantCreate, request: Request, _=Depends(verify_api_key)):
    """创建新租户"""
    if not TENANT_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Tenant manager not available")
    
    tenant_manager = get_tenant_manager()
    
    # 获取当前用户ID（从请求状态或API Key）
    user_id = ""
    if hasattr(request.state, 'api_key') and request.state.api_key:
        user_id = request.state.api_key.created_by or ""
    
    try:
        new_tenant = tenant_manager.create_tenant(
            name=tenant.name,
            slug=tenant.slug,
            created_by=user_id,
            description=tenant.description,
            plan=TenantPlan(tenant.plan),
            billing_email=tenant.billing_email
        )
        return new_tenant.to_dict()
    except ValueError as e:
        raise HTTPException(status_code=400, detail=str(e))


@app.get("/api/v1/tenants", response_model=List[TenantResponse], tags=["Tenants"])
async def list_tenants_endpoint(
    status: Optional[str] = None,
    plan: Optional[str] = None,
    limit: int = 100,
    offset: int = 0,
    _=Depends(verify_api_key)
):
    """列出租户"""
    if not TENANT_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Tenant manager not available")
    
    tenant_manager = get_tenant_manager()
    
    status_enum = TenantStatus(status) if status else None
    plan_enum = TenantPlan(plan) if plan else None
    
    tenants = tenant_manager.list_tenants(
        status=status_enum,
        plan=plan_enum,
        limit=limit,
        offset=offset
    )
    return [t.to_dict() for t in tenants]


@app.get("/api/v1/tenants/{tenant_id}", response_model=TenantResponse, tags=["Tenants"])
async def get_tenant_endpoint(tenant_id: str, _=Depends(verify_api_key)):
    """获取租户详情"""
    if not TENANT_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Tenant manager not available")
    
    tenant_manager = get_tenant_manager()
    tenant = tenant_manager.get_tenant(tenant_id)
    
    if not tenant:
        raise HTTPException(status_code=404, detail="Tenant not found")
    
    return tenant.to_dict()


@app.get("/api/v1/tenants/slug/{slug}", response_model=TenantResponse, tags=["Tenants"])
async def get_tenant_by_slug_endpoint(slug: str, _=Depends(verify_api_key)):
    """根据 slug 获取租户"""
    if not TENANT_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Tenant manager not available")
    
    tenant_manager = get_tenant_manager()
    tenant = tenant_manager.get_tenant_by_slug(slug)
    
    if not tenant:
        raise HTTPException(status_code=404, detail="Tenant not found")
    
    return tenant.to_dict()


@app.put("/api/v1/tenants/{tenant_id}", response_model=TenantResponse, tags=["Tenants"])
async def update_tenant_endpoint(tenant_id: str, update: TenantUpdate, _=Depends(verify_api_key)):
    """更新租户信息"""
    if not TENANT_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Tenant manager not available")
    
    tenant_manager = get_tenant_manager()
    
    # 过滤掉 None 值
    update_data = {k: v for k, v in update.dict().items() if v is not None}
    
    try:
        updated = tenant_manager.update_tenant(tenant_id, **update_data)
        if not updated:
            raise HTTPException(status_code=404, detail="Tenant not found")
        return updated.to_dict()
    except ValueError as e:
        raise HTTPException(status_code=400, detail=str(e))


@app.delete("/api/v1/tenants/{tenant_id}", tags=["Tenants"])
async def delete_tenant_endpoint(tenant_id: str, _=Depends(verify_api_key)):
    """删除租户（标记为过期）"""
    if not TENANT_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Tenant manager not available")
    
    tenant_manager = get_tenant_manager()
    success = tenant_manager.delete_tenant(tenant_id)
    
    if not success:
        raise HTTPException(status_code=404, detail="Tenant not found")
    
    return {"success": True, "message": f"Tenant {tenant_id} deleted"}


# Tenant Domain API
@app.post("/api/v1/tenants/{tenant_id}/domains", response_model=TenantDomainResponse, tags=["Tenants"])
async def add_tenant_domain_endpoint(tenant_id: str, domain: TenantDomainCreate, _=Depends(verify_api_key)):
    """为租户添加自定义域名"""
    if not TENANT_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Tenant manager not available")
    
    tenant_manager = get_tenant_manager()
    
    # 验证租户存在
    tenant = tenant_manager.get_tenant(tenant_id)
    if not tenant:
        raise HTTPException(status_code=404, detail="Tenant not found")
    
    try:
        new_domain = tenant_manager.add_domain(tenant_id, domain.domain)
        return new_domain.to_dict()
    except ValueError as e:
        raise HTTPException(status_code=400, detail=str(e))


@app.get("/api/v1/tenants/{tenant_id}/domains", response_model=List[TenantDomainResponse], tags=["Tenants"])
async def list_tenant_domains_endpoint(tenant_id: str, _=Depends(verify_api_key)):
    """获取租户的所有域名"""
    if not TENANT_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Tenant manager not available")
    
    tenant_manager = get_tenant_manager()
    domains = tenant_manager.get_tenant_domains(tenant_id)
    return [d.to_dict() for d in domains]


@app.post("/api/v1/tenants/{tenant_id}/domains/{domain_id}/verify", tags=["Tenants"])
async def verify_tenant_domain_endpoint(tenant_id: str, domain_id: str, _=Depends(verify_api_key)):
    """验证域名 DNS 记录"""
    if not TENANT_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Tenant manager not available")
    
    tenant_manager = get_tenant_manager()
    success = tenant_manager.verify_domain(tenant_id, domain_id)
    
    if not success:
        raise HTTPException(status_code=400, detail="Domain verification failed")
    
    return {"success": True, "message": "Domain verified successfully"}


@app.post("/api/v1/tenants/{tenant_id}/domains/{domain_id}/activate", tags=["Tenants"])
async def activate_tenant_domain_endpoint(tenant_id: str, domain_id: str, _=Depends(verify_api_key)):
    """激活已验证的域名"""
    if not TENANT_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Tenant manager not available")
    
    tenant_manager = get_tenant_manager()
    success = tenant_manager.activate_domain(tenant_id, domain_id)
    
    if not success:
        raise HTTPException(status_code=400, detail="Domain activation failed")
    
    return {"success": True, "message": "Domain activated successfully"}


@app.delete("/api/v1/tenants/{tenant_id}/domains/{domain_id}", tags=["Tenants"])
async def remove_tenant_domain_endpoint(tenant_id: str, domain_id: str, _=Depends(verify_api_key)):
    """移除域名绑定"""
    if not TENANT_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Tenant manager not available")
    
    tenant_manager = get_tenant_manager()
    success = tenant_manager.remove_domain(tenant_id, domain_id)
    
    if not success:
        raise HTTPException(status_code=404, detail="Domain not found")
    
    return {"success": True, "message": "Domain removed successfully"}


# Tenant Branding API
@app.get("/api/v1/tenants/{tenant_id}/branding", tags=["Tenants"])
async def get_tenant_branding_endpoint(tenant_id: str, _=Depends(verify_api_key)):
    """获取租户品牌配置"""
    if not TENANT_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Tenant manager not available")
    
    tenant_manager = get_tenant_manager()
    branding = tenant_manager.get_branding(tenant_id)
    
    if not branding:
        raise HTTPException(status_code=404, detail="Branding not found")
    
    return branding.to_dict()


@app.put("/api/v1/tenants/{tenant_id}/branding", tags=["Tenants"])
async def update_tenant_branding_endpoint(
    tenant_id: str,
    branding: TenantBrandingUpdate,
    _=Depends(verify_api_key)
):
    """更新租户品牌配置"""
    if not TENANT_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Tenant manager not available")
    
    tenant_manager = get_tenant_manager()
    
    # 过滤掉 None 值
    update_data = {k: v for k, v in branding.dict().items() if v is not None}
    
    updated = tenant_manager.update_branding(tenant_id, **update_data)
    if not updated:
        raise HTTPException(status_code=404, detail="Branding not found")
    
    return updated.to_dict()


@app.get("/api/v1/tenants/{tenant_id}/branding/theme.css", tags=["Tenants"])
async def get_tenant_theme_css_endpoint(tenant_id: str):
    """获取租户主题 CSS（公开访问）"""
    if not TENANT_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Tenant manager not available")
    
    tenant_manager = get_tenant_manager()
    branding = tenant_manager.get_branding(tenant_id)
    
    if not branding:
        raise HTTPException(status_code=404, detail="Branding not found")
    
    from fastapi.responses import PlainTextResponse
    return PlainTextResponse(content=branding.get_theme_css(), media_type="text/css")


# Tenant Member API
@app.post("/api/v1/tenants/{tenant_id}/members/invite", response_model=TenantMemberResponse, tags=["Tenants"])
async def invite_tenant_member_endpoint(
    tenant_id: str,
    invite: TenantMemberInvite,
    request: Request,
    _=Depends(verify_api_key)
):
    """邀请成员加入租户"""
    if not TENANT_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Tenant manager not available")
    
    tenant_manager = get_tenant_manager()
    
    # 获取当前用户ID
    invited_by = ""
    if hasattr(request.state, 'api_key') and request.state.api_key:
        invited_by = request.state.api_key.created_by or ""
    
    try:
        member = tenant_manager.invite_member(
            tenant_id=tenant_id,
            email=invite.email,
            role=MemberRole(invite.role),
            invited_by=invited_by,
            name=invite.name
        )
        return member.to_dict()
    except ValueError as e:
        raise HTTPException(status_code=400, detail=str(e))


@app.post("/api/v1/tenants/members/accept-invitation", tags=["Tenants"])
async def accept_invitation_endpoint(token: str, user_id: str):
    """接受邀请加入租户"""
    if not TENANT_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Tenant manager not available")
    
    tenant_manager = get_tenant_manager()
    member = tenant_manager.accept_invitation(token, user_id)
    
    if not member:
        raise HTTPException(status_code=400, detail="Invalid or expired invitation token")
    
    return member.to_dict()


@app.get("/api/v1/tenants/{tenant_id}/members", response_model=List[TenantMemberResponse], tags=["Tenants"])
async def list_tenant_members_endpoint(
    tenant_id: str,
    status: Optional[str] = None,
    role: Optional[str] = None,
    _=Depends(verify_api_key)
):
    """列出租户成员"""
    if not TENANT_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Tenant manager not available")
    
    tenant_manager = get_tenant_manager()
    
    status_enum = MemberStatus(status) if status else None
    role_enum = MemberRole(role) if role else None
    
    members = tenant_manager.list_members(tenant_id, status=status_enum, role=role_enum)
    return [m.to_dict() for m in members]


@app.put("/api/v1/tenants/{tenant_id}/members/{member_id}/role", tags=["Tenants"])
async def update_member_role_endpoint(
    tenant_id: str,
    member_id: str,
    role: str,
    request: Request,
    _=Depends(verify_api_key)
):
    """更新成员角色"""
    if not TENANT_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Tenant manager not available")
    
    tenant_manager = get_tenant_manager()
    
    # 获取当前用户ID
    updated_by = ""
    if hasattr(request.state, 'api_key') and request.state.api_key:
        updated_by = request.state.api_key.created_by or ""
    
    try:
        updated = tenant_manager.update_member_role(
            tenant_id=tenant_id,
            member_id=member_id,
            new_role=MemberRole(role),
            updated_by=updated_by
        )
        if not updated:
            raise HTTPException(status_code=404, detail="Member not found")
        return updated.to_dict()
    except ValueError as e:
        raise HTTPException(status_code=403, detail=str(e))


@app.delete("/api/v1/tenants/{tenant_id}/members/{member_id}", tags=["Tenants"])
async def remove_tenant_member_endpoint(
    tenant_id: str,
    member_id: str,
    request: Request,
    _=Depends(verify_api_key)
):
    """移除租户成员"""
    if not TENANT_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Tenant manager not available")
    
    tenant_manager = get_tenant_manager()
    
    # 获取当前用户ID
    removed_by = ""
    if hasattr(request.state, 'api_key') and request.state.api_key:
        removed_by = request.state.api_key.created_by or ""
    
    try:
        success = tenant_manager.remove_member(tenant_id, member_id, removed_by)
        if not success:
            raise HTTPException(status_code=404, detail="Member not found")
        return {"success": True, "message": "Member removed successfully"}
    except ValueError as e:
        raise HTTPException(status_code=403, detail=str(e))


# Tenant Role API
@app.get("/api/v1/tenants/{tenant_id}/roles", response_model=List[TenantRoleResponse], tags=["Tenants"])
async def list_tenant_roles_endpoint(tenant_id: str, _=Depends(verify_api_key)):
    """列出租户角色"""
    if not TENANT_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Tenant manager not available")
    
    tenant_manager = get_tenant_manager()
    roles = tenant_manager.list_roles(tenant_id)
    return [r.to_dict() for r in roles]


@app.post("/api/v1/tenants/{tenant_id}/roles", response_model=TenantRoleResponse, tags=["Tenants"])
async def create_tenant_role_endpoint(
    tenant_id: str,
    role: TenantRoleCreate,
    _=Depends(verify_api_key)
):
    """创建自定义角色"""
    if not TENANT_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Tenant manager not available")
    
    tenant_manager = get_tenant_manager()
    
    try:
        new_role = tenant_manager.create_custom_role(
            tenant_id=tenant_id,
            name=role.name,
            description=role.description,
            permissions=role.permissions
        )
        return new_role.to_dict()
    except ValueError as e:
        raise HTTPException(status_code=400, detail=str(e))


@app.put("/api/v1/tenants/{tenant_id}/roles/{role_id}/permissions", tags=["Tenants"])
async def update_role_permissions_endpoint(
    tenant_id: str,
    role_id: str,
    permissions: List[str],
    _=Depends(verify_api_key)
):
    """更新角色权限"""
    if not TENANT_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Tenant manager not available")
    
    tenant_manager = get_tenant_manager()
    
    try:
        updated = tenant_manager.update_role_permissions(tenant_id, role_id, permissions)
        if not updated:
            raise HTTPException(status_code=404, detail="Role not found")
        return updated.to_dict()
    except ValueError as e:
        raise HTTPException(status_code=400, detail=str(e))


@app.delete("/api/v1/tenants/{tenant_id}/roles/{role_id}", tags=["Tenants"])
async def delete_tenant_role_endpoint(tenant_id: str, role_id: str, _=Depends(verify_api_key)):
    """删除自定义角色"""
    if not TENANT_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Tenant manager not available")
    
    tenant_manager = get_tenant_manager()
    
    try:
        success = tenant_manager.delete_role(tenant_id, role_id)
        if not success:
            raise HTTPException(status_code=404, detail="Role not found")
        return {"success": True, "message": "Role deleted successfully"}
    except ValueError as e:
        raise HTTPException(status_code=400, detail=str(e))


@app.get("/api/v1/tenants/permissions", tags=["Tenants"])
async def list_tenant_permissions_endpoint(_=Depends(verify_api_key)):
    """获取所有可用的租户权限列表"""
    return {
        "permissions": [
            {"id": k, "name": v}
            for k, v in TENANT_PERMISSIONS.items()
        ]
    }


# Tenant Resolution API
@app.get("/api/v1/tenants/resolve", tags=["Tenants"])
async def resolve_tenant_endpoint(
    host: Optional[str] = None,
    slug: Optional[str] = None,
    tenant_id: Optional[str] = None,
    _=Depends(verify_api_key)
):
    """从请求信息解析租户"""
    if not TENANT_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Tenant manager not available")
    
    tenant_manager = get_tenant_manager()
    tenant = tenant_manager.resolve_tenant_from_request(
        host=host,
        slug=slug,
        tenant_id=tenant_id
    )
    
    if not tenant:
        raise HTTPException(status_code=404, detail="Tenant not found")
    
    return tenant.to_dict()


@app.get("/api/v1/tenants/{tenant_id}/context", tags=["Tenants"])
async def get_tenant_context_endpoint(tenant_id: str, _=Depends(verify_api_key)):
    """获取租户完整上下文"""
    if not TENANT_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Tenant manager not available")
    
    tenant_manager = get_tenant_manager()
    context = tenant_manager.get_tenant_context(tenant_id)
    
    if not context:
        raise HTTPException(status_code=404, detail="Tenant not found")
    
    return context


# ============================================
# Phase 8 Task 2: Subscription & Billing APIs
# ============================================

# Pydantic Models for Subscription API
class CreateSubscriptionRequest(BaseModel):
    plan_id: str = Field(..., description="订阅计划ID")
    billing_cycle: str = Field(default="monthly", description="计费周期: monthly/yearly")
    payment_provider: Optional[str] = Field(default=None, description="支付提供商: stripe/alipay/wechat")
    trial_days: int = Field(default=0, description="试用天数")


class ChangePlanRequest(BaseModel):
    new_plan_id: str = Field(..., description="新计划ID")
    prorate: bool = Field(default=True, description="是否按比例计算差价")


class CancelSubscriptionRequest(BaseModel):
    at_period_end: bool = Field(default=True, description="是否在周期结束时取消")


class CreatePaymentRequest(BaseModel):
    amount: float = Field(..., description="支付金额")
    currency: str = Field(default="CNY", description="货币")
    provider: str = Field(..., description="支付提供商: stripe/alipay/wechat")
    payment_method: Optional[str] = Field(default=None, description="支付方式")


class RequestRefundRequest(BaseModel):
    payment_id: str = Field(..., description="支付记录ID")
    amount: float = Field(..., description="退款金额")
    reason: str = Field(..., description="退款原因")


class ProcessRefundRequest(BaseModel):
    action: str = Field(..., description="操作: approve/reject")
    reason: Optional[str] = Field(default=None, description="拒绝原因（拒绝时必填）")


class RecordUsageRequest(BaseModel):
    resource_type: str = Field(..., description="资源类型: transcription/storage/api_call/export")
    quantity: float = Field(..., description="使用量")
    unit: str = Field(..., description="单位: minutes/mb/count/page")
    description: Optional[str] = Field(default=None, description="描述")


class CreateCheckoutSessionRequest(BaseModel):
    plan_id: str = Field(..., description="计划ID")
    billing_cycle: str = Field(default="monthly", description="计费周期")
    success_url: str = Field(..., description="支付成功回调URL")
    cancel_url: str = Field(..., description="支付取消回调URL")


# Subscription Plan APIs
@app.get("/api/v1/subscription-plans", tags=["Subscriptions"])
async def list_subscription_plans(
    include_inactive: bool = Query(default=False, description="包含已停用计划"),
    _=Depends(verify_api_key)
):
    """获取所有订阅计划"""
    if not SUBSCRIPTION_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Subscription manager not available")
    
    manager = get_subscription_manager()
    plans = manager.list_plans(include_inactive=include_inactive)
    
    return {
        "plans": [
            {
                "id": p.id,
                "name": p.name,
                "tier": p.tier,
                "description": p.description,
                "price_monthly": p.price_monthly,
                "price_yearly": p.price_yearly,
                "currency": p.currency,
                "features": p.features,
                "limits": p.limits,
                "is_active": p.is_active
            }
            for p in plans
        ]
    }


@app.get("/api/v1/subscription-plans/{plan_id}", tags=["Subscriptions"])
async def get_subscription_plan(
    plan_id: str,
    _=Depends(verify_api_key)
):
    """获取订阅计划详情"""
    if not SUBSCRIPTION_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Subscription manager not available")
    
    manager = get_subscription_manager()
    plan = manager.get_plan(plan_id)
    
    if not plan:
        raise HTTPException(status_code=404, detail="Plan not found")
    
    return {
        "id": plan.id,
        "name": plan.name,
        "tier": plan.tier,
        "description": plan.description,
        "price_monthly": plan.price_monthly,
        "price_yearly": plan.price_yearly,
        "currency": plan.currency,
        "features": plan.features,
        "limits": plan.limits,
        "is_active": plan.is_active,
        "created_at": plan.created_at.isoformat()
    }


# Subscription APIs
@app.post("/api/v1/tenants/{tenant_id}/subscription", tags=["Subscriptions"])
async def create_subscription(
    tenant_id: str,
    request: CreateSubscriptionRequest,
    user_id: str = Header(..., description="当前用户ID"),
    _=Depends(verify_api_key)
):
    """创建新订阅"""
    if not SUBSCRIPTION_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Subscription manager not available")
    
    manager = get_subscription_manager()
    try:
        subscription = manager.create_subscription(
            tenant_id=tenant_id,
            plan_id=request.plan_id,
            payment_provider=request.payment_provider,
            trial_days=request.trial_days,
            billing_cycle=request.billing_cycle
        )
        
        return {
            "id": subscription.id,
            "tenant_id": subscription.tenant_id,
            "plan_id": subscription.plan_id,
            "status": subscription.status,
            "current_period_start": subscription.current_period_start.isoformat(),
            "current_period_end": subscription.current_period_end.isoformat(),
            "trial_start": subscription.trial_start.isoformat() if subscription.trial_start else None,
            "trial_end": subscription.trial_end.isoformat() if subscription.trial_end else None,
            "created_at": subscription.created_at.isoformat()
        }
    except Exception as e:
        raise HTTPException(status_code=400, detail=str(e))


@app.get("/api/v1/tenants/{tenant_id}/subscription", tags=["Subscriptions"])
async def get_tenant_subscription(
    tenant_id: str,
    _=Depends(verify_api_key)
):
    """获取租户当前订阅"""
    if not SUBSCRIPTION_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Subscription manager not available")
    
    manager = get_subscription_manager()
    subscription = manager.get_tenant_subscription(tenant_id)
    
    if not subscription:
        return {"subscription": None}
    
    plan = manager.get_plan(subscription.plan_id)
    
    return {
        "subscription": {
            "id": subscription.id,
            "tenant_id": subscription.tenant_id,
            "plan_id": subscription.plan_id,
            "plan_name": plan.name if plan else None,
            "plan_tier": plan.tier if plan else None,
            "status": subscription.status,
            "current_period_start": subscription.current_period_start.isoformat(),
            "current_period_end": subscription.current_period_end.isoformat(),
            "cancel_at_period_end": subscription.cancel_at_period_end,
            "canceled_at": subscription.canceled_at.isoformat() if subscription.canceled_at else None,
            "trial_start": subscription.trial_start.isoformat() if subscription.trial_start else None,
            "trial_end": subscription.trial_end.isoformat() if subscription.trial_end else None,
            "created_at": subscription.created_at.isoformat()
        }
    }


@app.put("/api/v1/tenants/{tenant_id}/subscription/change-plan", tags=["Subscriptions"])
async def change_subscription_plan(
    tenant_id: str,
    request: ChangePlanRequest,
    _=Depends(verify_api_key)
):
    """更改订阅计划"""
    if not SUBSCRIPTION_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Subscription manager not available")
    
    manager = get_subscription_manager()
    subscription = manager.get_tenant_subscription(tenant_id)
    
    if not subscription:
        raise HTTPException(status_code=404, detail="No active subscription found")
    
    try:
        updated = manager.change_plan(
            subscription_id=subscription.id,
            new_plan_id=request.new_plan_id,
            prorate=request.prorate
        )
        
        return {
            "id": updated.id,
            "plan_id": updated.plan_id,
            "status": updated.status,
            "message": "Plan changed successfully"
        }
    except Exception as e:
        raise HTTPException(status_code=400, detail=str(e))


@app.post("/api/v1/tenants/{tenant_id}/subscription/cancel", tags=["Subscriptions"])
async def cancel_subscription(
    tenant_id: str,
    request: CancelSubscriptionRequest,
    _=Depends(verify_api_key)
):
    """取消订阅"""
    if not SUBSCRIPTION_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Subscription manager not available")
    
    manager = get_subscription_manager()
    subscription = manager.get_tenant_subscription(tenant_id)
    
    if not subscription:
        raise HTTPException(status_code=404, detail="No active subscription found")
    
    try:
        updated = manager.cancel_subscription(
            subscription_id=subscription.id,
            at_period_end=request.at_period_end
        )
        
        return {
            "id": updated.id,
            "status": updated.status,
            "cancel_at_period_end": updated.cancel_at_period_end,
            "canceled_at": updated.canceled_at.isoformat() if updated.canceled_at else None,
            "message": "Subscription cancelled"
        }
    except Exception as e:
        raise HTTPException(status_code=400, detail=str(e))


# Usage APIs
@app.post("/api/v1/tenants/{tenant_id}/usage", tags=["Subscriptions"])
async def record_usage(
    tenant_id: str,
    request: RecordUsageRequest,
    _=Depends(verify_api_key)
):
    """记录用量"""
    if not SUBSCRIPTION_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Subscription manager not available")
    
    manager = get_subscription_manager()
    record = manager.record_usage(
        tenant_id=tenant_id,
        resource_type=request.resource_type,
        quantity=request.quantity,
        unit=request.unit,
        description=request.description
    )
    
    return {
        "id": record.id,
        "tenant_id": record.tenant_id,
        "resource_type": record.resource_type,
        "quantity": record.quantity,
        "unit": record.unit,
        "cost": record.cost,
        "recorded_at": record.recorded_at.isoformat()
    }


@app.get("/api/v1/tenants/{tenant_id}/usage", tags=["Subscriptions"])
async def get_usage_summary(
    tenant_id: str,
    start_date: Optional[str] = Query(default=None, description="开始日期 (ISO格式)"),
    end_date: Optional[str] = Query(default=None, description="结束日期 (ISO格式)"),
    _=Depends(verify_api_key)
):
    """获取用量汇总"""
    if not SUBSCRIPTION_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Subscription manager not available")
    
    manager = get_subscription_manager()
    
    start = datetime.fromisoformat(start_date) if start_date else None
    end = datetime.fromisoformat(end_date) if end_date else None
    
    summary = manager.get_usage_summary(tenant_id, start, end)
    
    return summary


# Payment APIs
@app.get("/api/v1/tenants/{tenant_id}/payments", tags=["Subscriptions"])
async def list_payments(
    tenant_id: str,
    status: Optional[str] = Query(default=None, description="支付状态过滤"),
    limit: int = Query(default=100, description="返回数量限制"),
    offset: int = Query(default=0, description="偏移量"),
    _=Depends(verify_api_key)
):
    """获取支付记录列表"""
    if not SUBSCRIPTION_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Subscription manager not available")
    
    manager = get_subscription_manager()
    payments = manager.list_payments(tenant_id, status, limit, offset)
    
    return {
        "payments": [
            {
                "id": p.id,
                "amount": p.amount,
                "currency": p.currency,
                "provider": p.provider,
                "status": p.status,
                "payment_method": p.payment_method,
                "paid_at": p.paid_at.isoformat() if p.paid_at else None,
                "failed_at": p.failed_at.isoformat() if p.failed_at else None,
                "created_at": p.created_at.isoformat()
            }
            for p in payments
        ],
        "total": len(payments)
    }


@app.get("/api/v1/tenants/{tenant_id}/payments/{payment_id}", tags=["Subscriptions"])
async def get_payment(
    tenant_id: str,
    payment_id: str,
    _=Depends(verify_api_key)
):
    """获取支付记录详情"""
    if not SUBSCRIPTION_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Subscription manager not available")
    
    manager = get_subscription_manager()
    payment = manager.get_payment(payment_id)
    
    if not payment or payment.tenant_id != tenant_id:
        raise HTTPException(status_code=404, detail="Payment not found")
    
    return {
        "id": payment.id,
        "tenant_id": payment.tenant_id,
        "subscription_id": payment.subscription_id,
        "invoice_id": payment.invoice_id,
        "amount": payment.amount,
        "currency": payment.currency,
        "provider": payment.provider,
        "provider_payment_id": payment.provider_payment_id,
        "status": payment.status,
        "payment_method": payment.payment_method,
        "paid_at": payment.paid_at.isoformat() if payment.paid_at else None,
        "failed_at": payment.failed_at.isoformat() if payment.failed_at else None,
        "failure_reason": payment.failure_reason,
        "created_at": payment.created_at.isoformat()
    }


# Invoice APIs
@app.get("/api/v1/tenants/{tenant_id}/invoices", tags=["Subscriptions"])
async def list_invoices(
    tenant_id: str,
    status: Optional[str] = Query(default=None, description="发票状态过滤"),
    limit: int = Query(default=100, description="返回数量限制"),
    offset: int = Query(default=0, description="偏移量"),
    _=Depends(verify_api_key)
):
    """获取发票列表"""
    if not SUBSCRIPTION_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Subscription manager not available")
    
    manager = get_subscription_manager()
    invoices = manager.list_invoices(tenant_id, status, limit, offset)
    
    return {
        "invoices": [
            {
                "id": inv.id,
                "invoice_number": inv.invoice_number,
                "status": inv.status,
                "amount_due": inv.amount_due,
                "amount_paid": inv.amount_paid,
                "currency": inv.currency,
                "period_start": inv.period_start.isoformat() if inv.period_start else None,
                "period_end": inv.period_end.isoformat() if inv.period_end else None,
                "description": inv.description,
                "due_date": inv.due_date.isoformat() if inv.due_date else None,
                "paid_at": inv.paid_at.isoformat() if inv.paid_at else None,
                "created_at": inv.created_at.isoformat()
            }
            for inv in invoices
        ],
        "total": len(invoices)
    }


@app.get("/api/v1/tenants/{tenant_id}/invoices/{invoice_id}", tags=["Subscriptions"])
async def get_invoice(
    tenant_id: str,
    invoice_id: str,
    _=Depends(verify_api_key)
):
    """获取发票详情"""
    if not SUBSCRIPTION_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Subscription manager not available")
    
    manager = get_subscription_manager()
    invoice = manager.get_invoice(invoice_id)
    
    if not invoice or invoice.tenant_id != tenant_id:
        raise HTTPException(status_code=404, detail="Invoice not found")
    
    return {
        "id": invoice.id,
        "invoice_number": invoice.invoice_number,
        "status": invoice.status,
        "amount_due": invoice.amount_due,
        "amount_paid": invoice.amount_paid,
        "currency": invoice.currency,
        "period_start": invoice.period_start.isoformat() if invoice.period_start else None,
        "period_end": invoice.period_end.isoformat() if invoice.period_end else None,
        "description": invoice.description,
        "line_items": invoice.line_items,
        "due_date": invoice.due_date.isoformat() if invoice.due_date else None,
        "paid_at": invoice.paid_at.isoformat() if invoice.paid_at else None,
        "voided_at": invoice.voided_at.isoformat() if invoice.voided_at else None,
        "void_reason": invoice.void_reason,
        "created_at": invoice.created_at.isoformat()
    }


# Refund APIs
@app.post("/api/v1/tenants/{tenant_id}/refunds", tags=["Subscriptions"])
async def request_refund(
    tenant_id: str,
    request: RequestRefundRequest,
    user_id: str = Header(..., description="当前用户ID"),
    _=Depends(verify_api_key)
):
    """申请退款"""
    if not SUBSCRIPTION_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Subscription manager not available")
    
    manager = get_subscription_manager()
    try:
        refund = manager.request_refund(
            tenant_id=tenant_id,
            payment_id=request.payment_id,
            amount=request.amount,
            reason=request.reason,
            requested_by=user_id
        )
        
        return {
            "id": refund.id,
            "payment_id": refund.payment_id,
            "amount": refund.amount,
            "currency": refund.currency,
            "reason": refund.reason,
            "status": refund.status,
            "requested_at": refund.requested_at.isoformat()
        }
    except Exception as e:
        raise HTTPException(status_code=400, detail=str(e))


@app.get("/api/v1/tenants/{tenant_id}/refunds", tags=["Subscriptions"])
async def list_refunds(
    tenant_id: str,
    status: Optional[str] = Query(default=None, description="退款状态过滤"),
    limit: int = Query(default=100, description="返回数量限制"),
    offset: int = Query(default=0, description="偏移量"),
    _=Depends(verify_api_key)
):
    """获取退款记录列表"""
    if not SUBSCRIPTION_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Subscription manager not available")
    
    manager = get_subscription_manager()
    refunds = manager.list_refunds(tenant_id, status, limit, offset)
    
    return {
        "refunds": [
            {
                "id": r.id,
                "payment_id": r.payment_id,
                "amount": r.amount,
                "currency": r.currency,
                "reason": r.reason,
                "status": r.status,
                "requested_by": r.requested_by,
                "requested_at": r.requested_at.isoformat(),
                "approved_by": r.approved_by,
                "approved_at": r.approved_at.isoformat() if r.approved_at else None,
                "completed_at": r.completed_at.isoformat() if r.completed_at else None
            }
            for r in refunds
        ],
        "total": len(refunds)
    }


@app.post("/api/v1/tenants/{tenant_id}/refunds/{refund_id}/process", tags=["Subscriptions"])
async def process_refund(
    tenant_id: str,
    refund_id: str,
    request: ProcessRefundRequest,
    user_id: str = Header(..., description="当前用户ID"),
    _=Depends(verify_api_key)
):
    """处理退款申请（管理员）"""
    if not SUBSCRIPTION_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Subscription manager not available")
    
    manager = get_subscription_manager()
    
    if request.action == "approve":
        refund = manager.approve_refund(refund_id, user_id)
        if not refund:
            raise HTTPException(status_code=404, detail="Refund not found")
        
        # 自动完成退款（简化实现）
        refund = manager.complete_refund(refund_id)
        
        return {
            "id": refund.id,
            "status": refund.status,
            "message": "Refund approved and processed"
        }
    
    elif request.action == "reject":
        if not request.reason:
            raise HTTPException(status_code=400, detail="Rejection reason is required")
        
        refund = manager.reject_refund(refund_id, request.reason)
        if not refund:
            raise HTTPException(status_code=404, detail="Refund not found")
        
        return {
            "id": refund.id,
            "status": refund.status,
            "message": "Refund rejected"
        }
    
    else:
        raise HTTPException(status_code=400, detail="Invalid action")


# Billing History API
@app.get("/api/v1/tenants/{tenant_id}/billing-history", tags=["Subscriptions"])
async def get_billing_history(
    tenant_id: str,
    start_date: Optional[str] = Query(default=None, description="开始日期 (ISO格式)"),
    end_date: Optional[str] = Query(default=None, description="结束日期 (ISO格式)"),
    limit: int = Query(default=100, description="返回数量限制"),
    offset: int = Query(default=0, description="偏移量"),
    _=Depends(verify_api_key)
):
    """获取账单历史"""
    if not SUBSCRIPTION_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Subscription manager not available")
    
    manager = get_subscription_manager()
    
    start = datetime.fromisoformat(start_date) if start_date else None
    end = datetime.fromisoformat(end_date) if end_date else None
    
    history = manager.get_billing_history(tenant_id, start, end, limit, offset)
    
    return {
        "history": [
            {
                "id": h.id,
                "type": h.type,
                "amount": h.amount,
                "currency": h.currency,
                "description": h.description,
                "reference_id": h.reference_id,
                "balance_after": h.balance_after,
                "created_at": h.created_at.isoformat()
            }
            for h in history
        ],
        "total": len(history)
    }


# Payment Provider Integration APIs
@app.post("/api/v1/tenants/{tenant_id}/checkout/stripe", tags=["Subscriptions"])
async def create_stripe_checkout(
    tenant_id: str,
    request: CreateCheckoutSessionRequest,
    _=Depends(verify_api_key)
):
    """创建 Stripe Checkout 会话"""
    if not SUBSCRIPTION_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Subscription manager not available")
    
    manager = get_subscription_manager()
    
    try:
        session = manager.create_stripe_checkout_session(
            tenant_id=tenant_id,
            plan_id=request.plan_id,
            success_url=request.success_url,
            cancel_url=request.cancel_url,
            billing_cycle=request.billing_cycle
        )
        
        return session
    except Exception as e:
        raise HTTPException(status_code=400, detail=str(e))


@app.post("/api/v1/tenants/{tenant_id}/checkout/alipay", tags=["Subscriptions"])
async def create_alipay_order(
    tenant_id: str,
    plan_id: str,
    billing_cycle: str = Query(default="monthly", description="计费周期"),
    _=Depends(verify_api_key)
):
    """创建支付宝订单"""
    if not SUBSCRIPTION_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Subscription manager not available")
    
    manager = get_subscription_manager()
    
    try:
        order = manager.create_alipay_order(
            tenant_id=tenant_id,
            plan_id=plan_id,
            billing_cycle=billing_cycle
        )
        
        return order
    except Exception as e:
        raise HTTPException(status_code=400, detail=str(e))


@app.post("/api/v1/tenants/{tenant_id}/checkout/wechat", tags=["Subscriptions"])
async def create_wechat_order(
    tenant_id: str,
    plan_id: str,
    billing_cycle: str = Query(default="monthly", description="计费周期"),
    _=Depends(verify_api_key)
):
    """创建微信支付订单"""
    if not SUBSCRIPTION_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Subscription manager not available")
    
    manager = get_subscription_manager()
    
    try:
        order = manager.create_wechat_order(
            tenant_id=tenant_id,
            plan_id=plan_id,
            billing_cycle=billing_cycle
        )
        
        return order
    except Exception as e:
        raise HTTPException(status_code=400, detail=str(e))


# Webhook Handlers
@app.post("/webhooks/stripe", tags=["Subscriptions"])
async def stripe_webhook(request: Request):
    """Stripe Webhook 处理"""
    if not SUBSCRIPTION_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Subscription manager not available")
    
    payload = await request.json()
    manager = get_subscription_manager()
    
    success = manager.handle_webhook("stripe", payload)
    
    if success:
        return {"status": "ok"}
    else:
        raise HTTPException(status_code=400, detail="Webhook processing failed")


@app.post("/webhooks/alipay", tags=["Subscriptions"])
async def alipay_webhook(request: Request):
    """支付宝 Webhook 处理"""
    if not SUBSCRIPTION_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Subscription manager not available")
    
    payload = await request.json()
    manager = get_subscription_manager()
    
    success = manager.handle_webhook("alipay", payload)
    
    if success:
        return {"status": "ok"}
    else:
        raise HTTPException(status_code=400, detail="Webhook processing failed")


@app.post("/webhooks/wechat", tags=["Subscriptions"])
async def wechat_webhook(request: Request):
    """微信支付 Webhook 处理"""
    if not SUBSCRIPTION_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Subscription manager not available")
    
    payload = await request.json()
    manager = get_subscription_manager()
    
    success = manager.handle_webhook("wechat", payload)
    
    if success:
        return {"status": "ok"}
    else:
        raise HTTPException(status_code=400, detail="Webhook processing failed")


# ==================== Phase 8: Enterprise Features API ====================

# Pydantic Models for Enterprise

class SSOConfigCreate(BaseModel):
    provider: str = Field(..., description="SSO 提供商: wechat_work/dingtalk/feishu/okta/azure_ad/google/custom_saml")
    entity_id: Optional[str] = Field(default=None, description="SAML Entity ID")
    sso_url: Optional[str] = Field(default=None, description="SAML SSO URL")
    slo_url: Optional[str] = Field(default=None, description="SAML SLO URL")
    certificate: Optional[str] = Field(default=None, description="SAML X.509 证书")
    metadata_url: Optional[str] = Field(default=None, description="SAML 元数据 URL")
    metadata_xml: Optional[str] = Field(default=None, description="SAML 元数据 XML")
    client_id: Optional[str] = Field(default=None, description="OAuth Client ID")
    client_secret: Optional[str] = Field(default=None, description="OAuth Client Secret")
    authorization_url: Optional[str] = Field(default=None, description="OAuth 授权 URL")
    token_url: Optional[str] = Field(default=None, description="OAuth Token URL")
    userinfo_url: Optional[str] = Field(default=None, description="OAuth UserInfo URL")
    scopes: List[str] = Field(default=["openid", "email", "profile"], description="OAuth Scopes")
    attribute_mapping: Optional[Dict[str, str]] = Field(default=None, description="属性映射")
    auto_provision: bool = Field(default=True, description="自动创建用户")
    default_role: str = Field(default="member", description="默认角色")
    domain_restriction: List[str] = Field(default_factory=list, description="允许的邮箱域名")


class SSOConfigUpdate(BaseModel):
    entity_id: Optional[str] = None
    sso_url: Optional[str] = None
    slo_url: Optional[str] = None
    certificate: Optional[str] = None
    metadata_url: Optional[str] = None
    metadata_xml: Optional[str] = None
    client_id: Optional[str] = None
    client_secret: Optional[str] = None
    authorization_url: Optional[str] = None
    token_url: Optional[str] = None
    userinfo_url: Optional[str] = None
    scopes: Optional[List[str]] = None
    attribute_mapping: Optional[Dict[str, str]] = None
    auto_provision: Optional[bool] = None
    default_role: Optional[str] = None
    domain_restriction: Optional[List[str]] = None
    status: Optional[str] = None


class SCIMConfigCreate(BaseModel):
    provider: str = Field(..., description="身份提供商")
    scim_base_url: str = Field(..., description="SCIM 服务端地址")
    scim_token: str = Field(..., description="SCIM 访问令牌")
    sync_interval_minutes: int = Field(default=60, description="同步间隔（分钟）")
    attribute_mapping: Optional[Dict[str, str]] = Field(default=None, description="属性映射")
    sync_rules: Optional[Dict[str, Any]] = Field(default=None, description="同步规则")


class SCIMConfigUpdate(BaseModel):
    scim_base_url: Optional[str] = None
    scim_token: Optional[str] = None
    sync_interval_minutes: Optional[int] = None
    attribute_mapping: Optional[Dict[str, str]] = None
    sync_rules: Optional[Dict[str, Any]] = None
    status: Optional[str] = None


class AuditExportCreate(BaseModel):
    export_format: str = Field(..., description="导出格式: json/csv/pdf/xlsx")
    start_date: str = Field(..., description="开始日期 (ISO 格式)")
    end_date: str = Field(..., description="结束日期 (ISO 格式)")
    filters: Optional[Dict[str, Any]] = Field(default_factory=dict, description="过滤条件")
    compliance_standard: Optional[str] = Field(default=None, description="合规标准: soc2/iso27001/gdpr/hipaa/pci_dss")


class RetentionPolicyCreate(BaseModel):
    name: str = Field(..., description="策略名称")
    description: Optional[str] = Field(default=None, description="策略描述")
    resource_type: str = Field(..., description="资源类型: project/transcript/entity/audit_log/user_data")
    retention_days: int = Field(..., description="保留天数")
    action: str = Field(..., description="动作: archive/delete/anonymize")
    conditions: Optional[Dict[str, Any]] = Field(default_factory=dict, description="触发条件")
    auto_execute: bool = Field(default=False, description="自动执行")
    execute_at: Optional[str] = Field(default=None, description="执行时间 (cron 表达式)")
    notify_before_days: int = Field(default=7, description="提前通知天数")
    archive_location: Optional[str] = Field(default=None, description="归档位置")
    archive_encryption: bool = Field(default=True, description="归档加密")


class RetentionPolicyUpdate(BaseModel):
    name: Optional[str] = None
    description: Optional[str] = None
    retention_days: Optional[int] = None
    action: Optional[str] = None
    conditions: Optional[Dict[str, Any]] = None
    auto_execute: Optional[bool] = None
    execute_at: Optional[str] = None
    notify_before_days: Optional[int] = None
    archive_location: Optional[str] = None
    archive_encryption: Optional[bool] = None
    is_active: Optional[bool] = None


# SSO/SAML APIs

@app.post("/api/v1/tenants/{tenant_id}/sso-configs", tags=["Enterprise"])
async def create_sso_config_endpoint(
    tenant_id: str,
    config: SSOConfigCreate,
    _=Depends(verify_api_key)
):
    """创建 SSO 配置"""
    if not ENTERPRISE_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Enterprise manager not available")
    
    manager = get_enterprise_manager()
    
    try:
        sso_config = manager.create_sso_config(
            tenant_id=tenant_id,
            provider=config.provider,
            entity_id=config.entity_id,
            sso_url=config.sso_url,
            slo_url=config.slo_url,
            certificate=config.certificate,
            metadata_url=config.metadata_url,
            metadata_xml=config.metadata_xml,
            client_id=config.client_id,
            client_secret=config.client_secret,
            authorization_url=config.authorization_url,
            token_url=config.token_url,
            userinfo_url=config.userinfo_url,
            scopes=config.scopes,
            attribute_mapping=config.attribute_mapping,
            auto_provision=config.auto_provision,
            default_role=config.default_role,
            domain_restriction=config.domain_restriction
        )
        
        return {
            "id": sso_config.id,
            "tenant_id": sso_config.tenant_id,
            "provider": sso_config.provider,
            "status": sso_config.status,
            "entity_id": sso_config.entity_id,
            "sso_url": sso_config.sso_url,
            "authorization_url": sso_config.authorization_url,
            "scopes": sso_config.scopes,
            "auto_provision": sso_config.auto_provision,
            "default_role": sso_config.default_role,
            "created_at": sso_config.created_at.isoformat()
        }
    except Exception as e:
        raise HTTPException(status_code=400, detail=str(e))


@app.get("/api/v1/tenants/{tenant_id}/sso-configs", tags=["Enterprise"])
async def list_sso_configs_endpoint(
    tenant_id: str,
    _=Depends(verify_api_key)
):
    """列出租户的所有 SSO 配置"""
    if not ENTERPRISE_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Enterprise manager not available")
    
    manager = get_enterprise_manager()
    configs = manager.list_sso_configs(tenant_id)
    
    return {
        "configs": [
            {
                "id": c.id,
                "provider": c.provider,
                "status": c.status,
                "entity_id": c.entity_id,
                "sso_url": c.sso_url,
                "authorization_url": c.authorization_url,
                "auto_provision": c.auto_provision,
                "default_role": c.default_role,
                "created_at": c.created_at.isoformat()
            }
            for c in configs
        ],
        "total": len(configs)
    }


@app.get("/api/v1/tenants/{tenant_id}/sso-configs/{config_id}", tags=["Enterprise"])
async def get_sso_config_endpoint(
    tenant_id: str,
    config_id: str,
    _=Depends(verify_api_key)
):
    """获取 SSO 配置详情"""
    if not ENTERPRISE_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Enterprise manager not available")
    
    manager = get_enterprise_manager()
    config = manager.get_sso_config(config_id)
    
    if not config or config.tenant_id != tenant_id:
        raise HTTPException(status_code=404, detail="SSO config not found")
    
    return {
        "id": config.id,
        "tenant_id": config.tenant_id,
        "provider": config.provider,
        "status": config.status,
        "entity_id": config.entity_id,
        "sso_url": config.sso_url,
        "slo_url": config.slo_url,
        "metadata_url": config.metadata_url,
        "authorization_url": config.authorization_url,
        "token_url": config.token_url,
        "userinfo_url": config.userinfo_url,
        "scopes": config.scopes,
        "attribute_mapping": config.attribute_mapping,
        "auto_provision": config.auto_provision,
        "default_role": config.default_role,
        "domain_restriction": config.domain_restriction,
        "created_at": config.created_at.isoformat(),
        "updated_at": config.updated_at.isoformat()
    }


@app.put("/api/v1/tenants/{tenant_id}/sso-configs/{config_id}", tags=["Enterprise"])
async def update_sso_config_endpoint(
    tenant_id: str,
    config_id: str,
    update: SSOConfigUpdate,
    _=Depends(verify_api_key)
):
    """更新 SSO 配置"""
    if not ENTERPRISE_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Enterprise manager not available")
    
    manager = get_enterprise_manager()
    config = manager.get_sso_config(config_id)
    
    if not config or config.tenant_id != tenant_id:
        raise HTTPException(status_code=404, detail="SSO config not found")
    
    updated = manager.update_sso_config(
        config_id=config_id,
        **{k: v for k, v in update.dict().items() if v is not None}
    )
    
    return {
        "id": updated.id,
        "status": updated.status,
        "updated_at": updated.updated_at.isoformat()
    }


@app.delete("/api/v1/tenants/{tenant_id}/sso-configs/{config_id}", tags=["Enterprise"])
async def delete_sso_config_endpoint(
    tenant_id: str,
    config_id: str,
    _=Depends(verify_api_key)
):
    """删除 SSO 配置"""
    if not ENTERPRISE_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Enterprise manager not available")
    
    manager = get_enterprise_manager()
    config = manager.get_sso_config(config_id)
    
    if not config or config.tenant_id != tenant_id:
        raise HTTPException(status_code=404, detail="SSO config not found")
    
    manager.delete_sso_config(config_id)
    return {"success": True}


@app.get("/api/v1/tenants/{tenant_id}/sso-configs/{config_id}/metadata", tags=["Enterprise"])
async def get_sso_metadata_endpoint(
    tenant_id: str,
    config_id: str,
    base_url: str = Query(..., description="服务基础 URL"),
    _=Depends(verify_api_key)
):
    """获取 SAML Service Provider 元数据"""
    if not ENTERPRISE_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Enterprise manager not available")
    
    manager = get_enterprise_manager()
    config = manager.get_sso_config(config_id)
    
    if not config or config.tenant_id != tenant_id:
        raise HTTPException(status_code=404, detail="SSO config not found")
    
    metadata = manager.generate_saml_metadata(config_id, base_url)
    
    return {
        "metadata_xml": metadata,
        "entity_id": f"{base_url}/api/v1/sso/saml/{tenant_id}",
        "acs_url": f"{base_url}/api/v1/sso/saml/{tenant_id}/acs",
        "slo_url": f"{base_url}/api/v1/sso/saml/{tenant_id}/slo"
    }


# SCIM APIs

@app.post("/api/v1/tenants/{tenant_id}/scim-configs", tags=["Enterprise"])
async def create_scim_config_endpoint(
    tenant_id: str,
    config: SCIMConfigCreate,
    _=Depends(verify_api_key)
):
    """创建 SCIM 配置"""
    if not ENTERPRISE_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Enterprise manager not available")
    
    manager = get_enterprise_manager()
    
    try:
        scim_config = manager.create_scim_config(
            tenant_id=tenant_id,
            provider=config.provider,
            scim_base_url=config.scim_base_url,
            scim_token=config.scim_token,
            sync_interval_minutes=config.sync_interval_minutes,
            attribute_mapping=config.attribute_mapping,
            sync_rules=config.sync_rules
        )
        
        return {
            "id": scim_config.id,
            "tenant_id": scim_config.tenant_id,
            "provider": scim_config.provider,
            "status": scim_config.status,
            "scim_base_url": scim_config.scim_base_url,
            "sync_interval_minutes": scim_config.sync_interval_minutes,
            "created_at": scim_config.created_at.isoformat()
        }
    except Exception as e:
        raise HTTPException(status_code=400, detail=str(e))


@app.get("/api/v1/tenants/{tenant_id}/scim-configs", tags=["Enterprise"])
async def get_scim_config_endpoint(
    tenant_id: str,
    _=Depends(verify_api_key)
):
    """获取租户的 SCIM 配置"""
    if not ENTERPRISE_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Enterprise manager not available")
    
    manager = get_enterprise_manager()
    config = manager.get_tenant_scim_config(tenant_id)
    
    if not config:
        raise HTTPException(status_code=404, detail="SCIM config not found")
    
    return {
        "id": config.id,
        "tenant_id": config.tenant_id,
        "provider": config.provider,
        "status": config.status,
        "scim_base_url": config.scim_base_url,
        "sync_interval_minutes": config.sync_interval_minutes,
        "last_sync_at": config.last_sync_at.isoformat() if config.last_sync_at else None,
        "last_sync_status": config.last_sync_status,
        "last_sync_users_count": config.last_sync_users_count,
        "created_at": config.created_at.isoformat()
    }


@app.put("/api/v1/tenants/{tenant_id}/scim-configs/{config_id}", tags=["Enterprise"])
async def update_scim_config_endpoint(
    tenant_id: str,
    config_id: str,
    update: SCIMConfigUpdate,
    _=Depends(verify_api_key)
):
    """更新 SCIM 配置"""
    if not ENTERPRISE_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Enterprise manager not available")
    
    manager = get_enterprise_manager()
    config = manager.get_scim_config(config_id)
    
    if not config or config.tenant_id != tenant_id:
        raise HTTPException(status_code=404, detail="SCIM config not found")
    
    updated = manager.update_scim_config(
        config_id=config_id,
        **{k: v for k, v in update.dict().items() if v is not None}
    )
    
    return {
        "id": updated.id,
        "status": updated.status,
        "updated_at": updated.updated_at.isoformat()
    }


@app.post("/api/v1/tenants/{tenant_id}/scim-configs/{config_id}/sync", tags=["Enterprise"])
async def sync_scim_users_endpoint(
    tenant_id: str,
    config_id: str,
    _=Depends(verify_api_key)
):
    """执行 SCIM 用户同步"""
    if not ENTERPRISE_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Enterprise manager not available")
    
    manager = get_enterprise_manager()
    config = manager.get_scim_config(config_id)
    
    if not config or config.tenant_id != tenant_id:
        raise HTTPException(status_code=404, detail="SCIM config not found")
    
    result = manager.sync_scim_users(config_id)
    
    return result


@app.get("/api/v1/tenants/{tenant_id}/scim-users", tags=["Enterprise"])
async def list_scim_users_endpoint(
    tenant_id: str,
    active_only: bool = Query(default=True, description="仅显示活跃用户"),
    _=Depends(verify_api_key)
):
    """列出 SCIM 用户"""
    if not ENTERPRISE_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Enterprise manager not available")
    
    manager = get_enterprise_manager()
    users = manager.list_scim_users(tenant_id, active_only)
    
    return {
        "users": [
            {
                "id": u.id,
                "external_id": u.external_id,
                "user_name": u.user_name,
                "email": u.email,
                "display_name": u.display_name,
                "active": u.active,
                "groups": u.groups,
                "synced_at": u.synced_at.isoformat()
            }
            for u in users
        ],
        "total": len(users)
    }


# Audit Log Export APIs

@app.post("/api/v1/tenants/{tenant_id}/audit-exports", tags=["Enterprise"])
async def create_audit_export_endpoint(
    tenant_id: str,
    request: AuditExportCreate,
    current_user: str = Header(default="user", description="当前用户ID"),
    _=Depends(verify_api_key)
):
    """创建审计日志导出任务"""
    if not ENTERPRISE_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Enterprise manager not available")
    
    manager = get_enterprise_manager()
    
    try:
        start_date = datetime.fromisoformat(request.start_date)
        end_date = datetime.fromisoformat(request.end_date)
        
        export = manager.create_audit_export(
            tenant_id=tenant_id,
            export_format=request.export_format,
            start_date=start_date,
            end_date=end_date,
            created_by=current_user,
            filters=request.filters,
            compliance_standard=request.compliance_standard
        )
        
        return {
            "id": export.id,
            "tenant_id": export.tenant_id,
            "export_format": export.export_format,
            "start_date": export.start_date.isoformat(),
            "end_date": export.end_date.isoformat(),
            "compliance_standard": export.compliance_standard,
            "status": export.status,
            "expires_at": export.expires_at.isoformat() if export.expires_at else None,
            "created_at": export.created_at.isoformat()
        }
    except Exception as e:
        raise HTTPException(status_code=400, detail=str(e))


@app.get("/api/v1/tenants/{tenant_id}/audit-exports", tags=["Enterprise"])
async def list_audit_exports_endpoint(
    tenant_id: str,
    limit: int = Query(default=100, description="返回数量限制"),
    _=Depends(verify_api_key)
):
    """列出审计日志导出记录"""
    if not ENTERPRISE_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Enterprise manager not available")
    
    manager = get_enterprise_manager()
    exports = manager.list_audit_exports(tenant_id, limit)
    
    return {
        "exports": [
            {
                "id": e.id,
                "export_format": e.export_format,
                "start_date": e.start_date.isoformat(),
                "end_date": e.end_date.isoformat(),
                "compliance_standard": e.compliance_standard,
                "status": e.status,
                "file_size": e.file_size,
                "record_count": e.record_count,
                "downloaded_by": e.downloaded_by,
                "expires_at": e.expires_at.isoformat() if e.expires_at else None,
                "created_at": e.created_at.isoformat()
            }
            for e in exports
        ],
        "total": len(exports)
    }


@app.get("/api/v1/tenants/{tenant_id}/audit-exports/{export_id}", tags=["Enterprise"])
async def get_audit_export_endpoint(
    tenant_id: str,
    export_id: str,
    _=Depends(verify_api_key)
):
    """获取审计日志导出详情"""
    if not ENTERPRISE_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Enterprise manager not available")
    
    manager = get_enterprise_manager()
    export = manager.get_audit_export(export_id)
    
    if not export or export.tenant_id != tenant_id:
        raise HTTPException(status_code=404, detail="Export not found")
    
    return {
        "id": export.id,
        "export_format": export.export_format,
        "start_date": export.start_date.isoformat(),
        "end_date": export.end_date.isoformat(),
        "compliance_standard": export.compliance_standard,
        "status": export.status,
        "file_path": export.file_path,
        "file_size": export.file_size,
        "record_count": export.record_count,
        "checksum": export.checksum,
        "downloaded_by": export.downloaded_by,
        "downloaded_at": export.downloaded_at.isoformat() if export.downloaded_at else None,
        "expires_at": export.expires_at.isoformat() if export.expires_at else None,
        "created_at": export.created_at.isoformat(),
        "completed_at": export.completed_at.isoformat() if export.completed_at else None,
        "error_message": export.error_message
    }


@app.post("/api/v1/tenants/{tenant_id}/audit-exports/{export_id}/download", tags=["Enterprise"])
async def download_audit_export_endpoint(
    tenant_id: str,
    export_id: str,
    current_user: str = Header(default="user", description="当前用户ID"),
    _=Depends(verify_api_key)
):
    """下载审计日志导出文件"""
    if not ENTERPRISE_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Enterprise manager not available")
    
    manager = get_enterprise_manager()
    export = manager.get_audit_export(export_id)
    
    if not export or export.tenant_id != tenant_id:
        raise HTTPException(status_code=404, detail="Export not found")
    
    if export.status != "completed":
        raise HTTPException(status_code=400, detail="Export not ready")
    
    # 标记已下载
    manager.mark_export_downloaded(export_id, current_user)
    
    # 返回文件下载信息
    return {
        "download_url": f"/api/v1/tenants/{tenant_id}/audit-exports/{export_id}/file",
        "expires_at": export.expires_at.isoformat() if export.expires_at else None
    }


# Data Retention Policy APIs

@app.post("/api/v1/tenants/{tenant_id}/retention-policies", tags=["Enterprise"])
async def create_retention_policy_endpoint(
    tenant_id: str,
    policy: RetentionPolicyCreate,
    _=Depends(verify_api_key)
):
    """创建数据保留策略"""
    if not ENTERPRISE_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Enterprise manager not available")
    
    manager = get_enterprise_manager()
    
    try:
        new_policy = manager.create_retention_policy(
            tenant_id=tenant_id,
            name=policy.name,
            resource_type=policy.resource_type,
            retention_days=policy.retention_days,
            action=policy.action,
            description=policy.description,
            conditions=policy.conditions,
            auto_execute=policy.auto_execute,
            execute_at=policy.execute_at,
            notify_before_days=policy.notify_before_days,
            archive_location=policy.archive_location,
            archive_encryption=policy.archive_encryption
        )
        
        return {
            "id": new_policy.id,
            "tenant_id": new_policy.tenant_id,
            "name": new_policy.name,
            "resource_type": new_policy.resource_type,
            "retention_days": new_policy.retention_days,
            "action": new_policy.action,
            "auto_execute": new_policy.auto_execute,
            "is_active": new_policy.is_active,
            "created_at": new_policy.created_at.isoformat()
        }
    except Exception as e:
        raise HTTPException(status_code=400, detail=str(e))


@app.get("/api/v1/tenants/{tenant_id}/retention-policies", tags=["Enterprise"])
async def list_retention_policies_endpoint(
    tenant_id: str,
    resource_type: Optional[str] = Query(default=None, description="资源类型过滤"),
    _=Depends(verify_api_key)
):
    """列出数据保留策略"""
    if not ENTERPRISE_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Enterprise manager not available")
    
    manager = get_enterprise_manager()
    policies = manager.list_retention_policies(tenant_id, resource_type)
    
    return {
        "policies": [
            {
                "id": p.id,
                "name": p.name,
                "resource_type": p.resource_type,
                "retention_days": p.retention_days,
                "action": p.action,
                "auto_execute": p.auto_execute,
                "is_active": p.is_active,
                "last_executed_at": p.last_executed_at.isoformat() if p.last_executed_at else None
            }
            for p in policies
        ],
        "total": len(policies)
    }


@app.get("/api/v1/tenants/{tenant_id}/retention-policies/{policy_id}", tags=["Enterprise"])
async def get_retention_policy_endpoint(
    tenant_id: str,
    policy_id: str,
    _=Depends(verify_api_key)
):
    """获取数据保留策略详情"""
    if not ENTERPRISE_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Enterprise manager not available")
    
    manager = get_enterprise_manager()
    policy = manager.get_retention_policy(policy_id)
    
    if not policy or policy.tenant_id != tenant_id:
        raise HTTPException(status_code=404, detail="Policy not found")
    
    return {
        "id": policy.id,
        "tenant_id": policy.tenant_id,
        "name": policy.name,
        "description": policy.description,
        "resource_type": policy.resource_type,
        "retention_days": policy.retention_days,
        "action": policy.action,
        "conditions": policy.conditions,
        "auto_execute": policy.auto_execute,
        "execute_at": policy.execute_at,
        "notify_before_days": policy.notify_before_days,
        "archive_location": policy.archive_location,
        "archive_encryption": policy.archive_encryption,
        "is_active": policy.is_active,
        "last_executed_at": policy.last_executed_at.isoformat() if policy.last_executed_at else None,
        "last_execution_result": policy.last_execution_result,
        "created_at": policy.created_at.isoformat()
    }


@app.put("/api/v1/tenants/{tenant_id}/retention-policies/{policy_id}", tags=["Enterprise"])
async def update_retention_policy_endpoint(
    tenant_id: str,
    policy_id: str,
    update: RetentionPolicyUpdate,
    _=Depends(verify_api_key)
):
    """更新数据保留策略"""
    if not ENTERPRISE_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Enterprise manager not available")
    
    manager = get_enterprise_manager()
    policy = manager.get_retention_policy(policy_id)
    
    if not policy or policy.tenant_id != tenant_id:
        raise HTTPException(status_code=404, detail="Policy not found")
    
    updated = manager.update_retention_policy(
        policy_id=policy_id,
        **{k: v for k, v in update.dict().items() if v is not None}
    )
    
    return {
        "id": updated.id,
        "updated_at": updated.updated_at.isoformat()
    }


@app.delete("/api/v1/tenants/{tenant_id}/retention-policies/{policy_id}", tags=["Enterprise"])
async def delete_retention_policy_endpoint(
    tenant_id: str,
    policy_id: str,
    _=Depends(verify_api_key)
):
    """删除数据保留策略"""
    if not ENTERPRISE_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Enterprise manager not available")
    
    manager = get_enterprise_manager()
    policy = manager.get_retention_policy(policy_id)
    
    if not policy or policy.tenant_id != tenant_id:
        raise HTTPException(status_code=404, detail="Policy not found")
    
    manager.delete_retention_policy(policy_id)
    return {"success": True}


@app.post("/api/v1/tenants/{tenant_id}/retention-policies/{policy_id}/execute", tags=["Enterprise"])
async def execute_retention_policy_endpoint(
    tenant_id: str,
    policy_id: str,
    _=Depends(verify_api_key)
):
    """执行数据保留策略"""
    if not ENTERPRISE_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Enterprise manager not available")
    
    manager = get_enterprise_manager()
    policy = manager.get_retention_policy(policy_id)
    
    if not policy or policy.tenant_id != tenant_id:
        raise HTTPException(status_code=404, detail="Policy not found")
    
    job = manager.execute_retention_policy(policy_id)
    
    return {
        "job_id": job.id,
        "policy_id": job.policy_id,
        "status": job.status,
        "started_at": job.started_at.isoformat() if job.started_at else None,
        "created_at": job.created_at.isoformat()
    }


@app.get("/api/v1/tenants/{tenant_id}/retention-policies/{policy_id}/jobs", tags=["Enterprise"])
async def list_retention_jobs_endpoint(
    tenant_id: str,
    policy_id: str,
    limit: int = Query(default=100, description="返回数量限制"),
    _=Depends(verify_api_key)
):
    """列出数据保留任务"""
    if not ENTERPRISE_MANAGER_AVAILABLE:
        raise HTTPException(status_code=500, detail="Enterprise manager not available")
    
    manager = get_enterprise_manager()
    policy = manager.get_retention_policy(policy_id)
    
    if not policy or policy.tenant_id != tenant_id:
        raise HTTPException(status_code=404, detail="Policy not found")
    
    jobs = manager.list_retention_jobs(policy_id, limit)
    
    return {
        "jobs": [
            {
                "id": j.id,
                "status": j.status,
                "started_at": j.started_at.isoformat() if j.started_at else None,
                "completed_at": j.completed_at.isoformat() if j.completed_at else None,
                "affected_records": j.affected_records,
                "archived_records": j.archived_records,
                "deleted_records": j.deleted_records,
                "error_count": j.error_count
            }
            for j in jobs
        ],
        "total": len(jobs)
    }


# Serve frontend - MUST be last to not override API routes

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)