1
import os
2
import logging
3
import traceback
4
from pathlib import Path
5
from fastapi import FastAPI, Request, HTTPException, Depends
6
from fastapi.responses import HTMLResponse, JSONResponse
7
from fastapi.templating import Jinja2Templates
8
from sqlalchemy import create_engine, Column, Integer, String, Boolean, BigInteger, Text, DateTime, LargeBinary, ForeignKey
9
from sqlalchemy.orm import sessionmaker, declarative_base, Session
10
from sqlalchemy.exc import SQLAlchemyError, OperationalError, DatabaseError
11
from groq import Groq
12

13
# Configure logging
14
logging.basicConfig(
15
    level=logging.INFO,
16
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
17
)
18
logger = logging.getLogger(__name__)
19

20
# --- 1. ОБЩАЯ НАСТРОЙКА ---
21
app = FastAPI()
22

23
# --- 2. НАСТРОЙКА ДЛЯ ПРОКСИ-GROQ ---
24
GROQ_API_KEY = os.getenv("GROQ_API_KEY")
25
groq_client = Groq(api_key=GROQ_API_KEY) if GROQ_API_KEY else None
26

27
# --- 3. НАСТРОЙКА ДЛЯ ВЕБ-ИСТОРИИ (SERVERLESS-СОВМЕСТИМАЯ) ---
28
DATABASE_URL = os.getenv("DATABASE_URL")
29
Base = declarative_base()
30

31
# Для Vercel serverless - без connection pooling
32
def get_engine():
33
    """Create database engine with error handling"""
34
    if not DATABASE_URL:
35
        logger.warning("DATABASE_URL is not configured")
36
        return None
37
    
38
    try:
39
        logger.info("Creating database engine...")
40
        engine = create_engine(
41
            DATABASE_URL,
42
            poolclass=None,  # Отключаем pooling для serverless
43
            connect_args={"connect_timeout": 10}
44
        )
45
        logger.info("Database engine created successfully")
46
        return engine
47
    except OperationalError as e:
48
        logger.error(f"Database operational error: {str(e)}")
49
        logger.error(f"Traceback: {traceback.format_exc()}")
50
        return None
51
    except DatabaseError as e:
52
        logger.error(f"Database error: {str(e)}")
53
        logger.error(f"Traceback: {traceback.format_exc()}")
54
        return None
55
    except Exception as e:
56
        logger.error(f"Unexpected error creating database engine: {type(e).__name__} - {str(e)}")
57
        logger.error(f"Traceback: {traceback.format_exc()}")
58
        return None
59

60
# Template path - работает как локально, так и на Vercel
61
try:
62
    template_dir = Path(__file__).parent / "templates"
63
    templates = Jinja2Templates(directory=str(template_dir))
64
    logger.info(f"Templates directory set to: {template_dir}")
65
except Exception as e:
66
    logger.error(f"Error setting up templates: {type(e).__name__} - {str(e)}")
67
    logger.error(f"Traceback: {traceback.format_exc()}")
68
    # Fallback to relative path
69
    templates = Jinja2Templates(directory="templates")
70

71

72
# --- МОДЕЛИ ДЛЯ ВЕБ-ИСТОРИИ (SQLAlchemy) ---
73
class Pair(Base):
74
    __tablename__ = "pairs"
75
    id = Column(Integer, primary_key=True)
76
    client_id = Column(BigInteger, unique=True, nullable=False)
77
    performer_id = Column(BigInteger, unique=True, nullable=False)
78
    is_frozen = Column(Boolean, default=False)
79

80
class User(Base):
81
    __tablename__ = "users"
82
    user_id = Column(BigInteger, primary_key=True, autoincrement=False)
83
    display_name = Column(String, nullable=False)
84

85
class History(Base):
86
    __tablename__ = "history"
87
    id = Column(Integer, primary_key=True)
88
    pair_id = Column(Integer, ForeignKey("pairs.id"), nullable=False)
89
    message_id = Column(BigInteger, nullable=False, index=True)
90
    sender_id = Column(BigInteger, nullable=False)
91
    date = Column(DateTime, nullable=False)
92
    text = Column(Text)
93
    original_text = Column(Text)
94
    media_blob = Column(LargeBinary)
95
    media_url = Column(String)  # Добавлено недостающее поле
96
    status = Column(String, default="sent")
97
    edit_date = Column(DateTime)
98
    log_message_id = Column(Integer)
99

100

101
# --- ЛОГИКА ДЛЯ ПРОКСИ-GROQ ---
102
MODEL_INFO = {
103
    "llama3-70b-8192": {"size": 70, "quality": 10}, "llama3-8b-8192": {"size": 8, "quality": 7},
104
    "llama-3.1-70b-versatile": {"size": 70, "quality": 9.5}, "mixtral-8x7b-32768": {"size": 56, "quality": 8.5},
105
    "gemma-7b-it": {"size": 7, "quality": 6},
106
}
107

108
def find_best_alternative(models_list):
109
    best_model, max_score = None, -1
110
    for model_id in models_list:
111
        score = MODEL_INFO.get(model_id, {}).get("quality", 0)
112
        if score > max_score:
113
            max_score, best_model = score, model_id
114
    return best_model or "gemma-7b-it"
115

116
@app.post("/api/groq")
117
async def proxy_to_groq(request: Request):
118
    """Proxy endpoint for Groq API with comprehensive error handling"""
119
    if not groq_client:
120
        logger.error("Groq API call attempted but GROQ_API_KEY is not set")
121
        raise HTTPException(status_code=500, detail="GROQ_API_KEY is not set.")
122
    
123
    try:
124
        logger.info("Received Groq API proxy request")
125
        data = await request.json()
126
        model = data.get("model", "llama-3.1-70b-versatile")
127
        
128
        if "messages" not in data:
129
            logger.error("Missing 'messages' field in request data")
130
            raise HTTPException(status_code=400, detail="Missing 'messages' field in request")
131
        
132
        logger.info(f"Attempting to use model: {model}")
133
        
134
        try:
135
            chat_completion = groq_client.chat.completions.create(messages=data["messages"], model=model)
136
            logger.info(f"Successfully completed chat with model: {model}")
137
        except Exception as e:
138
            error_str = str(e)
139
            logger.warning(f"Error with model {model}: {error_str}")
140
            
141
            if "model_decommissioned" in error_str or "not found" in error_str.lower():
142
                logger.info("Model decommissioned, attempting to find alternative...")
143
                try:
144
                    models_response = groq_client.models.list()
145
                    available_ids = [m.id for m in models_response.data]
146
                    best_alternative = find_best_alternative(available_ids)
147
                    logger.info(f"Switching from {model} to {best_alternative}")
148
                    chat_completion = groq_client.chat.completions.create(messages=data["messages"], model=best_alternative)
149
                    logger.info(f"Successfully completed chat with alternative model: {best_alternative}")
150
                except Exception as fallback_error:
151
                    logger.error(f"Failed to use alternative model: {type(fallback_error).__name__} - {str(fallback_error)}")
152
                    logger.error(f"Traceback: {traceback.format_exc()}")
153
                    raise HTTPException(
154
                        status_code=500, 
155
                        detail=f"Failed with original and alternative models: {str(fallback_error)}"
156
                    )
157
            elif "rate_limit" in error_str.lower():
158
                logger.error(f"Rate limit error: {error_str}")
159
                raise HTTPException(status_code=429, detail=f"Rate limit exceeded: {error_str}")
160
            elif "authentication" in error_str.lower() or "api key" in error_str.lower():
161
                logger.error(f"Authentication error: {error_str}")
162
                raise HTTPException(status_code=401, detail=f"Authentication failed: {error_str}")
163
            else:
164
                logger.error(f"Unexpected Groq API error: {type(e).__name__} - {error_str}")
165
                logger.error(f"Traceback: {traceback.format_exc()}")
166
                raise e
167
        
168
        return chat_completion.dict()
169
        
170
    except HTTPException:
171
        raise  # Re-raise HTTP exceptions as-is
172
    except KeyError as e:
173
        logger.error(f"Missing required field: {str(e)}")
174
        logger.error(f"Traceback: {traceback.format_exc()}")
175
        raise HTTPException(status_code=400, detail=f"Missing required field: {str(e)}")
176
    except Exception as e:
177
        logger.error(f"Unexpected error in Groq proxy: {type(e).__name__} - {str(e)}")
178
        logger.error(f"Traceback: {traceback.format_exc()}")
179
        raise HTTPException(status_code=500, detail=f"Error: {type(e).__name__} - {str(e)}")
180

181

182
# --- ЛОГИКА ДЛЯ ВЕБ-ИСТОРИИ (SERVERLESS-СОВМЕСТИМАЯ) ---
183
def get_db() -> Session:
184
    """Dependency для получения DB сессии (serverless-совместимая версия) с error handling"""
185
    if not DATABASE_URL:
186
        logger.error("Database access attempted but DATABASE_URL is not set")
187
        raise HTTPException(status_code=500, detail="DATABASE_URL is not set.")
188
    
189
    engine = None
190
    db = None
191
    
192
    try:
193
        logger.info("Creating database session...")
194
        engine = get_engine()
195
        if not engine:
196
            logger.error("Failed to create database engine - get_engine returned None")
197
            raise HTTPException(status_code=500, detail="Failed to create database engine.")
198
        
199
        # Создаем таблицы если их нет (для serverless это безопасно делать на каждом запросе)
200
        try:
201
            Base.metadata.create_all(bind=engine)
202
            logger.info("Database tables checked/created successfully")
203
        except OperationalError as e:
204
            logger.error(f"Database operational error during table creation: {str(e)}")
205
            logger.error(f"Traceback: {traceback.format_exc()}")
206
            raise HTTPException(status_code=503, detail=f"Database connection failed: {str(e)}")
207
        except DatabaseError as e:
208
            logger.error(f"Database error during table creation: {str(e)}")
209
            logger.error(f"Traceback: {traceback.format_exc()}")
210
            raise HTTPException(status_code=500, detail=f"Database error: {str(e)}")
211
        except Exception as e:
212
            logger.warning(f"Warning: Could not create tables: {type(e).__name__} - {str(e)}")
213
        
214
        # Создаем новую сессию для каждого запроса
215
        try:
216
            SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
217
            db = SessionLocal()
218
            logger.info("Database session created successfully")
219
        except Exception as e:
220
            logger.error(f"Failed to create database session: {type(e).__name__} - {str(e)}")
221
            logger.error(f"Traceback: {traceback.format_exc()}")
222
            raise HTTPException(status_code=500, detail=f"Failed to create database session: {str(e)}")
223
        
224
        yield db
225
        
226
    except HTTPException:
227
        raise  # Re-raise HTTP exceptions as-is
228
    except Exception as e:
229
        logger.error(f"Unexpected error in get_db: {type(e).__name__} - {str(e)}")
230
        logger.error(f"Traceback: {traceback.format_exc()}")
231
        raise HTTPException(status_code=500, detail=f"Database error: {str(e)}")
232
    finally:
233
        # Cleanup resources
234
        if db:
235
            try:
236
                db.close()
237
                logger.debug("Database session closed")
238
            except Exception as e:
239
                logger.warning(f"Error closing database session: {str(e)}")
240
        
241
        if engine:
242
            try:
243
                engine.dispose()
244
                logger.debug("Database engine disposed")
245
            except Exception as e:
246
                logger.warning(f"Error disposing database engine: {str(e)}")
247

248
def get_user_display_name(db_session, user_id: int) -> str:
249
    """Get user display name with error handling"""
250
    try:
251
        user = db_session.query(User).filter(User.user_id == user_id).first()
252
        return user.display_name if user else f"ID: {user_id}"
253
    except SQLAlchemyError as e:
254
        logger.error(f"Database error getting user {user_id}: {str(e)}")
255
        return f"ID: {user_id}"
256
    except Exception as e:
257
        logger.error(f"Unexpected error getting user {user_id}: {type(e).__name__} - {str(e)}")
258
        return f"ID: {user_id}"
259

260
@app.get("/", response_class=HTMLResponse)
261
async def list_pairs(request: Request, db: Session = Depends(get_db)):
262
    """List all conversation pairs with comprehensive error handling"""
263
    try:
264
        logger.info("Fetching list of conversation pairs")
265
        pairs = db.query(Pair).all()
266
        logger.info(f"Found {len(pairs)} conversation pairs")
267
        
268
        pair_details = []
269
        for p in pairs:
270
            try:
271
                pair_details.append({
272
                    "client_id": p.client_id,
273
                    "client_name": get_user_display_name(db, p.client_id),
274
                    "performer_name": get_user_display_name(db, p.performer_id),
275
                    "is_frozen": p.is_frozen
276
                })
277
            except Exception as e:
278
                logger.error(f"Error processing pair {p.id}: {type(e).__name__} - {str(e)}")
279
                # Continue with other pairs even if one fails
280
                continue
281
        
282
        return templates.TemplateResponse("index.html", {"request": request, "pairs": pair_details})
283
        
284
    except SQLAlchemyError as e:
285
        logger.error(f"Database error in list_pairs: {type(e).__name__} - {str(e)}")
286
        logger.error(f"Traceback: {traceback.format_exc()}")
287
        raise HTTPException(status_code=503, detail=f"Database error: {str(e)}")
288
    except Exception as e:
289
        logger.error(f"Unexpected error in list_pairs: {type(e).__name__} - {str(e)}")
290
        logger.error(f"Traceback: {traceback.format_exc()}")
291
        raise HTTPException(status_code=500, detail=f"Error loading pairs: {str(e)}")
292

293
@app.get("/dialog/{client_id}", response_class=HTMLResponse)
294
async def show_dialog(request: Request, client_id: int, db: Session = Depends(get_db)):
295
    """Show dialog for a specific client with comprehensive error handling"""
296
    try:
297
        logger.info(f"Fetching dialog for client_id: {client_id}")
298
        
299
        pair = db.query(Pair).filter(Pair.client_id == client_id).first()
300
        if not pair:
301
            logger.warning(f"Dialog not found for client_id: {client_id}")
302
            raise HTTPException(status_code=404, detail="Диалог не найден")
303
        
304
        logger.info(f"Found pair {pair.id} for client {client_id}")
305
        
306
        try:
307
            messages = db.query(History).filter(History.pair_id == pair.id).order_by(History.date).all()
308
            logger.info(f"Found {len(messages)} messages for pair {pair.id}")
309
        except SQLAlchemyError as e:
310
            logger.error(f"Database error fetching messages: {type(e).__name__} - {str(e)}")
311
            logger.error(f"Traceback: {traceback.format_exc()}")
312
            raise HTTPException(status_code=503, detail=f"Error fetching messages: {str(e)}")
313
        
314
        client_name = get_user_display_name(db, pair.client_id)
315
        performer_name = get_user_display_name(db, pair.performer_id)
316
        
317
        return templates.TemplateResponse("dialog.html", {
318
            "request": request,
319
            "client_id": client_id,
320
            "client_name": client_name,
321
            "performer_name": performer_name,
322
            "messages": messages
323
        })
324
        
325
    except HTTPException:
326
        raise  # Re-raise HTTP exceptions as-is
327
    except SQLAlchemyError as e:
328
        logger.error(f"Database error in show_dialog: {type(e).__name__} - {str(e)}")
329
        logger.error(f"Traceback: {traceback.format_exc()}")
330
        raise HTTPException(status_code=503, detail=f"Database error: {str(e)}")
331
    except Exception as e:
332
        logger.error(f"Unexpected error in show_dialog: {type(e).__name__} - {str(e)}")
333
        logger.error(f"Traceback: {traceback.format_exc()}")
334
        raise HTTPException(status_code=500, detail=f"Error loading dialog: {str(e)}")
335

336
@app.get("/api/dialog/{client_id}")
337
async def get_dialog_data(client_id: int, db: Session = Depends(get_db)):
338
    """Возвращает данные диалога в формате JSON с comprehensive error handling"""
339
    try:
340
        logger.info(f"API: Fetching dialog data for client_id: {client_id}")
341
        
342
        pair = db.query(Pair).filter(Pair.client_id == client_id).first()
343
        if not pair:
344
            logger.warning(f"API: Dialog not found for client_id: {client_id}")
345
            raise HTTPException(status_code=404, detail="Диалог не найден")
346
        
347
        logger.info(f"API: Found pair {pair.id} for client {client_id}")
348

349
        try:
350
            messages = db.query(History).filter(History.pair_id == pair.id).order_by(History.date).all()
351
            logger.info(f"API: Found {len(messages)} messages for pair {pair.id}")
352
        except SQLAlchemyError as e:
353
            logger.error(f"Database error fetching messages in API: {type(e).__name__} - {str(e)}")
354
            logger.error(f"Traceback: {traceback.format_exc()}")
355
            raise HTTPException(status_code=503, detail=f"Error fetching messages: {str(e)}")
356

357
        # Преобразуем сообщения в формат, удобный для JSON
358
        messages_data = []
359
        for msg in messages:
360
            try:
361
                messages_data.append({
362
                    "id": msg.id,
363
                    "sender_id": msg.sender_id,
364
                    "text": msg.text,
365
                    "original_text": msg.original_text,
366
                    "date": msg.date.isoformat() if msg.date else None,
367
                    "status": msg.status,
368
                    "media_url": msg.media_url
369
                })
370
            except Exception as e:
371
                logger.error(f"Error serializing message {msg.id}: {type(e).__name__} - {str(e)}")
372
                # Continue with other messages even if one fails
373
                continue
374

375
        return {"messages": messages_data}
376
        
377
    except HTTPException:
378
        raise  # Re-raise HTTP exceptions as-is
379
    except SQLAlchemyError as e:
380
        logger.error(f"Database error in get_dialog_data: {type(e).__name__} - {str(e)}")
381
        logger.error(f"Traceback: {traceback.format_exc()}")
382
        raise HTTPException(status_code=503, detail=f"Database error: {str(e)}")
383
    except Exception as e:
384
        logger.error(f"Unexpected error in get_dialog_data: {type(e).__name__} - {str(e)}")
385
        logger.error(f"Traceback: {traceback.format_exc()}")
386
        raise HTTPException(status_code=500, detail=f"Error fetching dialog data: {str(e)}")
387

388

389
# --- HEALTH CHECK ---
390
@app.get("/api/health")
391
def health_check():
392
    """Health check endpoint с comprehensive diagnostics"""
393
    try:
394
        logger.info("Health check requested")
395
        
396
        # Test database connection if configured
397
        db_status = "not_configured"
398
        db_error = None
399
        if DATABASE_URL:
400
            try:
401
                engine = get_engine()
402
                if engine:
403
                    # Try to execute a simple query
404
                    with engine.connect() as conn:
405
                        conn.execute("SELECT 1")
406
                    db_status = "connected"
407
                    logger.info("Health check: Database connection successful")
408
                else:
409
                    db_status = "error"
410
                    db_error = "Failed to create engine"
411
                    logger.warning("Health check: Failed to create database engine")
412
            except Exception as e:
413
                db_status = "error"
414
                db_error = str(e)
415
                logger.error(f"Health check: Database connection failed: {str(e)}")
416
        
417
        # Test Groq client if configured
418
        groq_status = "not_configured"
419
        groq_error = None
420
        if GROQ_API_KEY:
421
            if groq_client:
422
                groq_status = "configured"
423
                logger.info("Health check: Groq client configured")
424
            else:
425
                groq_status = "error"
426
                groq_error = "Failed to initialize client"
427
                logger.warning("Health check: Groq client initialization failed")
428
        
429
        status = {
430
            "status": "ok" if db_status in ["connected", "not_configured"] and groq_status in ["configured", "not_configured"] else "degraded",
431
            "groq": {
432
                "status": groq_status,
433
                "error": groq_error
434
            },
435
            "database": {
436
                "status": db_status,
437
                "error": db_error
438
            },
439
            "timestamp": os.popen('date -u +"%Y-%m-%dT%H:%M:%SZ"').read().strip()
440
        }
441
        
442
        logger.info(f"Health check result: {status['status']}")
443
        return status
444
        
445
    except Exception as e:
446
        logger.error(f"Error in health check: {type(e).__name__} - {str(e)}")
447
        logger.error(f"Traceback: {traceback.format_exc()}")
448
        return {
449
            "status": "error",
450
            "error": str(e),
451
            "type": type(e).__name__
452
        }
453

454

455
# --- GLOBAL EXCEPTION HANDLER ---
456
@app.exception_handler(Exception)
457
async def global_exception_handler(request: Request, exc: Exception):
458
    """Global exception handler to catch any unhandled errors"""
459
    logger.error(f"UNHANDLED EXCEPTION: {type(exc).__name__} - {str(exc)}")
460
    logger.error(f"Request URL: {request.url}")
461
    logger.error(f"Request method: {request.method}")
462
    logger.error(f"Traceback: {traceback.format_exc()}")
463
    
464
    # Return a generic error response
465
    return JSONResponse(
466
        status_code=500,
467
        content={
468
            "error": "Internal server error",
469
            "type": type(exc).__name__,
470
            "detail": str(exc),
471
            "path": str(request.url)
472
        }
473
    )
474

475

476
# Log startup
477
logger.info("=" * 60)
478
logger.info("Application starting up...")
479
logger.info(f"GROQ_API_KEY configured: {GROQ_API_KEY is not None}")
480
logger.info(f"DATABASE_URL configured: {DATABASE_URL is not None}")
481
logger.info("=" * 60)