#!/usr/bin/env python3
"""
Тест правильной аутентификации и WebSocket подключения
"""

import asyncio
import json
import httpx
import websockets
from typing import Optional

class ProperAuthTest:
    def __init__(self):
        self.base_url = "http://localhost:8000"  # API Gateway
        self.ws_url = "ws://localhost:8002"      # Emergency Service
        self.token: Optional[str] = None
        
    async def login_and_get_token(self) -> Optional[str]:
        """Получаем настоящий JWT токен через авторизацию"""
        try:
            async with httpx.AsyncClient() as client:
                # Данные для входа
                login_data = {
                    "email": "shadow85@list.ru",
                    "password": "R0sebud1985"
                }
                
                print("🔐 Авторизация пользователя...")
                response = await client.post(
                    f"{self.base_url}/api/v1/auth/login",
                    json=login_data,
                    headers={"Content-Type": "application/json"}
                )
                
                print(f"📡 Статус авторизации: {response.status_code}")
                
                if response.status_code == 200:
                    auth_data = response.json()
                    token = auth_data.get("access_token")
                    print(f"✅ Получен JWT токен: {token[:50]}...")
                    return token
                else:
                    print(f"❌ Ошибка авторизации: {response.text}")
                    return None
                    
        except Exception as e:
            print(f"❌ Ошибка при авторизации: {e}")
            return None
    
    async def test_websocket_with_jwt_token(self, token: str) -> bool:
        """Тестируем WebSocket подключение с настоящим JWT токеном"""
        try:
            # Формируем URL с JWT токеном
            ws_url = f"{self.ws_url}/api/v1/emergency/ws/current_user_id?token={token}"
            print(f"🔌 Подключение к WebSocket с JWT токеном...")
            
            async with websockets.connect(ws_url) as websocket:
                print("✅ WebSocket подключен успешно!")
                
                # Отправляем тестовое сообщение
                test_message = {
                    "type": "ping",
                    "message": "Hello from proper auth test!"
                }
                
                await websocket.send(json.dumps(test_message))
                print(f"📤 Отправлено: {test_message}")
                
                # Ждём ответ (с таймаутом)
                try:
                    response = await asyncio.wait_for(websocket.recv(), timeout=5.0)
                    print(f"📥 Получен ответ: {response}")
                except asyncio.TimeoutError:
                    print("⏰ Таймаут - ответ не получен, но подключение работает")
                
                return True
                
        except websockets.exceptions.ConnectionClosed as e:
            print(f"❌ WebSocket подключение закрыто: {e.code} - {e.reason}")
            return False
        except Exception as e:
            print(f"❌ Ошибка WebSocket подключения: {e}")
            return False
    
    async def show_token_analysis(self, token: str):
        """Анализ JWT токена"""
        print("\n" + "="*50)
        print("🔍 АНАЛИЗ JWT ТОКЕНА")
        print("="*50)
        
        try:
            import jwt
            from shared.config import settings
            
            # Декодируем токен БЕЗ проверки (для анализа структуры)
            unverified_payload = jwt.decode(token, options={"verify_signature": False})
            print(f"📋 Содержимое токена:")
            for key, value in unverified_payload.items():
                if key == 'exp':
                    import datetime
                    exp_time = datetime.datetime.fromtimestamp(value)
                    print(f"  {key}: {value} ({exp_time})")
                else:
                    print(f"  {key}: {value}")
            
            # Проверяем подпись
            try:
                verified_payload = jwt.decode(
                    token, 
                    settings.SECRET_KEY, 
                    algorithms=[settings.ALGORITHM]
                )
                print("✅ Подпись токена валидна")
            except jwt.InvalidTokenError as e:
                print(f"❌ Ошибка проверки подписи: {e}")
                
        except Exception as e:
            print(f"❌ Ошибка анализа токена: {e}")
    
    async def run_test(self):
        """Запуск полного теста"""
        print("🚀 ЗАПУСК ТЕСТА ПРАВИЛЬНОЙ АУТЕНТИФИКАЦИИ")
        print("="*60)
        
        # Шаг 1: Получаем JWT токен
        token = await self.login_and_get_token()
        if not token:
            print("❌ Не удалось получить токен. Проверьте, что сервисы запущены.")
            return False
        
        # Шаг 2: Анализируем токен
        await self.show_token_analysis(token)
        
        # Шаг 3: Тестируем WebSocket
        print("\n" + "="*50)
        print("🔌 ТЕСТ WEBSOCKET ПОДКЛЮЧЕНИЯ")
        print("="*50)
        
        websocket_success = await self.test_websocket_with_jwt_token(token)
        
        # Результат
        print("\n" + "="*50)
        print("📊 РЕЗУЛЬТАТ ТЕСТА")
        print("="*50)
        
        if websocket_success:
            print("✅ Тест пройден успешно!")
            print("✅ JWT аутентификация работает корректно")
            print("✅ WebSocket подключение установлено")
        else:
            print("❌ Тест не прошел")
            print("❌ Проблемы с WebSocket подключением")
        
        return websocket_success

async def main():
    """Главная функция"""
    tester = ProperAuthTest()
    await tester.run_test()

if __name__ == "__main__":
    asyncio.run(main())