src/db/supabase_adapter.py

"""
Supabase Adapter
================

Supabase(PostgreSQL + pgvector) 연동 어댑터.
호텔 로열티 데이터의 저장 및 벡터 검색을 담당합니다.

테이블 구조 (supabase/migrations/20260109_001_kb_schema.sql 참조):
- kb_documents: 문서 메타데이터 + extracted_knowledge (JSONB)
- kb_chunks: 청크 텍스트 + 벡터 임베딩 (pgvector 768차원)
"""

import os
import json
from typing import Dict, Any, List, Optional
from datetime import datetime, timezone
from dotenv import load_dotenv

load_dotenv()


class SupabaseAdapter:
    """
    Supabase 데이터베이스 어댑터.
    
    환경변수:
        SUPABASE_URL: Supabase 프로젝트 URL
        SUPABASE_KEY: Supabase anon/service_role 키
    """
    
    def __init__(
        self,
        url: Optional[str] = None,
        key: Optional[str] = None
    ):
        """
        Args:
            url: Supabase URL (없으면 환경변수에서 로드)
            key: Supabase API Key (없으면 환경변수에서 로드)
        """
        from supabase import create_client, Client
        
        self.url = url or os.getenv("SUPABASE_URL")
        self.key = key or os.getenv("SUPABASE_KEY")
        
        if not self.url or not self.key:
            raise ValueError(
                "SUPABASE_URL과 SUPABASE_KEY가 필요합니다. "
                "로컬: .env 파일을 확인하세요. "
                "HF Space: Settings > Repository secrets에 설정하세요."
            )
        
        self.client: Client = create_client(self.url, self.key)
        self._embeddings = None
    
    @property
    def embeddings(self):
        """Lazy 로딩된 임베딩 생성기. EMBEDDING_MODEL 환경변수로 선택."""
        if self._embeddings is None:
            embedding_model = os.getenv("EMBEDDING_MODEL", "bge-m3").lower()
            
            if embedding_model == "gemini":
                from .embeddings import GeminiEmbeddings
                self._embeddings = GeminiEmbeddings()
            else:  # 기본값: bge-m3
                from .bge_embeddings import BGEEmbeddings
                self._embeddings = BGEEmbeddings()
        
        return self._embeddings
    
    # =========================================================================
    # 문서 저장 (kb_documents 테이블)
    # =========================================================================
    
    def upsert_knowledge(
        self,
        doc_id: str,
        chain: str,
        source_file: str,
        identity: Dict[str, Any],
        extracted_knowledge: Dict[str, Any],
        source_info: Optional[Dict[str, Any]] = None,
        version_info: Optional[Dict[str, Any]] = None
    ) -> Dict[str, Any]:
        """
        추출된 지식을 Supabase에 저장/업데이트.
        
        Args:
            doc_id: 고유 문서 ID
            chain: 호텔 체인 (IHG, MARRIOTT, ACCOR 등)
            source_file: 소스 파일 경로
            identity: 문서 identity 메타데이터
            extracted_knowledge: 추출된 지식 (JSONB)
            source_info: 소스 정보 (선택적)
            version_info: 버전 정보 (선택적)
            
        Returns:
            저장된 레코드
        """
        record = {
            "doc_id": doc_id,
            "chain": chain,
            "source_file": source_file,
            "identity": json.dumps(identity, ensure_ascii=False),
            "extracted_knowledge": json.dumps(extracted_knowledge, ensure_ascii=False),
            "source_info": json.dumps(source_info or {}, ensure_ascii=False),
            "version_info": json.dumps(version_info or {}, ensure_ascii=False),
            "updated_at": datetime.now(timezone.utc).isoformat()
        }
        
        try:
            result = self.client.table("kb_documents").upsert(
                record,
                on_conflict="doc_id"
            ).execute()
            
            return result.data[0] if result.data else record
            
        except Exception as e:
            raise RuntimeError(f"문서 저장 실패 ({doc_id}): {e}") from e
    
    def get_knowledge(self, doc_id: str) -> Optional[Dict[str, Any]]:
        """문서 조회"""
        try:
            result = self.client.table("kb_documents")\
                .select("*")\
                .eq("doc_id", doc_id)\
                .execute()
            
            if result.data:
                record = result.data[0]
                # JSONB 필드 파싱
                for field in ["identity", "extracted_knowledge", "source_info", "version_info"]:
                    if field in record and isinstance(record[field], str):
                        record[field] = json.loads(record[field])
                return record
            return None
            
        except Exception as e:
            raise RuntimeError(f"문서 조회 실패 ({doc_id}): {e}") from e
    
    def list_documents(self, chain: Optional[str] = None) -> List[Dict[str, Any]]:
        """문서 목록 조회"""
        try:
            query = self.client.table("kb_documents").select("doc_id, chain, source_file, updated_at")
            
            if chain:
                query = query.eq("chain", chain.upper())
            
            result = query.execute()
            return result.data or []
            
        except Exception as e:
            raise RuntimeError(f"문서 목록 조회 실패: {e}") from e
    
    # =========================================================================
    # 청크 저장 (kb_chunks 테이블 + pgvector)
    # =========================================================================
    
    def upsert_chunks(
        self,
        chunks: List[Dict[str, Any]],
        generate_embeddings: bool = True
    ) -> int:
        """
        텍스트 청크를 벡터 임베딩과 함께 저장.
        
        Args:
            chunks: 청크 리스트. 각 청크는 다음 필드 포함:
                - chunk_id: 고유 ID
                - doc_id: 부모 문서 ID
                - chain: 호텔 체인
                - content: 청크 텍스트
                - metadata: 추가 메타데이터 (선택적)
            generate_embeddings: 임베딩 생성 여부
            
        Returns:
            저장된 청크 수
        """
        if not chunks:
            return 0
        
        records = []
        
        for chunk in chunks:
            record = {
                "chunk_id": chunk["chunk_id"],
                "doc_id": chunk["doc_id"],
                "chain": chunk.get("chain", "UNKNOWN"),
                "chunk_type": chunk.get("metadata", {}).get("type"),
                "content": chunk["content"],
                "metadata": json.dumps(chunk.get("metadata", {}), ensure_ascii=False),
                "updated_at": datetime.now(timezone.utc).isoformat()
            }
            
            # 임베딩 생성
            if generate_embeddings and chunk["content"]:
                try:
                    embedding = self.embeddings.embed_text(chunk["content"])
                    record["embedding"] = embedding
                except Exception as e:
                    print(f"⚠️ 임베딩 생성 실패 ({chunk['chunk_id']}): {e}")
                    record["embedding"] = None
            
            records.append(record)
        
        # 배치 처리 (Supabase timeout 방지)
        BATCH_SIZE = 30  # 50 → 30으로 줄여 안정성 향상
        MAX_RETRIES = 3
        BATCH_DELAY = 0.5  # 배치 간 0.5초 딜레이
        total_saved = 0
        
        import time
        
        try:
            for i in range(0, len(records), BATCH_SIZE):
                batch = records[i:i + BATCH_SIZE]
                
                # 재시도 로직
                for attempt in range(MAX_RETRIES):
                    try:
                        result = self.client.table("kb_chunks").upsert(
                            batch,
                            on_conflict="chunk_id"
                        ).execute()
                        
                        batch_saved = len(result.data) if result.data else len(batch)
                        total_saved += batch_saved
                        break  # 성공 시 재시도 루프 종료
                        
                    except Exception as e:
                        if attempt < MAX_RETRIES - 1:
                            print(f"   ⚠️ 배치 저장 실패 (시도 {attempt + 1}/{MAX_RETRIES}), 재시도 중...")
                            time.sleep(2)  # 재시도 전 2초 대기
                        else:
                            raise  # 마지막 시도 실패 시 예외 전파
                
                # 진행 상황 출력 (100개마다)
                if (i + BATCH_SIZE) % 100 == 0 or i + BATCH_SIZE >= len(records):
                    print(f"   💾 {min(i + BATCH_SIZE, len(records))}/{len(records)} 청크 저장 완료")
                
                # 배치 간 딜레이 (서버 연결 유지)
                if i + BATCH_SIZE < len(records):
                    time.sleep(BATCH_DELAY)
            
            return total_saved
            
        except Exception as e:
            raise RuntimeError(f"청크 저장 실패: {e}") from e
    
    # =========================================================================
    # 벡터 검색 (Semantic Search)
    # =========================================================================
    
    def search_similar(
        self,
        query: str,
        limit: int = 5,
        chain: Optional[str] = None,
        threshold: float = 0.5
    ) -> List[Dict[str, Any]]:
        """
        쿼리와 유사한 청크를 벡터 검색.
        
        Args:
            query: 검색 쿼리
            limit: 반환할 최대 결과 수
            chain: 특정 체인으로 필터링 (선택적)
            threshold: 최소 유사도 임계값 (0-1)
            
        Returns:
            유사한 청크 리스트 (유사도 점수 포함)
        """
        # 쿼리 임베딩 생성
        query_embedding = self.embeddings.embed_query(query)
        
        try:
            # Supabase RPC 함수 호출 (pgvector match_documents)
            # 주의: 이 함수는 Supabase에서 별도로 생성해야 함
            result = self.client.rpc(
                "match_kb_chunks",
                {
                    "query_embedding": query_embedding,
                    "match_threshold": threshold,
                    "match_count": limit,
                    "filter_chain": chain
                }
            ).execute()
            
            return result.data or []
            
        except Exception as e:
            # RPC 함수가 없는 경우 대체 방법 (비효율적)
            print(f"⚠️ match_kb_chunks RPC 함수를 찾을 수 없습니다: {e}")
            print("   supabase/migrations/20260109_001_kb_schema.sql을 참조하세요.")
            return []
    
    # =========================================================================
    # 유틸리티
    # =========================================================================
    
    def health_check(self) -> Dict[str, Any]:
        """연결 상태 확인"""
        try:
            # 간단한 쿼리로 연결 테스트
            result = self.client.table("kb_documents")\
                .select("count", count="exact")\
                .limit(1)\
                .execute()
            
            return {
                "status": "healthy",
                "documents_count": result.count,
                "url": self.url[:30] + "..."
            }
        except Exception as e:
            return {
                "status": "error",
                "error": str(e)
            }
    
    def get_stats(self) -> Dict[str, Any]:
        """데이터베이스 통계"""
        try:
            docs = self.client.table("kb_documents")\
                .select("chain", count="exact")\
                .execute()
            
            chunks = self.client.table("kb_chunks")\
                .select("chain", count="exact")\
                .execute()
            
            return {
                "documents": docs.count or 0,
                "chunks": chunks.count or 0
            }
        except Exception as e:
            return {"error": str(e)}
    
    # =========================================================================
    # 사용자 프로필 (User Gate)
    # =========================================================================
    
    def get_user_profile(self, user_id: str) -> Optional[Dict[str, Any]]:
        """
        사용자 프로필 조회.
        
        Args:
            user_id: Supabase Auth UUID
            
        Returns:
            프로필 정보 또는 None
        """
        try:
            result = self.client.table("user_profiles")\
                .select("*")\
                .eq("user_id", user_id)\
                .execute()
            
            return result.data[0] if result.data else None
        except Exception as e:
            print(f"⚠️ 프로필 조회 실패 ({user_id}): {e}")
            return None
    
    def upsert_user_profile(
        self, 
        user_id: str, 
        preferred_airports: List[str] = None,
        display_name: str = None
    ) -> Optional[Dict[str, Any]]:
        """
        사용자 프로필 생성/수정.
        
        Args:
            user_id: Supabase Auth UUID
            preferred_airports: 선호 공항 코드 리스트
            display_name: 표시 이름
            
        Returns:
            저장된 프로필 또는 None
        """
        try:
            data = {"user_id": user_id}
            if preferred_airports is not None:
                data["preferred_airports"] = preferred_airports
            if display_name is not None:
                data["display_name"] = display_name
            
            result = self.client.table("user_profiles")\
                .upsert(data, on_conflict="user_id")\
                .execute()
            
            return result.data[0] if result.data else None
        except Exception as e:
            print(f"⚠️ 프로필 저장 실패 ({user_id}): {e}")
            return None
    
    # =========================================================================
    # 멤버십 (User Gate)
    # =========================================================================
    
    def get_user_memberships(self, user_id: str) -> List[Dict[str, Any]]:
        """
        사용자의 모든 멤버십 조회.
        
        Args:
            user_id: Supabase Auth UUID
            
        Returns:
            멤버십 리스트
        """
        try:
            result = self.client.table("user_memberships")\
                .select("*")\
                .eq("user_id", user_id)\
                .execute()
            
            return result.data or []
        except Exception as e:
            print(f"⚠️ 멤버십 조회 실패 ({user_id}): {e}")
            return []
    
    def upsert_membership(
        self,
        user_id: str,
        chain: str,
        tier: str,
        expires_at: str = None
    ) -> Optional[Dict[str, Any]]:
        """
        멤버십 등록/수정.
        
        Args:
            user_id: Supabase Auth UUID
            chain: 호텔 체인 코드 (HILTON, MARRIOTT 등)
            tier: 등급 (Gold, Platinum 등)
            expires_at: 만료일 (선택, YYYY-MM-DD)
            
        Returns:
            저장된 멤버십 또는 None
        """
        try:
            data = {
                "user_id": user_id,
                "chain": chain.upper(),
                "tier": tier
            }
            if expires_at:
                data["expires_at"] = expires_at
            
            # user_id + chain 복합키로 upsert
            # Supabase는 on_conflict에 복합키를 직접 지원하지 않으므로
            # 먼저 삭제 후 삽입하는 방식 사용
            self.client.table("user_memberships")\
                .delete()\
                .eq("user_id", user_id)\
                .eq("chain", chain.upper())\
                .execute()
            
            result = self.client.table("user_memberships")\
                .insert(data)\
                .execute()
            
            return result.data[0] if result.data else None
        except Exception as e:
            print(f"⚠️ 멤버십 저장 실패 ({user_id}, {chain}): {e}")
            return None
    
    def delete_membership(self, user_id: str, chain: str) -> bool:
        """
        멤버십 삭제.
        
        Args:
            user_id: Supabase Auth UUID
            chain: 호텔 체인 코드
            
        Returns:
            삭제 성공 여부
        """
        try:
            self.client.table("user_memberships")\
                .delete()\
                .eq("user_id", user_id)\
                .eq("chain", chain.upper())\
                .execute()
            
            return True
        except Exception as e:
            print(f"⚠️ 멤버십 삭제 실패 ({user_id}, {chain}): {e}")
            return False
    
    # =========================================================================
    # 신용카드 (Credit Cards)
    # =========================================================================
    
    def get_user_credit_cards(self, user_id: str) -> List[Dict[str, Any]]:
        """
        사용자의 보유 신용카드 목록 조회.
        
        Args:
            user_id: Supabase Auth UUID
            
        Returns:
            신용카드 리스트
        """
        try:
            result = self.client.table("user_credit_cards")\
                .select("*")\
                .eq("user_id", user_id)\
                .eq("is_active", True)\
                .order("created_at")\
                .execute()
            
            return result.data or []
        except Exception as e:
            print(f"⚠️ 신용카드 조회 실패 ({user_id}): {e}")
            return []
    
    def upsert_credit_card(
        self,
        user_id: str,
        card_id: str,
        card_name: str,
        issuer_code: str,
        region: str = "USA",
        card_open_date: str = None,
        anniversary_month: int = None,
        annual_fee: float = None
    ) -> Optional[Dict[str, Any]]:
        """
        신용카드 등록/수정.
        
        Args:
            user_id: Supabase Auth UUID
            card_id: 카드 고유 ID (AMEX_PLATINUM_US 등)
            card_name: 카드 이름
            issuer_code: 발급사 코드
            region: 발급 국가
            card_open_date: 카드 개설일 (YYYY-MM-DD)
            anniversary_month: 연회비 갱신 월 (1-12)
            annual_fee: 연회비
            
        Returns:
            저장된 카드 정보 또는 None
        """
        try:
            data = {
                "user_id": user_id,
                "card_id": card_id.upper(),
                "card_name": card_name,
                "issuer_code": issuer_code.upper(),
                "region": region.upper(),
                "is_active": True
            }
            
            if card_open_date:
                data["card_open_date"] = card_open_date
            if anniversary_month:
                data["anniversary_month"] = anniversary_month
            if annual_fee is not None:
                data["annual_fee_amount"] = annual_fee
            
            # user_id + card_id 복합키로 upsert
            self.client.table("user_credit_cards")\
                .delete()\
                .eq("user_id", user_id)\
                .eq("card_id", card_id.upper())\
                .execute()
            
            result = self.client.table("user_credit_cards")\
                .insert(data)\
                .execute()
            
            return result.data[0] if result.data else None
        except Exception as e:
            print(f"⚠️ 신용카드 저장 실패 ({user_id}, {card_id}): {e}")
            return None
    
    def delete_credit_card(self, user_id: str, card_id: str) -> bool:
        """
        신용카드 삭제 (soft delete - is_active = False).
        
        Args:
            user_id: Supabase Auth UUID
            card_id: 카드 고유 ID
            
        Returns:
            삭제 성공 여부
        """
        try:
            self.client.table("user_credit_cards")\
                .update({"is_active": False})\
                .eq("user_id", user_id)\
                .eq("card_id", card_id.upper())\
                .execute()
            
            return True
        except Exception as e:
            print(f"⚠️ 신용카드 삭제 실패 ({user_id}, {card_id}): {e}")
            return False
    
    # =========================================================================
    # 크레딧 사용 추적 (Credit Usage Tracking)
    # =========================================================================
    
    def get_user_credit_usage(
        self, 
        user_id: str, 
        card_id: str = None,
        benefit_id: str = None
    ) -> List[Dict[str, Any]]:
        """
        사용자의 크레딧 사용 기록 조회.
        
        Args:
            user_id: Supabase Auth UUID
            card_id: 특정 카드로 필터링 (선택)
            benefit_id: 특정 혜택으로 필터링 (선택)
            
        Returns:
            사용 기록 리스트
        """
        try:
            query = self.client.table("user_credit_usage")\
                .select("*")\
                .eq("user_id", user_id)
            
            if card_id:
                query = query.eq("card_id", card_id.upper())
            if benefit_id:
                query = query.eq("benefit_id", benefit_id.lower())
            
            result = query.order("usage_period", desc=True).execute()
            
            return result.data or []
        except Exception as e:
            print(f"⚠️ 크레딧 사용 조회 실패 ({user_id}): {e}")
            return []
    
    def upsert_credit_usage(
        self,
        user_id: str,
        card_id: str,
        benefit_id: str,
        usage_period: str,
        amount_used: float,
        amount_limit: float,
        currency: str = "USD",
        usage_date: str = None,
        description: str = None
    ) -> Optional[Dict[str, Any]]:
        """
        크레딧 사용 기록 저장/수정.
        
        Args:
            user_id: Supabase Auth UUID
            card_id: 카드 ID
            benefit_id: 혜택 ID
            usage_period: 사용 기간 (2026-H1, 2026-Q1, 2026-01 등)
            amount_used: 사용 금액
            amount_limit: 한도 금액
            currency: 통화
            usage_date: 실제 사용일 (YYYY-MM-DD)
            description: 사용 내역
            
        Returns:
            저장된 기록 또는 None
        """
        try:
            data = {
                "user_id": user_id,
                "card_id": card_id.upper(),
                "benefit_id": benefit_id.lower(),
                "usage_period": usage_period,
                "amount_used": amount_used,
                "amount_limit": amount_limit,
                "currency": currency
            }
            
            if usage_date:
                data["usage_date"] = usage_date
            if description:
                data["description"] = description
            
            # user_id + card_id + benefit_id + usage_period 복합키로 upsert
            self.client.table("user_credit_usage")\
                .delete()\
                .eq("user_id", user_id)\
                .eq("card_id", card_id.upper())\
                .eq("benefit_id", benefit_id.lower())\
                .eq("usage_period", usage_period)\
                .execute()
            
            result = self.client.table("user_credit_usage")\
                .insert(data)\
                .execute()
            
            return result.data[0] if result.data else None
        except Exception as e:
            print(f"⚠️ 크레딧 사용 저장 실패 ({user_id}, {card_id}, {benefit_id}): {e}")
            return None
    
    def delete_credit_usage(
        self, 
        user_id: str, 
        card_id: str, 
        benefit_id: str, 
        usage_period: str
    ) -> bool:
        """
        크레딧 사용 기록 삭제.
        
        Args:
            user_id: Supabase Auth UUID
            card_id: 카드 ID
            benefit_id: 혜택 ID
            usage_period: 사용 기간
            
        Returns:
            삭제 성공 여부
        """
        try:
            self.client.table("user_credit_usage")\
                .delete()\
                .eq("user_id", user_id)\
                .eq("card_id", card_id.upper())\
                .eq("benefit_id", benefit_id.lower())\
                .eq("usage_period", usage_period)\
                .execute()
            
            return True
        except Exception as e:
            print(f"⚠️ 크레딧 사용 삭제 실패: {e}")
            return False

    # =========================================================================
    # Valuation Preferences (가치 평가 설정)
    # =========================================================================
    
    def get_valuation_preferences(self, user_id: str) -> Optional[Dict[str, Any]]:
        """
        사용자의 가치 평가 설정 조회.
        
        Args:
            user_id: Supabase Auth UUID
            
        Returns:
            설정 정보 또는 None
        """
        try:
            result = self.client.table("user_valuation_preferences")\
                .select("*")\
                .eq("user_id", user_id)\
                .execute()
            
            return result.data[0] if result.data else None
        except Exception as e:
            print(f"⚠️ 가치 평가 설정 조회 실패 ({user_id}): {e}")
            return None
    
    def upsert_valuation_preferences(
        self,
        user_id: str,
        travel_style: str = "VALUE",
        custom_valuations: Optional[Dict[str, float]] = None
    ) -> Optional[Dict[str, Any]]:
        """
        사용자의 가치 평가 설정 저장 (Upsert).
        
        Args:
            user_id: Supabase Auth UUID
            travel_style: 여행 스타일 (PREMIUM, VALUE, CASHBACK)
            custom_valuations: 개별 프로그램 가치 오버라이드
            
        Returns:
            저장된 설정 또는 None
        """
        try:
            data = {
                "user_id": user_id,
                "travel_style": travel_style.upper(),
                "custom_valuations": custom_valuations or {}
            }
            
            # user_id UNIQUE 제약으로 upsert
            self.client.table("user_valuation_preferences")\
                .delete()\
                .eq("user_id", user_id)\
                .execute()
            
            result = self.client.table("user_valuation_preferences")\
                .insert(data)\
                .execute()
            
            return result.data[0] if result.data else None
        except Exception as e:
            print(f"⚠️ 가치 평가 설정 저장 실패 ({user_id}): {e}")
            return None


# =============================================================================
# Supabase SQL 설정 (참고용)
# =============================================================================
SUPABASE_SETUP_SQL = """
-- 1. pgvector 확장 활성화
CREATE EXTENSION IF NOT EXISTS vector;

-- 2. knowledge_documents 테이블
CREATE TABLE IF NOT EXISTS knowledge_documents (
    id SERIAL PRIMARY KEY,
    doc_id TEXT UNIQUE NOT NULL,
    chain TEXT NOT NULL,
    source_file TEXT,
    identity JSONB,
    extracted_knowledge JSONB,
    source_info JSONB,
    version_info JSONB,
    created_at TIMESTAMPTZ DEFAULT NOW(),
    updated_at TIMESTAMPTZ DEFAULT NOW()
);

CREATE INDEX idx_knowledge_chain ON knowledge_documents(chain);
CREATE INDEX idx_knowledge_doc_id ON knowledge_documents(doc_id);

-- 3. doc_chunks 테이블 (벡터 저장)
CREATE TABLE IF NOT EXISTS doc_chunks (
    id SERIAL PRIMARY KEY,
    chunk_id TEXT UNIQUE NOT NULL,
    doc_id TEXT REFERENCES knowledge_documents(doc_id),
    chain TEXT NOT NULL,
    content TEXT NOT NULL,
    metadata JSONB,
    embedding vector(768),  -- Gemini text-embedding-004 = 768차원
    created_at TIMESTAMPTZ DEFAULT NOW(),
    updated_at TIMESTAMPTZ DEFAULT NOW()
);

CREATE INDEX idx_chunks_doc_id ON doc_chunks(doc_id);
CREATE INDEX idx_chunks_chain ON doc_chunks(chain);

-- 4. 벡터 검색용 인덱스 (HNSW - 권장)
CREATE INDEX ON doc_chunks USING hnsw (embedding vector_cosine_ops);

-- 5. 벡터 검색 RPC 함수
CREATE OR REPLACE FUNCTION match_chunks(
    query_embedding vector(768),
    match_threshold float,
    match_count int,
    filter_chain text DEFAULT NULL
)
RETURNS TABLE (
    chunk_id text,
    doc_id text,
    chain text,
    content text,
    metadata jsonb,
    similarity float
)
LANGUAGE plpgsql
AS $$
BEGIN
    RETURN QUERY
    SELECT
        dc.chunk_id,
        dc.doc_id,
        dc.chain,
        dc.content,
        dc.metadata,
        1 - (dc.embedding <=> query_embedding) AS similarity
    FROM doc_chunks dc
    WHERE 
        (filter_chain IS NULL OR dc.chain = filter_chain)
        AND 1 - (dc.embedding <=> query_embedding) > match_threshold
    ORDER BY dc.embedding <=> query_embedding
    LIMIT match_count;
END;
$$;
"""


if __name__ == "__main__":
    print("🗄️ Supabase Adapter 테스트")
    print("=" * 50)
    
    try:
        adapter = SupabaseAdapter()
        health = adapter.health_check()
        
        print(f"상태: {health['status']}")
        if health['status'] == 'healthy':
            print(f"문서 수: {health.get('documents_count', 'N/A')}")
            print("✅ 연결 성공")
        else:
            print(f"오류: {health.get('error')}")
            
    except Exception as e:
        print(f"❌ 초기화 실패: {e}")
        print("\n📋 Supabase 설정 SQL:")
        print(SUPABASE_SETUP_SQL[:500] + "...")