class YouTubeLiveChatService:
    """YouTube 라이브 채팅 폴링 서비스"""
    
    def get_chat_messages(self):
        # YouTube API로 새 메시지 가져오기
        # 2초마다 폴링
        
    async def poll_chat_messages(self, callback):
        # 비동기로 지속적 폴링
        # 콜백으로 메시지 전달

class ConnectionManager:
    """WebSocket 연결 관리"""
    
    async def broadcast(self, message):
        # 모든 연결된 클라이언트에게 메시지 전송

"""
YouTube Live Chat Service
실시간으로 YouTube 라이브 채팅을 가져오는 서비스
"""

import os
import asyncio
from typing import Optional, List, Dict, Callable, Tuple
from google.oauth2.credentials import Credentials
from google_auth_oauthlib.flow import Flow
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError


class YouTubeLiveChatService:
    def __init__(self, client_id: str, client_secret: str, 
                 redirect_uri: str, token_file: str = "credentials.json"):
        self.client_id = client_id
        self.client_secret = client_secret
        self.redirect_uri = redirect_uri
        self.token_file = token_file
        self.credentials: Optional[Credentials] = None
        self.youtube = None
        self.live_chat_id: Optional[str] = None
        self.next_page_token: Optional[str] = None
        self.is_running = False
        
        # 저장된 토큰 자동 로드
        self._load_credentials()
    
    def _load_credentials(self):
        """저장된 토큰 파일에서 credentials 로드"""
        if os.path.exists(self.token_file):
            try:
                self.credentials = Credentials.from_authorized_user_file(
                    self.token_file,
                    scopes=["https://www.googleapis.com/auth/youtube.readonly"]
                )
                
                # 토큰이 만료되었으면 갱신
                if self.credentials and self.credentials.expired:
                    from google.auth.transport.requests import Request
                    self.credentials.refresh(Request())
                    self._save_credentials()
                
                if self.credentials and self.credentials.valid:
                    self.youtube = build('youtube', 'v3', 
                                       credentials=self.credentials)
                    print(f"✓ 저장된 토큰 로드 성공")
                    return True
            except Exception as e:
                print(f"⚠️ 토큰 로드 실패: {e}")
        return False
    
    def _save_credentials(self):
        """credentials를 파일로 저장"""
        if self.credentials:
            try:
                with open(self.token_file, 'w') as token:
                    token.write(self.credentials.to_json())
                print(f"✓ 토큰 저장됨")
            except Exception as e:
                print(f"✗ 토큰 저장 실패: {e}")
    
    def get_live_chat_id(self, video_id: str) -> Optional[str]:
        """비디오 ID로 라이브 채팅 ID 가져오기"""
        if not self.youtube:
            return None
        
        try:
            request = self.youtube.videos().list(
                part="liveStreamingDetails",
                id=video_id
            )
            response = request.execute()
            
            if response['items']:
                live_chat_id = response['items'][0].get(
                    'liveStreamingDetails', {}
                ).get('activeLiveChatId')
                
                if live_chat_id:
                    self.live_chat_id = live_chat_id
                    print(f"✓ 라이브 채팅 ID: {live_chat_id}")
                    return live_chat_id
        except HttpError as e:
            print(f"✗ 라이브 채팅 ID 가져오기 실패: {e}")
        return None
    
    def get_chat_messages(self) -> Tuple[List[Dict], float]:
        """라이브 채팅 메시지 가져오기"""
        if not self.live_chat_id or not self.youtube:
            return [], 2
        
        try:
            request = self.youtube.liveChatMessages().list(
                liveChatId=self.live_chat_id,
                part="snippet,authorDetails",
                pageToken=self.next_page_token
            )
            response = request.execute()
            
            # 다음 페이지 토큰 저장
            self.next_page_token = response.get('nextPageToken')
            
            # 메시지 파싱
            messages = []
            for item in response.get('items', []):
                snippet = item['snippet']
                author = item['authorDetails']
                
                message = {
                    'id': item['id'],
                    'username': author['displayName'],
                    'text': snippet['displayMessage'],
                    'timestamp': snippet['publishedAt'],
                    'isChatModerator': author.get('isChatModerator', False),
                    'isChatOwner': author.get('isChatOwner', False),
                }
                messages.append(message)
            
            # 폴링 간격 최적화: 최대 2초로 제한
            api_interval = response.get('pollingIntervalMillis', 2000) / 1000
            polling_interval = min(api_interval, 2)
            
            if messages:
                print(f"✓ {len(messages)}개의 새 메시지")
            
            return messages, polling_interval
            
        except HttpError as e:
            print(f"✗ 메시지 가져오기 실패: {e}")
            return [], 2
    
    async def poll_chat_messages(self, callback: Callable, interval: float = 2):
        """주기적으로 채팅 메시지 폴링"""
        self.is_running = True
        print("🚀 YouTube 채팅 폴링 시작...")
        
        while self.is_running:
            try:
                messages, polling_interval = self.get_chat_messages()
                
                if messages:
                    for message in messages:
                        await callback(message)
                
                await asyncio.sleep(polling_interval)
                
            except Exception as e:
                print(f"✗ 폴링 중 오류: {e}")
                await asyncio.sleep(2)
        
        print("🛑 YouTube 채팅 폴링 종료")

from fastapi import FastAPI, WebSocket, WebSocketDisconnect
from fastapi.middleware.cors import CORSMiddleware
from fastapi.responses import HTMLResponse, RedirectResponse
from typing import List
import json
import os
import asyncio
from datetime import datetime
from dotenv import load_dotenv
from youtube_service import YouTubeLiveChatService

load_dotenv()

app = FastAPI(title="Physics Chat Playground API")

# CORS 설정
app.add_middleware(
    CORSMiddleware,
    allow_origins=["http://localhost:5173"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# WebSocket 연결 관리
class ConnectionManager:
    def __init__(self):
        self.active_connections: List[WebSocket] = []

    async def connect(self, websocket: WebSocket):
        await websocket.accept()
        self.active_connections.append(websocket)

    def disconnect(self, websocket: WebSocket):
        self.active_connections.remove(websocket)

    async def broadcast(self, message: dict):
        for connection in self.active_connections:
            try:
                await connection.send_json(message)
            except Exception as e:
                print(f"Error broadcasting: {e}")

manager = ConnectionManager()

# YouTube Service 초기화
youtube_service = YouTubeLiveChatService(
    client_id=os.getenv("YOUTUBE_CLIENT_ID"),
    client_secret=os.getenv("YOUTUBE_CLIENT_SECRET"),
    redirect_uri=os.getenv("REDIRECT_URI"),
    token_file="credentials.json"
)

is_youtube_connected = youtube_service.is_authenticated()
polling_task = None

@app.get("/")
async def root():
    return {
        "message": "Physics Chat Playground API",
        "youtube_connected": is_youtube_connected
    }

@app.get("/auth/youtube")
async def youtube_auth():
    """YouTube 인증 시작"""
    if not youtube_service:
        return {"error": "YouTube service not initialized"}
    
    auth_url = youtube_service.get_auth_url()
    return RedirectResponse(url=auth_url)

@app.get("/auth/callback")
async def youtube_callback(code: str):
    """YouTube OAuth 콜백"""
    global is_youtube_connected
    
    if youtube_service.authenticate_with_code(code):
        is_youtube_connected = True
        return HTMLResponse("""
            <html>
                <body>
                    <h1>✅ YouTube 인증 완료!</h1>
                    <p>브라우저를 닫아도 됩니다.</p>
                </body>
            </html>
        """)
    return {"error": "Authentication failed"}

@app.post("/youtube/connect/{video_id}")
async def connect_youtube_chat(video_id: str):
    """YouTube 라이브 채팅 연결"""
    global polling_task, is_youtube_connected
    
    if not youtube_service.is_authenticated():
        return {"error": "Please authenticate first"}
    
    is_youtube_connected = True
    
    # 이미 폴링 중이면 중지
    if polling_task and not polling_task.done():
        youtube_service.stop_polling()
        await asyncio.sleep(1)
    
    chat_id = youtube_service.get_live_chat_id(video_id)
    if chat_id:
        # 백그라운드에서 채팅 폴링 시작
        async def handle_youtube_message(message):
            print(f"📺 YouTube: [{message['username']}] {message['text']}")
            
            broadcast_message = {
                "type": "youtube",
                "id": message['id'],
                "username": message['username'],
                "text": message['text'],
                "timestamp": message['timestamp'],
                "isYouTube": True,
            }
            
            await manager.broadcast(broadcast_message)
        
        polling_task = asyncio.create_task(
            youtube_service.poll_chat_messages(handle_youtube_message)
        )
        
        return {
            "success": True,
            "message": "Connected to YouTube Live Chat",
            "chatId": chat_id,
        }
    
    return {"error": "Could not find live chat"}

@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket):
    await manager.connect(websocket)
    try:
        while True:
            data = await websocket.receive_text()
            message_data = json.loads(data)
            message_data["timestamp"] = datetime.now().isoformat()
            await manager.broadcast(message_data)
    except WebSocketDisconnect:
        manager.disconnect(websocket)

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

def _save_credentials(self):
    """credentials를 파일로 저장"""
    if self.credentials:
        with open(self.token_file, 'w') as token:
            token.write(self.credentials.to_json())

def _load_credentials(self):
    """저장된 토큰 파일에서 credentials 로드"""
    if os.path.exists(self.token_file):
        self.credentials = Credentials.from_authorized_user_file(
            self.token_file,
            scopes=["https://www.googleapis.com/auth/youtube.readonly"]
        )
        
        # 토큰 만료 시 자동 갱신
        if self.credentials.expired and self.credentials.refresh_token:
            self.credentials.refresh(Request())
            self._save_credentials()

def get_chat_messages(self):
    # ...
    api_interval = response.get('pollingIntervalMillis', 2000) / 1000
    polling_interval = min(api_interval, 2)  # 최대 2초
    return messages, polling_interval

class ConnectionManager:
    async def broadcast(self, message: dict):
        for connection in self.active_connections:
            try:
                await connection.send_json(message)
            except Exception as e:
                # 연결 끊긴 클라이언트 무시
                pass

# 기존
from .youtube_service import YouTubeLiveChatService

# 수정
from youtube_service import YouTubeLiveChatService

# API 권장 간격과 2초 중 최소값 선택
api_interval = response.get('pollingIntervalMillis', 2000) / 1000
polling_interval = min(api_interval, 2)

async def broadcast(self, message: dict):
    for connection in self.active_connections:
        try:
            await connection.send_json(message)
        except:
            pass  # 에러 무시하고 계속 진행