# plugin_system.py
import importlib
import inspect
from typing import Dict, List, Any, Optional
from pathlib import Path
import json
import asyncio
from dataclasses import dataclass
from abc import ABC, abstractmethod

@dataclass
class PluginManifest:
    name: str
    version: str
    description: str
    author: str
    entry_point: str
    permissions: List[str]
    api_version: str

class BasePlugin(ABC):
    """插件基類"""
    
    @abstractmethod
    async def initialize(self, context: Dict) -> bool:
        pass
    
    @abstractmethod
    async def execute(self, data: Any) -> Any:
        pass
    
    @abstractmethod
    async def cleanup(self):
        pass

class PluginManager:
    def __init__(self):
        self.plugins: Dict[str, BasePlugin] = {}
        self.manifest_cache: Dict[str, PluginManifest] = {}
        self.plugin_context = {}
    
    async def load_plugin(self, plugin_path: str) -> bool:
        """動態加載插件"""
        try:
            # 讀取插件清單
            manifest_path = Path(plugin_path) / "manifest.json"
            with open(manifest_path, 'r') as f:
                manifest_data = json.load(f)
            
            manifest = PluginManifest(**manifest_data)
            
            # 驗證權限
            if not await self._validate_permissions(manifest.permissions):
                raise PermissionError(f"插件 {manifest.name} 請求的權限被拒絕")
            
            # 動態導入插件
            spec = importlib.util.spec_from_file_location(
                manifest.name, 
                Path(plugin_path) / manifest.entry_point
            )
            module = importlib.util.module_from_spec(spec)
            spec.loader.exec_module(module)
            
            # 查找插件類
            plugin_class = None
            for name, obj in inspect.getmembers(module):
                if (inspect.isclass(obj) and 
                    issubclass(obj, BasePlugin) and 
                    obj != BasePlugin):
                    plugin_class = obj
                    break
            
            if not plugin_class:
                raise ValueError(f"在插件 {manifest.name} 中未找到有效的插件類")
            
            # 實例化插件
            plugin_instance = plugin_class()
            await plugin_instance.initialize(self.plugin_context)
            
            # 註冊插件
            self.plugins[manifest.name] = plugin_instance
            self.manifest_cache[manifest.name] = manifest
            
            print(f"插件 {manifest.name} v{manifest.version} 加載成功")
            return True
            
        except Exception as e:
            print(f"加載插件失敗: {e}")
            return False
    
    async def execute_plugin(self, plugin_name: str, data: Any) -> Any:
        """執行插件"""
        if plugin_name not in self.plugins:
            raise ValueError(f"插件 {plugin_name} 未加載")
        
        plugin = self.plugins[plugin_name]
        return await plugin.execute(data)
    
    async def unload_plugin(self, plugin_name: str):
        """卸載插件"""
        if plugin_name in self.plugins:
            await self.plugins[plugin_name].cleanup()
            del self.plugins[plugin_name]
            del self.manifest_cache[plugin_name]

class PaymentPlugin(BasePlugin):
    """支付插件示例"""
    
    async def initialize(self, context: Dict) -> bool:
        self.api_key = context.get("payment_api_key")
        self.endpoint = context.get("payment_endpoint")
        return True
    
    async def execute(self, data: Dict) -> Dict:
        """處理支付請求"""
        # 調用支付網關API
        payment_result = await self._process_payment(
            data["amount"], 
            data["currency"],
            data["payment_method"]
        )
        
        return {
            "transaction_id": payment_result["id"],
            "status": payment_result["status"],
            "amount": data["amount"]
        }
    
    async def cleanup(self):
        """清理資源"""
        self.api_key = None
        self.endpoint = None

# 使用示例
plugin_manager = PluginManager()

# 加載支付插件
await plugin_manager.load_plugin("./plugins/payment-gateway")

# 使用插件處理支付
payment_data = {
    "amount": 100.00,
    "currency": "USD",
    "payment_method": "credit_card"
}

result = await plugin_manager.execute_plugin("payment-gateway", payment_data)
print(f"支付結果: {result}")

# marketplace.py
from typing import Dict, List, Optional
from datetime import datetime
import aiohttp
import json
import asyncio

class Marketplace:
    def __init__(self, api_endpoint: str):
        self.api_endpoint = api_endpoint
        self.applications = {}
        self.plugins = {}
        self.templates = {}
    
    async def browse_applications(self, category: str = None, 
                                search_query: str = None) -> List[Dict]:
        """瀏覽應用市場"""
        params = {}
        if category:
            params["category"] = category
        if search_query:
            params["q"] = search_query
        
        async with aiohttp.ClientSession() as session:
            async with session.get(
                f"{self.api_endpoint}/applications",
                params=params
            ) as response:
                applications = await response.json()
                self.applications.update({app["id"]: app for app in applications})
                return applications
    
    async def install_application(self, app_id: str, 
                                target_environment: str) -> Dict:
        """安裝市場應用"""
        # 獲取應用詳情
        app_details = await self._get_application_details(app_id)
        
        # 下載應用包
        app_package = await self._download_application_package(app_id)
        
        # 部署應用到目標環境
        deployment_result = await self._deploy_application(
            app_package, target_environment
        )
        
        # 記錄安裝歷史
        await self._record_installation(app_id, target_environment)
        
        return {
            "app_id": app_id,
            "app_name": app_details["name"],
            "version": app_details["version"],
            "deployment_status": "success",
            "endpoint": deployment_result["endpoint"]
        }
    
    async def publish_application(self, app_metadata: Dict, 
                                app_package: bytes) -> str:
        """發佈應用到市場"""
        # 驗證應用元數據
        if not await self._validate_app_metadata(app_metadata):
            raise ValueError("應用元數據驗證失敗")
        
        # 上傳應用到市場
        async with aiohttp.ClientSession() as session:
            form_data = aiohttp.FormData()
            form_data.add_field('metadata', 
                              json.dumps(app_metadata),
                              content_type='application/json')
            form_data.add_field('package', 
                              app_package,
                              filename=f"{app_metadata['name']}.zip",
                              content_type='application/zip')
            
            async with session.post(
                f"{self.api_endpoint}/applications/publish",
                data=form_data
            ) as response:
                result = await response.json()
                return result["app_id"]

class RatingSystem:
    """評分和評論系統"""
    
    def __init__(self):
        self.ratings = {}
        self.reviews = {}
    
    async def rate_application(self, app_id: str, user_id: str, 
                             rating: int, comment: str = None):
        """為應用評分"""
        if app_id not in self.ratings:
            self.ratings[app_id] = []
        
        self.ratings[app_id].append({
            "user_id": user_id,
            "rating": rating,
            "timestamp": datetime.now()
        })
        
        if comment:
            if app_id not in self.reviews:
                self.reviews[app_id] = []
            
            self.reviews[app_id].append({
                "user_id": user_id,
                "comment": comment,
                "timestamp": datetime.now()
            })
    
    async def get_application_rating(self, app_id: str) -> Dict:
        """獲取應用評分統計"""
        if app_id not in self.ratings:
            return {"average": 0, "count": 0}
        
        ratings = self.ratings[app_id]
        average = sum(r["rating"] for r in ratings) / len(ratings)
        
        return {
            "average": round(average, 1),
            "count": len(ratings),
            "distribution": self._calculate_rating_distribution(ratings)
        }

# api_gateway.py
from flask import Flask, request, jsonify
from functools import wraps
import jwt
import time
from typing import Dict, Optional

app = Flask(__name__)

class APIGateway:
    def __init__(self):
        self.routes = {}
        self.middlewares = []
        self.rate_limits = {}
    
    def register_route(self, path: str, handler, methods: List[str] = None):
        """註冊API路由"""
        self.routes[path] = {
            "handler": handler,
            "methods": methods or ["GET"],
            "rate_limit": self.rate_limits.get(path, {"requests": 100, "window": 3600})
        }
    
    def add_middleware(self, middleware_func):
        """添加中間件"""
        self.middlewares.append(middleware_func)
    
    async def handle_request(self, path: str, method: str, 
                           headers: Dict, body: Optional[Dict] = None):
        """處理API請求"""
        # 執行中間件
        context = {"headers": headers, "body": body}
        for middleware in self.middlewares:
            context = await middleware(context)
            if context.get("block_request"):
                return {"error": "請求被中間件阻止"}
        
        # 檢查路由是否存在
        if path not in self.routes:
            return {"error": "路由不存在"}
        
        route = self.routes[path]
        
        # 檢查HTTP方法
        if method not in route["methods"]:
            return {"error": "方法不允許"}
        
        # 檢查速率限制
        if not await self._check_rate_limit(path, context.get("api_key")):
            return {"error": "速率限制超出"}
        
        # 調用處理函數
        try:
            result = await route["handler"](context)
            return result
        except Exception as e:
            return {"error": f"處理請求時出錯: {str(e)}"}

class DeveloperPortal:
    """開發者門户"""
    
    def __init__(self):
        self.api_docs = {}
        self.sdks = {}
        self.tutorials = {}
    
    async def generate_api_documentation(self, api_spec: Dict) -> str:
        """生成API文檔"""
        # 使用模板生成OpenAPI文檔
        openapi_spec = {
            "openapi": "3.0.0",
            "info": {
                "title": api_spec["name"],
                "version": api_spec["version"],
                "description": api_spec["description"]
            },
            "paths": self._generate_paths(api_spec["endpoints"])
        }
        
        return json.dumps(openapi_spec, indent=2)
    
    async def generate_sdk(self, api_spec: Dict, language: str) -> str:
        """生成SDK"""
        if language == "python":
            return self._generate_python_sdk(api_spec)
        elif language == "javascript":
            return self._generate_javascript_sdk(api_spec)
        elif language == "java":
            return self._generate_java_sdk(api_spec)
    
    async def create_tutorial(self, topic: str, content: Dict) -> str:
        """創建教程"""
        tutorial_id = f"tutorial_{len(self.tutorials) + 1}"
        self.tutorials[tutorial_id] = {
            "topic": topic,
            "content": content,
            "created_at": datetime.now(),
            "difficulty": content.get("difficulty", "beginner")
        }
        return tutorial_id

# API路由示例
api_gateway = APIGateway()

@app.route('/api/v1/<path:subpath>', methods=['GET', 'POST', 'PUT', 'DELETE'])
async def api_proxy(subpath):
    """API網關代理"""
    full_path = f"/api/v1/{subpath}"
    result = await api_gateway.handle_request(
        full_path,
        request.method,
        dict(request.headers),
        request.get_json(silent=True)
    )
    return jsonify(result)

# 認證中間件
async def auth_middleware(context: Dict) -> Dict:
    """認證中間件"""
    api_key = context["headers"].get("X-API-Key")
    if not api_key:
        context["block_request"] = True
        return context
    
    # 驗證API Key
    if not await validate_api_key(api_key):
        context["block_request"] = True
        return context
    
    context["user_id"] = await get_user_id_from_api_key(api_key)
    return context

api_gateway.add_middleware(auth_middleware)

# third_party_integrations.py
from typing import Dict, List, Any
import aiohttp
import asyncio
from abc import ABC, abstractmethod

class ThirdPartyService(ABC):
    """第三方服務基類"""
    
    @abstractmethod
    async def authenticate(self, credentials: Dict) -> bool:
        pass
    
    @abstractmethod
    async def make_request(self, endpoint: str, data: Dict = None) -> Any:
        pass
    
    @abstractmethod
    async def webhook_handler(self, payload: Dict) -> Dict:
        pass

class CRMIntegration(ThirdPartyService):
    """CRM系統集成"""
    
    def __init__(self):
        self.base_url = None
        self.access_token = None
    
    async def authenticate(self, credentials: Dict) -> bool:
        """認證到CRM系統"""
        self.base_url = credentials["base_url"]
        
        async with aiohttp.ClientSession() as session:
            async with session.post(
                f"{self.base_url}/oauth/token",
                data={
                    "grant_type": "client_credentials",
                    "client_id": credentials["client_id"],
                    "client_secret": credentials["client_secret"]
                }
            ) as response:
                if response.status == 200:
                    token_data = await response.json()
                    self.access_token = token_data["access_token"]
                    return True
        return False
    
    async def create_contact(self, contact_data: Dict) -> Dict:
        """創建聯繫人"""
        return await self.make_request("/contacts", contact_data)
    
    async def make_request(self, endpoint: str, data: Dict = None) -> Any:
        """發送API請求"""
        headers = {"Authorization": f"Bearer {self.access_token}"}
        
        async with aiohttp.ClientSession() as session:
            async with session.post(
                f"{self.base_url}{endpoint}",
                json=data,
                headers=headers
            ) as response:
                return await response.json()

class IntegrationManager:
    """集成管理器"""
    
    def __init__(self):
        self.integrations = {
            "salesforce": SalesforceIntegration(),
            "hubspot": HubspotIntegration(),
            "zapier": ZapierIntegration(),
            "slack": SlackIntegration()
        }
        self.connected_services = {}
    
    async def connect_service(self, service_name: str, 
                            credentials: Dict) -> bool:
        """連接第三方服務"""
        if service_name not in self.integrations:
            return False
        
        service = self.integrations[service_name]
        success = await service.authenticate(credentials)
        
        if success:
            self.connected_services[service_name] = service
            return True
        
        return False
    
    async def create_data_sync(self, source_service: str, 
                             target_service: str,
                             mapping_rules: Dict):
        """創建數據同步"""
        if (source_service not in self.connected_services or 
            target_service not in self.connected_services):
            raise ValueError("服務未連接")
        
        source = self.connected_services[source_service]
        target = self.connected_services[target_service]
        
        # 啓動同步任務
        asyncio.create_task(
            self._run_data_sync(source, target, mapping_rules)
        )
    
    async def _run_data_sync(self, source, target, mapping_rules):
        """運行數據同步"""
        while True:
            try:
                # 從源系統獲取數據
                source_data = await source.fetch_data(mapping_rules["source_query"])
                
                # 轉換數據
                transformed_data = await self._transform_data(
                    source_data, mapping_rules["field_mapping"]
                )
                
                # 推送到目標系統
                await target.push_data(transformed_data)
                
                # 等待下一次同步
                await asyncio.sleep(mapping_rules.get("interval_seconds", 300))
                
            except Exception as e:
                print(f"數據同步錯誤: {e}")
                await asyncio.sleep(60)

# ecosystem_manager.py
from typing import Dict, List
from datetime import datetime
import asyncio

class EcosystemManager:
    def __init__(self):
        self.plugin_registry = {}
        self.app_registry = {}
        self.integration_registry = {}
        self.analytics = EcosystemAnalytics()
    
    async def register_plugin(self, plugin_metadata: Dict) -> str:
        """註冊插件到生態系統"""
        plugin_id = f"plugin_{len(self.plugin_registry) + 1}"
        
        self.plugin_registry[plugin_id] = {
            **plugin_metadata,
            "registered_at": datetime.now(),
            "download_count": 0,
            "rating": 0.0
        }
        
        # 發佈到插件市場
        await self._publish_to_marketplace("plugin", plugin_metadata)
        
        return plugin_id
    
    async def register_application(self, app_metadata: Dict) -> str:
        """註冊應用到生態系統"""
        app_id = f"app_{len(self.app_registry) + 1}"
        
        self.app_registry[app_id] = {
            **app_metadata,
            "registered_at": datetime.now(),
            "install_count": 0,
            "revenue_share": app_metadata.get("revenue_share", 0.1)
        }
        
        return app_id
    
    async def process_revenue_share(self, app_id: str, amount: float):
        """處理收入分成"""
        app = self.app_registry[app_id]
        revenue_share = amount * app["revenue_share"]
        
        # 記錄分成
        await self._record_payment(
            app["developer_id"],
            revenue_share,
            f"Revenue share for {app['name']}"
        )
        
        # 更新分析
        await self.analytics.record_transaction(app_id, amount, revenue_share)

class EcosystemAnalytics:
    """生態系統分析"""
    
    def __init__(self):
        self.metrics = {
            "total_plugins": 0,
            "total_apps": 0,
            "total_developers": 0,
            "monthly_revenue": 0.0,
            "active_installs": 0
        }
        self.transaction_log = []
    
    async def record_transaction(self, item_id: str, amount: float, 
                              revenue_share: float):
        """記錄交易"""
        self.transaction_log.append({
            "item_id": item_id,
            "amount": amount,
            "revenue_share": revenue_share,
            "timestamp": datetime.now()
        })
        
        self.metrics["monthly_revenue"] += amount
    
    async def generate_ecosystem_report(self) -> Dict:
        """生成生態系統報告"""
        return {
            "metrics": self.metrics,
            "top_plugins": await self._get_top_plugins(),
            "top_apps": await self._get_top_apps(),
            "growth_trends": await self._calculate_growth_trends(),
            "revenue_breakdown": await self._analyze_revenue_breakdown()
        }

# 使用示例
ecosystem = EcosystemManager()

# 註冊新插件
plugin_id = await ecosystem.register_plugin({
    "name": "Advanced Analytics",
    "version": "1.0.0",
    "description": "高級數據分析插件",
    "developer_id": "dev_123",
    "price": 99.99,
    "category": "analytics"
})

# 處理購買
await ecosystem.process_revenue_share(plugin_id, 99.99)