# app/utils/postgrest_optimization.py（注文最適化ヘルパー）
from typing import Dict, List, Any, Optional
import urllib.parse
from dataclasses import dataclass

@dataclass
class QueryPerformanceMetrics:
    """クエリパフォーマンス測定"""
    execution_time: float
    rows_returned: int
    bytes_transferred: int
    cache_hit: bool

class PostgRESTQueryOptimizer:
    """PostgRESTクエリ最適化ヘルパー（スマート注文システム）"""
    
    @staticmethod
    def build_optimized_query(
        table: str,                              # テーブル名（メニューカテゴリ）
        select_fields: List[str] = None,         # 取得フィールド（欲しい料理の部分）
        filters: Dict[str, Any] = None,          # フィルター条件（注文の詳細指定）
        order_by: List[str] = None,              # ソート順（料理の並び順）
        limit: int = None,                       # 取得件数制限（注文数上限）
        offset: int = None,                      # 開始位置（何番目から注文するか）
        embedded_resources: Dict[str, Dict] = None,  # 関連データ（サイドメニューも一緒に）
        use_count: bool = False                  # 件数取得（全部で何皿あるか知りたい）
    ) -> str:
        """最適化されたPostgRESTクエリURL生成（効率的な注文書作成）"""
        
        # 🎯 基本URL構築
        base_url = f"/{table}"
        query_params = []
        
        # 📋 Step 1: 必要なフィールドのみ選択（欲しい部分だけ注文）
        if select_fields:
            # 👍 良い例: select=id,name,email（必要な部分だけ）
            # 👎 悪い例: select=*（全部盛り = 重い）
            select_str = ",".join(select_fields)
            query_params.append(f"select={select_str}")
            print(f"✅ 効率的: 必要フィールドのみ選択 ({len(select_fields)}個)")
        else:
            print("⚠️ 注意: 全フィールド取得（*）は重くなる可能性があります")
        
        # 🔍 Step 2: フィルター条件の最適化
        if filters:
            for field, value in filters.items():
                if isinstance(value, list):
                    # 配列での絞り込み（複数の料理IDから選択）
                    values_str = ",".join(map(str, value))
                    query_params.append(f"{field}=in.({values_str})")
                    print(f"📊 リスト検索: {field} in ({len(value)}件)")
                elif isinstance(value, dict):
                    # 範囲検索や複雑な条件
                    for operator, op_value in value.items():
                        query_params.append(f"{field}={operator}.{op_value}")
                        print(f"🔍 条件検索: {field} {operator} {op_value}")
                else:
                    # 単純な等価検索
                    query_params.append(f"{field}=eq.{value}")
                    print(f"🎯 等価検索: {field} = {value}")
        
        # 📈 Step 3: ソート最適化（インデックスを活用）
        if order_by:
            # インデックスのある列での並び替えを推奨
            order_str = ",".join(order_by)
            query_params.append(f"order={order_str}")
            print(f"🔄 ソート: {order_str}")
        
        # 📄 Step 4: ページネーション（大量データの分割取得）
        if limit:
            query_params.append(f"limit={limit}")
            if offset:
                query_params.append(f"offset={offset}")
            print(f"📄 ページング: {limit}件ずつ（{offset or 0}番目から）")
        
        # 🔗 Step 5: 関連データの効率的取得（JOINクエリの最適化）
        if embedded_resources:
            for resource, config in embedded_resources.items():
                embed_select = config.get('select', '*')
                embed_filters = config.get('filters', {})
                
                embed_query = f"{resource}({embed_select})"
                if embed_filters:
                    # 関連データにもフィルター適用
                    filter_parts = [f"{k}=eq.{v}" for k, v in embed_filters.items()]
                    embed_query = f"{resource}({embed_select})"
                
                # selectパラメータに埋め込み
                if 'select=' in query_params[0] if query_params else False:
                    query_params[0] += f",{embed_query}"
                else:
                    query_params.insert(0, f"select=*,{embed_query}")
                print(f"🔗 関連データ取得: {resource}")
        
        # 📊 Step 6: 件数取得の最適化
        if use_count:
            query_params.append("count=exact")
            print("🔢 件数取得: ON（少し重くなります）")
        
        # 🎯 最終URL生成
        if query_params:
            query_string = "&".join(query_params)
            final_url = f"{base_url}?{query_string}"
        else:
            final_url = base_url
        
        print(f"📞 生成されたクエリURL: {final_url}")
        return final_url
    
    @staticmethod
    def optimize_bulk_operations(
        table: str,
        operation: str,
        data: List[Dict[str, Any]],
        batch_size: int = 100
    ) -> List[str]:
        """一括操作の最適化（大量注文の効率化）"""
        
        print(f"🚚 一括{operation}操作: {len(data)}件を{batch_size}件ずつ処理")
        
        urls = []
        
        # バッチ処理で分割（一度に大量処理すると重いので小分け）
        for i in range(0, len(data), batch_size):
            batch = data[i:i + batch_size]
            
            if operation == "insert":
                # 一括挿入
                urls.append(f"/{table}")
                print(f"📝 バッチ{i//batch_size + 1}: {len(batch)}件挿入")
            
            elif operation == "update":
                # 一括更新（可能な場合）
                urls.append(f"/{table}")
                print(f"✏️ バッチ{i//batch_size + 1}: {len(batch)}件更新")
            
            elif operation == "upsert":
                # 一括UPSERT（あれば更新、なければ挿入）
                urls.append(f"/{table}")
                print(f"🔄 バッチ{i//batch_size + 1}: {len(batch)}件UPSERT")
        
        return urls
    
    @staticmethod
    def analyze_query_performance(url: str, response_time: float, data_size: int) -> QueryPerformanceMetrics:
        """クエリパフォーマンス分析（注文効率の測定）"""
        
        # 🎯 パフォーマンス評価
        if response_time < 0.1:
            performance = "🚀 超高速"
        elif response_time < 0.5:
            performance = "✅ 高速"
        elif response_time < 2.0:
            performance = "📊 普通"
        else:
            performance = "🐌 要改善"
        
        # 📊 データサイズ評価
        if data_size < 1024:  # 1KB未満
            size_rating = "軽量"
        elif data_size < 1024 * 100:  # 100KB未満
            size_rating = "適正"
        else:
            size_rating = "重い"
        
        print(f"⏱️ 応答時間: {response_time:.3f}秒 ({performance})")
        print(f"📦 データサイズ: {data_size:,}バイト ({size_rating})")
        
        return QueryPerformanceMetrics(
            execution_time=response_time,
            rows_returned=data_size // 100,  # 推定行数
            bytes_transferred=data_size,
            cache_hit=response_time < 0.1
        )

# 🎯 実際の使用例
def demo_optimized_queries():
    """最適化クエリのデモ（効率的注文の実例）"""
    
    optimizer = PostgRESTQueryOptimizer()
    
    # 📋 例1: 基本的な最適化クエリ
    print("=== 例1: 基本的なユーザー検索 ===")
    url1 = optimizer.build_optimized_query(
        table="users",
        select_fields=["id", "name", "email"],  # 必要な項目のみ
        filters={"is_active": True},            # アクティブユーザーのみ
        order_by=["created_at.desc"],           # 新しい順
        limit=20                                # 20件まで
    )
    # 結果: /users?select=id,name,email&is_active=eq.true&order=created_at.desc&limit=20
    
    print("\n=== 例2: 複雑な検索条件 ===")
    url2 = optimizer.build_optimized_query(
        table="tasks",
        select_fields=["id", "title", "status", "due_date"],
        filters={
            "status": ["todo", "in_progress"],    # ステータス複数指定
            "priority": {"gte": 2},               # 優先度2以上
            "due_date": {"lt": "2024-12-31"}      # 期限が2024年内
        },
        order_by=["priority.desc", "due_date.asc"],
        limit=50
    )
    
    print("\n=== 例3: 関連データの効率取得 ===")
    url3 = optimizer.build_optimized_query(
        table="projects",
        select_fields=["id", "name", "status"],
        embedded_resources={
            "tasks": {
                "select": "id,title,status",
                "filters": {"status": "todo"}
            },
            "members": {
                "select": "id,name,role"
            }
        },
        limit=10
    )
    
    return [url1, url2, url3]

if __name__ == "__main__":
    demo_optimized_queries()

# app/core/postgrest_cache.py（PostgREST専用の作り置きシステム）
import hashlib
import json
import time
from typing import Any, Optional, Dict, List
from datetime import datetime, timedelta
from dataclasses import dataclass

from app.core.cache import cache

@dataclass 
class CacheStats:
    """キャッシュ統計情報（作り置き効果測定）"""
    hit_count: int = 0          # キャッシュヒット数（作り置きが使われた回数）
    miss_count: int = 0         # キャッシュミス数（作り置きがなくて作った回数）
    total_requests: int = 0     # 総リクエスト数（総注文数）
    
    @property
    def hit_rate(self) -> float:
        """ヒット率計算（作り置き活用率）"""
        if self.total_requests == 0:
            return 0.0
        return (self.hit_count / self.total_requests) * 100

class PostgRESTCache:
    """PostgREST専用キャッシュ管理（レストランの作り置きマネージャー）"""
    
    def __init__(self, default_ttl: int = 300):
        self.default_ttl = default_ttl                    # デフォルト保存時間（5分）
        self.cache_key_prefix = "postgrest"               # キャッシュキーの接頭辞
        self.stats = CacheStats()                         # 統計情報
        self.hot_tables = ["users", "projects", "tasks"]  # 人気テーブル（よく注文されるメニュー）
    
    def get_cached_response(
        self, 
        url: str,                    # APIのURL（注文内容）
        headers: dict = None         # リクエストヘッダー（注文の詳細条件）
    ) -> Optional[Any]:
        """キャッシュされたレスポンス取得（作り置き料理の提供）"""
        
        cache_key = self._generate_cache_key(url, headers)
        start_time = time.time()
        
        # 📦 キャッシュから取得を試行
        cached_data = cache.get(cache_key)
        
        if cached_data is not None:
            # 🎯 キャッシュヒット！（作り置きが見つかった）
            self.stats.hit_count += 1
            response_time = time.time() - start_time
            print(f"⚡ キャッシュヒット: {cache_key} (応答時間: {response_time:.3f}秒)")
            
            # 人気データの統計を更新
            table_name = self._extract_table_name(url)
            if table_name in self.hot_tables:
                self._update_popularity_stats(table_name)
            
            return cached_data
        
        else:
            # 📭 キャッシュミス（作り置きなし、新たに作る必要あり）
            self.stats.miss_count += 1
            print(f"📭 キャッシュミス: {cache_key}")
            return None
        
        finally:
            self.stats.total_requests += 1
    
    def cache_response(
        self, 
        url: str,                    # APIのURL
        response_data: Any,          # レスポンスデータ（完成した料理）
        headers: dict = None,        # レスポンスヘッダー
        ttl: Optional[int] = None    # キャッシュ保存時間（作り置き期限）
    ):
        """レスポンスキャッシュ（作り置き料理の保存）"""
        
        cache_key = self._generate_cache_key(url, headers)
        cache_ttl = ttl or self.default_ttl
        
        # 📊 データの特性に応じてTTL調整（料理に応じて保存期間を変更）
        table_name = self._extract_table_name(url)
        
        # 🔄 よく変更されるデータは短めの保存時間
        if 'content-range' in (headers or {}):
            cache_ttl = min(cache_ttl, 60)      # ページネーションデータは1分
            print(f"📄 ページネーションデータ: TTL={cache_ttl}秒")
        
        elif table_name in ["audit_logs", "notifications"]:
            cache_ttl = min(cache_ttl, 30)      # ログ・通知は30秒
            print(f"📝 ログデータ: TTL={cache_ttl}秒")
        
        elif table_name in ["users", "organizations"]:
            cache_ttl = max(cache_ttl, 600)     # ユーザー・組織情報は10分
            print(f"👥 ユーザーデータ: TTL={cache_ttl}秒")
        
        # 💾 キャッシュ保存実行
        cache_metadata = {
            "data": response_data,
            "cached_at": datetime.utcnow().isoformat(),
            "ttl": cache_ttl,
            "url": url,
            "table": table_name
        }
        
        cache.set(cache_key, cache_metadata, cache_ttl)
        print(f"💾 キャッシュ保存: {cache_key} (TTL: {cache_ttl}秒)")
    
    def invalidate_table_cache(self, table_name: str):
        """テーブル関連キャッシュ無効化（特定料理の作り置きを全て廃棄）"""
        
        print(f"🗑️ テーブルキャッシュ無効化開始: {table_name}")
        
        # パターンマッチでテーブル関連のキャッシュを検索
        pattern = f"{self.cache_key_prefix}:*/{table_name}*"
        
        # 実際の実装では Redis の SCAN コマンドなどを使用
        invalidated_count = 0
        
        # キャッシュキーの検索と削除（簡略化実装）
        # 実際は Redis.scan_iter() などを使用
        cache_keys = cache.keys(pattern) if hasattr(cache, 'keys') else []
        
        for key in cache_keys:
            cache.delete(key)
            invalidated_count += 1
        
        print(f"✅ {invalidated_count}個のキャッシュを無効化: {table_name}")
    
    def invalidate_related_caches(self, table_name: str, operation: str):
        """関連キャッシュの連鎖無効化（関連料理の作り置きも廃棄）"""
        
        # 📊 テーブル間の依存関係マップ
        table_relationships = {
            "users": ["projects", "tasks", "organizations"],      # ユーザー変更で関連データも無効化
            "projects": ["tasks", "project_members"],             # プロジェクト変更でタスクも無効化
            "organizations": ["users", "projects", "tasks"],      # 組織変更で全関連データ無効化
            "tasks": []                                           # タスクは他に影響しない
        }
        
        # 🎯 直接テーブルのキャッシュ無効化
        self.invalidate_table_cache(table_name)
        
        # 🔗 関連テーブルのキャッシュも無効化
        related_tables = table_relationships.get(table_name, [])
        for related_table in related_tables:
            print(f"🔗 関連テーブル無効化: {related_table} (起因: {table_name})")
            self.invalidate_table_cache(related_table)
        
        print(f"♻️ 連鎖無効化完了: {table_name} → {len(related_tables)}個の関連テーブル")
    
    def get_cache_statistics(self) -> Dict[str, Any]:
        """キャッシュ統計情報取得（作り置きシステムの効果測定）"""
        
        return {
            "hit_rate": round(self.stats.hit_rate, 2),
            "hit_count": self.stats.hit_count,
            "miss_count": self.stats.miss_count,
            "total_requests": self.stats.total_requests,
            "efficiency": "excellent" if self.stats.hit_rate > 80 else
                         "good" if self.stats.hit_rate > 60 else
                         "needs_improvement"
        }
    
    def _generate_cache_key(self, url: str, headers: dict = None) -> str:
        """キャッシュキー生成（作り置き料理の識別ラベル作成）"""
        
        # URL + 重要なヘッダーでユニークなキーを生成
        key_parts = [url]
        
        if headers:
            # 認証情報がキャッシュに影響する場合は含める
            auth_header = headers.get('Authorization', '')
            if auth_header:
                # JWTトークンの一部のみ使用（セキュリティ考慮）
                key_parts.append(hashlib.md5(auth_header.encode()).hexdigest()[:8])
        
        # ハッシュ化してキー生成
        key_string = "|".join(key_parts)
        cache_key = f"{self.cache_key_prefix}:{hashlib.md5(key_string.encode()).hexdigest()}"
        
        return cache_key
    
    def _extract_table_name(self, url: str) -> str:
        """URLからテーブル名抽出"""
        # /users?select=id,name → "users"
        # /api/v1/projects/123 → "projects"
        
        parts = url.strip('/').split('/')
        for part in parts:
            if '?' in part:
                return part.split('?')[0]
            elif part and not part.startswith('api') and not part.startswith('v'):
                return part
        return "unknown"
    
    def _update_popularity_stats(self, table_name: str):
        """人気テーブル統計更新"""
        # 実際の実装では Redis の ZINCRBY などを使用
        print(f"📊 人気度更新: {table_name}")

# 🎯 キャッシュミドルウェアの実装例
class PostgRESTCacheMiddleware:
    """PostgRESTキャッシュミドルウェア（自動作り置きシステム）"""
    
    def __init__(self):
        self.cache_manager = PostgRESTCache()
    
    async def __call__(self, request, call_next):
        """リクエスト処理でキャッシュを自動適用"""
        
        # 🔍 GET リクエストのみキャッシュ対象
        if request.method != "GET":
            return await call_next(request)
        
        # 📦 キャッシュ確認
        cached_response = self.cache_manager.get_cached_response(
            url=str(request.url),
            headers=dict(request.headers)
        )
        
        if cached_response:
            # ✅ キャッシュヒット：即座に返却
            return create_response_from_cache(cached_response)
        
        # 📭 キャッシュミス：通常処理 + キャッシュ保存
        response = await call_next(request)
        
        # 📄 レスポンスをキャッシュに保存
        if response.status_code == 200:
            self.cache_manager.cache_response(
                url=str(request.url),
                response_data=response.json(),
                headers=dict(response.headers)
            )
        
        return response

def create_response_from_cache(cached_data):
    """キャッシュデータからレスポンス生成"""
    # 実際の実装では適切なレスポンスオブジェクトを生成
    pass

# app/client/optimization/cache_manager.py（スマホ用キャッシュシステム）
import time
import json
import hashlib
from typing import Any, Dict, Optional, Callable
from datetime import datetime, timedelta
from dataclasses import dataclass, asdict
from threading import RLock

@dataclass
class CacheEntry:
    """キャッシュエントリ（保存されたデータ）"""
    data: Any                    # 実際のデータ（料理の中身）
    timestamp: float             # 保存時刻（作った時間）
    ttl: float                   # 有効期限（消費期限）
    access_count: int = 0        # アクセス回数（使われた回数）
    last_access: float = None    # 最終アクセス時刻（最後に使った時間）

class FletCacheManager:
    """Fletアプリケーション用キャッシュマネージャー（スマホの冷蔵庫管理システム）"""
    
    def __init__(self, max_size: int = 1000, default_ttl: int = 300):
        self.cache: Dict[str, CacheEntry] = {}    # キャッシュ辞書（冷蔵庫の中身）
        self.max_size = max_size                  # 最大保存数（冷蔵庫の容量）
        self.default_ttl = default_ttl            # デフォルト保存時間（5分）
        self._lock = RLock()                      # スレッドセーフティ（同時アクセス防止）
        
        # 📊 統計情報（冷蔵庫の使用状況）
        self.hits = 0                             # ヒット数（冷蔵庫から取り出せた回数）
        self.misses = 0                           # ミス数（冷蔵庫になくて作った回数）
        self.evictions = 0                        # 追い出し数（古い物を捨てた回数）
    
    def get(self, key: str, default: Any = None) -> Any:
        """キャッシュ取得（冷蔵庫から食材を取り出し）"""
        with self._lock:
            if key not in self.cache:
                # 📭 キャッシュにない（冷蔵庫にない）
                self.misses += 1
                return default
            
            entry = self.cache[key]
            current_time = time.time()
            
            # ⏰ 消費期限チェック
            if current_time - entry.timestamp > entry.ttl:
                # 🗑️ 期限切れなので削除
                del self.cache[key]
                self.misses += 1
                print(f"⏰ 期限切れキャッシュ削除: {key}")
                return default
            
            # 📊 アクセス統計更新
            entry.access_count += 1
            entry.last_access = current_time
            
            self.hits += 1
            print(f"✅ キャッシュヒット: {key} (使用回数: {entry.access_count})")
            return entry.data
    
    def set(self, key: str, value: Any, ttl: Optional[int] = None) -> None:
        """キャッシュ設定（冷蔵庫に食材を保存）"""
        with self._lock:
            cache_ttl = ttl or self.default_ttl
            current_time = time.time()
            
            # 🏠 容量チェック（冷蔵庫が満杯なら古い物を捨てる）
            if len(self.cache) >= self.max_size and key not in self.cache:
                self._evict_lru()
            
            self.cache[key] = CacheEntry(
                data=value,
                timestamp=current_time,
                ttl=cache_ttl,
                last_access=current_time
            )
            print(f"💾 キャッシュ保存: {key} (TTL: {cache_ttl}秒)")
    
    def delete(self, key: str) -> bool:
        """キャッシュ削除（特定の食材を捨てる）"""
        with self._lock:
            if key in self.cache:
                del self.cache[key]
                print(f"🗑️ キャッシュ削除: {key}")
                return True
            return False
    
    def clear(self) -> None:
        """全キャッシュクリア（冷蔵庫を空にする）"""
        with self._lock:
            self.cache.clear()
            self.hits = 0
            self.misses = 0
            self.evictions = 0
            print("🧹 全キャッシュクリア完了")
    
    def get_or_fetch(
        self, 
        key: str, 
        fetch_func: Callable[[], Any],  # データ取得関数（料理を作る関数）
        ttl: Optional[int] = None
    ) -> Any:
        """キャッシュ取得または新規取得（冷蔵庫確認→なければ作って保存）"""
        
        # 🔍 まずキャッシュを確認
        cached_value = self.get(key)
        if cached_value is not None:
            return cached_value
        
        # 📭 キャッシュにないので新規取得
        print(f"🔄 新規データ取得: {key}")
        fresh_value = fetch_func()
        
        # 💾 取得したデータをキャッシュに保存
        self.set(key, fresh_value, ttl)
        return fresh_value
    
    def _evict_lru(self) -> None:
        """LRU削除（最も使われていない古いデータを削除）"""
        if not self.cache:
            return
        
        # 📊 最後のアクセス時刻が最も古いものを見つける
        oldest_key = min(
            self.cache.keys(),
            key=lambda k: self.cache[k].last_access or 0
        )
        
        del self.cache[oldest_key]
        self.evictions += 1
        print(f"🗑️ LRU削除: {oldest_key} (容量確保のため)")
    
    def get_statistics(self) -> Dict[str, Any]:
        """キャッシュ統計情報取得（冷蔵庫の使用状況レポート）"""
        total_requests = self.hits + self.misses
        hit_rate = (self.hits / total_requests * 100) if total_requests > 0 else 0
        
        return {
            "hit_rate": round(hit_rate, 2),
            "hits": self.hits,
            "misses": self.misses,
            "evictions": self.evictions,
            "current_size": len(self.cache),
            "max_size": self.max_size,
            "efficiency": "excellent" if hit_rate > 80 else
                         "good" if hit_rate > 60 else
                         "needs_improvement"
        }
    
    def cleanup_expired(self) -> int:
        """期限切れキャッシュ一括削除（冷蔵庫の大掃除）"""
        current_time = time.time()
        expired_keys = []
        
        with self._lock:
            for key, entry in self.cache.items():
                if current_time - entry.timestamp > entry.ttl:
                    expired_keys.append(key)
            
            for key in expired_keys:
                del self.cache[key]
        
        print(f"🧹 期限切れ削除: {len(expired_keys)}個")
        return len(expired_keys)

# 🎯 Fletアプリでの実際の使用例
class OptimizedSupabaseClient:
    """最適化されたSupabaseクライアント（高速通信システム）"""
    
    def __init__(self, supabase_client):
        self.client = supabase_client
        self.cache = FletCacheManager(max_size=500, default_ttl=300)  # 5分キャッシュ
    
    async def get_user_projects(self, user_id: str, use_cache: bool = True) -> list:
        """ユーザープロジェクト取得（キャッシュ付き）"""
        
        cache_key = f"user_projects:{user_id}"
        
        if use_cache:
            # 🔄 キャッシュから取得を試行
            return self.cache.get_or_fetch(
                key=cache_key,
                fetch_func=lambda: self._fetch_user_projects(user_id),
                ttl=300  # 5分間キャッシュ
            )
        else:
            # 🌐 直接APIから取得
            return self._fetch_user_projects(user_id)
    
    def _fetch_user_projects(self, user_id: str) -> list:
        """実際のAPI呼び出し（サーバーから新鮮なデータ取得）"""
        print(f"🌐 API呼び出し: ユーザー{user_id}のプロジェクト取得")
        
        response = self.client.table("projects")\
            .select("id, name, status, created_at")\
            .eq("user_id", user_id)\
            .order("created_at", desc=True)\
            .execute()
        
        return response.data
    
    async def get_project_tasks(self, project_id: str, use_cache: bool = True) -> list:
        """プロジェクトタスク取得（キャッシュ付き）"""
        
        cache_key = f"project_tasks:{project_id}"
        
        if use_cache:
            return self.cache.get_or_fetch(
                key=cache_key,
                fetch_func=lambda: self._fetch_project_tasks(project_id),
                ttl=180  # 3分間キャッシュ（タスクは更新頻度が高い）
            )
        else:
            return self._fetch_project_tasks(project_id)
    
    def _fetch_project_tasks(self, project_id: str) -> list:
        """実際のタスクAPI呼び出し"""
        print(f"🌐 API呼び出し: プロジェクト{project_id}のタスク取得")
        
        response = self.client.table("tasks")\
            .select("id, title, status, priority, due_date")\
            .eq("project_id", project_id)\
            .order("priority", desc=True)\
            .execute()
        
        return response.data
    
    def invalidate_user_cache(self, user_id: str):
        """ユーザー関連キャッシュ無効化（データ更新時）"""
        patterns = [
            f"user_projects:{user_id}",
            f"user_profile:{user_id}"
        ]
        
        for pattern in patterns:
            self.cache.delete(pattern)
        
        print(f"♻️ ユーザーキャッシュ無効化: {user_id}")
    
    def get_cache_report(self) -> str:
        """キャッシュレポート生成"""
        stats = self.cache.get_statistics()
        
        return f"""
📊 キャッシュレポート
・ヒット率: {stats['hit_rate']}% ({stats['efficiency']})
・ヒット数: {stats['hits']} / ミス数: {stats['misses']}
・現在の保存数: {stats['current_size']}/{stats['max_size']}
・削除回数: {stats['evictions']}
        """.strip()

# 使用例：Fletアプリでのキャッシュ活用
async def demo_flet_cache():
    """Fletアプリでのキャッシュ使用例"""
    
    # クライアント初期化
    client = OptimizedSupabaseClient(supabase_client)
    
    # 📋 最初のアクセス（APIから取得）
    print("=== 初回アクセス ===")
    projects = await client.get_user_projects("user123")
    print(f"取得結果: {len(projects)}件のプロジェクト")
    
    # 📋 2回目のアクセス（キャッシュから取得）
    print("\n=== 2回目アクセス ===")
    projects = await client.get_user_projects("user123")
    print(f"取得結果: {len(projects)}件のプロジェクト（キャッシュから）")
    
    # 📊 統計レポート表示
    print(client.get_cache_report())

# app/client/optimization/cache_manager.py
import time
import json
import hashlib
from typing import Any, Dict, Optional, Callable
from datetime import datetime, timedelta
from dataclasses import dataclass, asdict
from threading import RLock

@dataclass
class CacheEntry:
    data: Any
    timestamp: float
    ttl: float
    access_count: int = 0
    last_access: float = None

class FletCacheManager:
    """Fletアプリケーション用キャッシュマネージャー"""
    
    def __init__(self, max_size: int = 1000, default_ttl: int = 300):
        self.cache: Dict[str, CacheEntry] = {}
        self.max_size = max_size
        self.default_ttl = default_ttl
        self._lock = RLock()
        
        # 統計情報
        self.hits = 0
        self.misses = 0
        self.evictions = 0
    
    def get(self, key: str, default: Any = None) -> Any:
        """キャッシュ取得"""
        with self._lock:
            if key not in self.cache:
                self.misses += 1
                return default
            
            entry = self.cache[key]
            current_time = time.time()
            
            # TTL チェック
            if current_time - entry.timestamp > entry.ttl:
                del self.cache[key]
                self.misses += 1
                return default
            
            # アクセス統計更新
            entry.access_count += 1
            entry.last_access = current_time
            
            self.hits += 1
            return entry.data
    
    def set(self, key: str, value: Any, ttl: Optional[int] = None) -> None:
        """キャッシュ設定"""
        with self._lock:
            cache_ttl = ttl or self.default_ttl
            current_time = time.time()
            
            # サイズ制限チェック
            if len(self.cache) >= self.max_size and key not in self.cache:
                self._evict_lru()
            
            self.cache[key] = CacheEntry(
                data=value,
                timestamp=current_time,
                ttl=cache_ttl,
                last_access=current_time
            )
    
    def delete(self, key: str) -> bool:
        """キャッシュ削除"""
        with self._lock:
            if key in self.cache:
                del self.cache[key]
                return True
            return False
    
    def clear(self) -> None:
        """全キャッシュクリア"""
        with self._lock:
            self.cache.clear()
            self.hits = 0
            self.misses = 0
            self.evictions = 0
    
    def get_or_fetch(
        self, 
        key: str, 
        fetch_func: Callable[[], Any],
        ttl: Optional[int] = None
    ) -> Any:
        """キャッシュ取得または関数実行"""
        cached_value = self.get(key)
        if cached_value is not None:
            return cached_value
        
        # フェッチして캐시
        fresh_value = fetch_func()
        self.set(key, fresh_value, ttl)
        return fresh_value
    
    def _evict_lru(self) -> None:
        """LRU驺제"""
        if not self.cache:
            return
        
        # 最近最少使用アイテム特定
        lru_key = min(
            self.cache.keys(),
            key=lambda k: (
                self.cache[k].access_count,
                self.cache[k].last_access or 0
            )
        )
        
        del self.cache[lru_key]
        self.evictions += 1
    
    def get_stats(self) -> Dict[str, Any]:
        """統計情報取得"""
        total_requests = self.hits + self.misses
        hit_ratio = (self.hits / total_requests * 100) if total_requests > 0 else 0
        
        return {
            "hits": self.hits,
            "misses": self.misses,
            "hit_ratio": hit_ratio,
            "evictions": self.evictions,
            "cache_size": len(self.cache),
            "max_size": self.max_size
        }

# Fletアプリケーション統合
class OptimizedSupabaseClient:
    """最適化されたSupabaseクライアント"""
    
    def __init__(self, supabase_client, cache_manager: FletCacheManager):
        self.client = supabase_client
        self.cache = cache_manager
    
    async def get_with_cache(
        self, 
        table: str, 
        query_params: Dict[str, Any] = None,
        cache_ttl: int = 300
    ) -> Any:
        """キャッシュ付きクエリ実行"""
        
        # キャッシュキー生成
        cache_key = self._generate_cache_key(table, query_params)
        
        # キャッシュチェック
        cached_result = self.cache.get(cache_key)
        if cached_result is not None:
            return cached_result
        
        # データベースクエリ実行
        query = self.client.table(table).select("*")
        
        if query_params:
            for key, value in query_params.items():
                if key == "eq":
                    for field, val in value.items():
                        query = query.eq(field, val)
                elif key == "in":
                    for field, val in value.items():
                        query = query.in_(field, val)
                elif key == "order":
                    query = query.order(value)
                elif key == "limit":
                    query = query.limit(value)
        
        response = await query.execute()
        
        # 結果をキャッシュ
        if response.data:
            self.cache.set(cache_key, response.data, cache_ttl)
        
        return response.data
    
    def invalidate_table_cache(self, table: str):
        """テーブル関連キャッシュ無効化"""
        keys_to_delete = [
            key for key in self.cache.cache.keys()
            if key.startswith(f"table:{table}")
        ]
        
        for key in keys_to_delete:
            self.cache.delete(key)
    
    def _generate_cache_key(
        self, 
        table: str, 
        query_params: Dict[str, Any] = None
    ) -> str:
        """キャッシュキー生成"""
        key_data = {"table": table}
        
        if query_params:
            key_data["params"] = query_params
        
        key_string = json.dumps(key_data, sort_keys=True)
        key_hash = hashlib.md5(key_string.encode()).hexdigest()
        
        return f"table:{table}:{key_hash}"

# app/client/optimization/realtime_optimizer.py
from typing import Dict, Set, Callable, Any
import asyncio
from datetime import datetime, timedelta

class RealtimeUpdateOptimizer:
    """リアルタイム更新最適化"""
    
    def __init__(self, batch_delay: float = 0.1, max_batch_size: int = 100):
        self.batch_delay = batch_delay
        self.max_batch_size = max_batch_size
        
        # バッチ処理用
        self.pending_updates: Dict[str, Dict[str, Any]] = {}
        self.update_callbacks: Dict[str, Callable] = {}
        self.batch_timer: Optional[asyncio.Task] = None
        
        # 重複除去用
        self.processed_updates: Set[str] = set()
        self.cleanup_interval = 60  # 60秒でクリーンアップ
    
    def register_callback(self, table: str, callback: Callable):
        """テーブル更新コールバック登録"""
        self.update_callbacks[table] = callback
    
    def handle_realtime_update(self, table: str, event_type: str, record: Dict[str, Any]):
        """リアルタイム更新処理"""
        
        # 重複チェック
        update_id = f"{table}:{event_type}:{record.get('id')}:{datetime.utcnow().isoformat()}"
        if update_id in self.processed_updates:
            return
        
        # バッチに追加
        if table not in self.pending_updates:
            self.pending_updates[table] = []
        
        self.pending_updates[table].append({
            "event_type": event_type,
            "record": record,
            "timestamp": datetime.utcnow()
        })
        
        self.processed_updates.add(update_id)
        
        # バッチサイズチェック
        if len(self.pending_updates[table]) >= self.max_batch_size:
            asyncio.create_task(self._process_batch(table))
        else:
            # 遅延バッチ処理開始
            if self.batch_timer is None or self.batch_timer.done():
                self.batch_timer = asyncio.create_task(self._delayed_batch_process())
    
    async def _delayed_batch_process(self):
        """遅延バッチ処理"""
        await asyncio.sleep(self.batch_delay)
        
        # すべてのテーブルのバッチ処理
        for table in list(self.pending_updates.keys()):
            if self.pending_updates[table]:
                await self._process_batch(table)
    
    async def _process_batch(self, table: str):
        """バッチ処理実行"""
        if table not in self.pending_updates or not self.pending_updates[table]:
            return
        
        updates = self.pending_updates[table].copy()
        self.pending_updates[table] = []
        
        # 更新を種類別にグループ化
        grouped_updates = {
            "INSERT": [],
            "UPDATE": [],
            "DELETE": []
        }
        
        for update in updates:
            event_type = update["event_type"]
            if event_type in grouped_updates:
                grouped_updates[event_type].append(update)
        
        # コールバック実行
        if table in self.update_callbacks:
            try:
                await self.update_callbacks[table](grouped_updates)
            except Exception as e:
                print(f"Error in realtime callback for {table}: {e}")
    
    def cleanup_processed_updates(self):
        """処理済み更新履歴クリーンアップ"""
        # 古い履歴を削除（メモリ使用量制御）
        cutoff_time = datetime.utcnow() - timedelta(seconds=self.cleanup_interval)
        # 実装簡略化のため、定期的に全クリア
        if len(self.processed_updates) > 10000:
            self.processed_updates.clear()

# UI更新最適化
class UIUpdateBatcher:
    """UI更新バッチ処理"""
    
    def __init__(self, update_interval: float = 0.016):  # 60FPS
        self.update_interval = update_interval
        self.pending_ui_updates: Set[Callable] = set()
        self.update_timer: Optional[asyncio.Task] = None
    
    def schedule_ui_update(self, update_func: Callable):
        """UI更新スケジュール"""
        self.pending_ui_updates.add(update_func)
        
        if self.update_timer is None or self.update_timer.done():
            self.update_timer = asyncio.create_task(self._process_ui_updates())
    
    async def _process_ui_updates(self):
        """UI更新処理"""
        await asyncio.sleep(self.update_interval)
        
        updates_to_process = self.pending_ui_updates.copy()
        self.pending_ui_updates.clear()
        
        # UI更新実行
        for update_func in updates_to_process:
            try:
                if asyncio.iscoroutinefunction(update_func):
                    await update_func()
                else:
                    update_func()
            except Exception as e:
                print(f"Error in UI update: {e}")

# app/monitoring/performance_tracker.py
import time
import psutil
import statistics
from typing import Dict, List, Any, Optional
from dataclasses import dataclass, field
from datetime import datetime, timedelta
from collections import deque, defaultdict

@dataclass
class PerformanceMetric:
    name: str
    value: float
    timestamp: datetime
    tags: Dict[str, str] = field(default_factory=dict)

@dataclass
class QueryPerformance:
    query: str
    duration: float
    rows_affected: int
    timestamp: datetime
    success: bool
    error_message: str = None

class PerformanceTracker:
    """パフォーマンス追跡システム"""
    
    def __init__(self, max_history: int = 10000):
        self.max_history = max_history
        
        # メトリクス履歴
        self.metrics_history: deque = deque(maxlen=max_history)
        self.query_history: deque = deque(maxlen=max_history)
        
        # 統計情報
        self.response_times: defaultdict = defaultdict(lambda: deque(maxlen=1000))
        self.error_counts: defaultdict = defaultdict(int)
        self.request_counts: defaultdict = defaultdict(int)
        
        # システムリソース
        self.system_metrics: deque = deque(maxlen=1000)
        
        # アラート閾値
        self.alert_thresholds = {
            "response_time_p95": 2.0,  # 2秒
            "error_rate": 0.05,        # 5%
            "cpu_usage": 80.0,         # 80%
            "memory_usage": 85.0       # 85%
        }
    
    def record_request(
        self, 
        endpoint: str, 
        method: str, 
        duration: float, 
        status_code: int,
        user_id: Optional[str] = None
    ):
        """リクエスト記録"""
        
        # 基本統計
        key = f"{method}:{endpoint}"
        self.response_times[key].append(duration)
        self.request_counts[key] += 1
        
        if status_code >= 400:
            self.error_counts[key] += 1
        
        # 詳細メトリクス
        metric = PerformanceMetric(
            name="http_request",
            value=duration,
            timestamp=datetime.utcnow(),
            tags={
                "endpoint": endpoint,
                "method": method,
                "status_code": str(status_code),
                "user_id": user_id or "anonymous"
            }
        )
        
        self.metrics_history.append(metric)
        
        # アラートチェック
        self._check_response_time_alert(key, duration)
        self._check_error_rate_alert(key)
    
    def record_query(
        self, 
        query: str, 
        duration: float, 
        rows_affected: int = 0,
        success: bool = True,
        error_message: str = None
    ):
        """データベースクエリ記録"""
        
        query_perf = QueryPerformance(
            query=query[:500],  # クエリを500文字で切断
            duration=duration,
            rows_affected=rows_affected,
            timestamp=datetime.utcnow(),
            success=success,
            error_message=error_message
        )
        
        self.query_history.append(query_perf)
        
        # スロークエリ監視
        if duration > 1.0:  # 1秒以上
            self._trigger_slow_query_alert(query_perf)
    
    def collect_system_metrics(self):
        """システムメトリクス収集"""
        
        # CPU使用率
        cpu_percent = psutil.cpu_percent(interval=1)
        
        # メモリ使用率
        memory = psutil.virtual_memory()
        memory_percent = memory.percent
        
        # ディスク使用率
        disk = psutil.disk_usage('/')
        disk_percent = disk.percent
        
        # ネットワークI/O
        network = psutil.net_io_counters()
        
        system_metric = {
            "cpu_percent": cpu_percent,
            "memory_percent": memory_percent,
            "memory_used_mb": memory.used / 1024 / 1024,
            "disk_percent": disk_percent,
            "network_bytes_sent": network.bytes_sent,
            "network_bytes_recv": network.bytes_recv,
            "timestamp": datetime.utcnow()
        }
        
        self.system_metrics.append(system_metric)
        
        # システムアラートチェック
        self._check_system_alerts(system_metric)
        
        return system_metric
    
    def get_performance_summary(self, hours: int = 24) -> Dict[str, Any]:
        """パフォーマンス要約取得"""
        
        cutoff_time = datetime.utcnow() - timedelta(hours=hours)
        
        # 期間内のメトリクス
        recent_metrics = [
            m for m in self.metrics_history 
            if m.timestamp >= cutoff_time
        ]
        
        recent_queries = [
            q for q in self.query_history 
            if q.timestamp >= cutoff_time
        ]
        
        # レスポンス時間統計
        response_time_stats = {}
        for endpoint, times in self.response_times.items():
            if times:
                response_time_stats[endpoint] = {
                    "count": len(times),
                    "avg": statistics.mean(times),
                    "p50": statistics.median(times),
                    "p95": self._percentile(times, 95),
                    "p99": self._percentile(times, 99),
                    "max": max(times)
                }
        
        # エラー率
        error_rates = {}
        for endpoint in self.request_counts:
            total_requests = self.request_counts[endpoint]
            error_count = self.error_counts[endpoint]
            error_rates[endpoint] = (error_count / total_requests) if total_requests > 0 else 0
        
        # 最遅クエリ
        slowest_queries = sorted(recent_queries, key=lambda q: q.duration, reverse=True)[:10]
        
        # システムリソース統計
        if self.system_metrics:
            recent_system = [m for m in self.system_metrics if m["timestamp"] >= cutoff_time]
            system_stats = {
                "avg_cpu": statistics.mean([m["cpu_percent"] for m in recent_system]),
                "max_cpu": max([m["cpu_percent"] for m in recent_system]),
                "avg_memory": statistics.mean([m["memory_percent"] for m in recent_system]),
                "max_memory": max([m["memory_percent"] for m in recent_system])
            } if recent_system else {}
        else:
            system_stats = {}
        
        return {
            "period_hours": hours,
            "total_requests": len(recent_metrics),
            "total_queries": len(recent_queries),
            "response_time_stats": response_time_stats,
            "error_rates": error_rates,
            "slowest_queries": [
                {
                    "query": q.query,
                    "duration": q.duration,
                    "timestamp": q.timestamp.isoformat()
                } for q in slowest_queries
            ],
            "system_stats": system_stats,
            "generated_at": datetime.utcnow().isoformat()
        }
    
    def _percentile(self, data: List[float], percentile: int) -> float:
        """パーセンタイル計算"""
        if not data:
            return 0
        
        sorted_data = sorted(data)
        index = (percentile / 100) * (len(sorted_data) - 1)
        
        if index.is_integer():
            return sorted_data[int(index)]
        else:
            lower = sorted_data[int(index)]
            upper = sorted_data[int(index) + 1]
            return lower + (upper - lower) * (index - int(index))
    
    def _check_response_time_alert(self, endpoint: str, duration: float):
        """レスポンス時間アラートチェック"""
        if duration > self.alert_thresholds["response_time_p95"]:
            self._send_alert(
                f"Slow response detected: {endpoint}",
                f"Response time: {duration:.2f}s (threshold: {self.alert_thresholds['response_time_p95']}s)"
            )
    
    def _check_error_rate_alert(self, endpoint: str):
        """エラー率アラートチェック"""
        total_requests = self.request_counts[endpoint]
        error_count = self.error_counts[endpoint]
        
        if total_requests >= 10:  # 最低10リクエストで判定
            error_rate = error_count / total_requests
            if error_rate > self.alert_thresholds["error_rate"]:
                self._send_alert(
                    f"High error rate detected: {endpoint}",
                    f"Error rate: {error_rate:.2%} (threshold: {self.alert_thresholds['error_rate']:.2%})"
                )
    
    def _check_system_alerts(self, system_metric: Dict[str, Any]):
        """システムアラートチェック"""
        if system_metric["cpu_percent"] > self.alert_thresholds["cpu_usage"]:
            self._send_alert(
                "High CPU usage detected",
                f"CPU usage: {system_metric['cpu_percent']:.1f}%"
            )
        
        if system_metric["memory_percent"] > self.alert_thresholds["memory_usage"]:
            self._send_alert(
                "High memory usage detected",
                f"Memory usage: {system_metric['memory_percent']:.1f}%"
            )
    
    def _trigger_slow_query_alert(self, query_perf: QueryPerformance):
        """スロークエリアラート"""
        self._send_alert(
            "Slow query detected",
            f"Query: {query_perf.query[:100]}...\nDuration: {query_perf.duration:.2f}s"
        )
    
    def _send_alert(self, title: str, message: str):
        """アラート送信"""
        # 実際の実装では外部アラートシステムに送信
        print(f"ALERT: {title}\n{message}")

# グローバルパフォーマンストラッカー
performance_tracker = PerformanceTracker()