crm.clientright.ru/ticket_form/backend/app/api/documents.py

"""
Documents API Routes - Загрузка и обработка документов

Новый флоу: поэкранная загрузка документов
"""
from fastapi import APIRouter, HTTPException, UploadFile, File, Form, Request
from typing import Optional, List
import httpx
import json
import uuid
from datetime import datetime
import logging
from ..services.redis_service import redis_service
from ..config import settings

router = APIRouter(prefix="/api/v1/documents", tags=["Documents"])
logger = logging.getLogger(__name__)

# n8n webhook для загрузки документов
N8N_DOCUMENT_UPLOAD_WEBHOOK = "https://n8n.clientright.pro/webhook/webform_document_upload"


@router.post("/upload")
async def upload_document(
    request: Request,
    file: UploadFile = File(...),
    claim_id: str = Form(...),
    session_id: str = Form(...),
    document_type: str = Form(...),
    document_name: Optional[str] = Form(None),
    document_description: Optional[str] = Form(None),
    group_index: Optional[str] = Form(None),
    unified_id: Optional[str] = Form(None),
    contact_id: Optional[str] = Form(None),
    phone: Optional[str] = Form(None),
):
    """
    Загрузка одного документа.
    
    Принимает файл и метаданные, отправляет в n8n для:
    1. Сохранения в S3
    2. OCR обработки
    3. Обновления черновика в PostgreSQL
    
    После успешной обработки n8n публикует событие document_ocr_completed в Redis.
    """
    try:
        # Генерируем уникальный ID файла
        file_id = f"doc_{uuid.uuid4().hex[:12]}"
        
        logger.info(
            "📤 Document upload received",
            extra={
                "claim_id": claim_id,
                "session_id": session_id,
                "document_type": document_type,
                "file_name": file.filename,
                "file_size": file.size if hasattr(file, 'size') else 'unknown',
                "content_type": file.content_type,
            },
        )
        
        # Читаем содержимое файла
        file_content = await file.read()
        file_size = len(file_content)
        
        # Получаем IP клиента
        client_ip = request.client.host if request.client else "unknown"
        forwarded_for = request.headers.get("x-forwarded-for", "").split(",")[0].strip()
        if forwarded_for:
            client_ip = forwarded_for
        
        # Формируем данные в формате совместимом с существующим n8n воркфлоу
        form_data = {
            # Основные идентификаторы
            "form_id": "ticket_form",
            "stage": "document_upload",
            "session_id": session_id,
            "claim_id": claim_id,
            "client_ip": client_ip,
            
            # Идентификаторы пользователя
            "unified_id": unified_id or "",
            "contact_id": contact_id or "",
            "phone": phone or "",
            
            # Информация о документе
            "document_type": document_type,
            "file_id": file_id,
            "original_filename": file.filename,
            "content_type": file.content_type or "application/octet-stream",
            "file_size": str(file_size),
            "upload_timestamp": datetime.utcnow().isoformat(),
            
            # Формат uploads_* для совместимости
            # ✅ Используем group_index для правильной индексации (по умолчанию 0)
            "uploads_field_names[{idx}]".format(idx=group_index or "0"): document_type,
            "uploads_field_labels[{idx}]".format(idx=group_index or "0"): document_name or document_type,
            "uploads_descriptions[{idx}]".format(idx=group_index or "0"): document_description or "",
        }
        
        # ✅ Добавляем group_index в данные формы
        if group_index:
            form_data["group_index"] = group_index
            logger.info(f"📋 group_index передан в n8n: {group_index}")
        
        # Файл для multipart (ключ uploads[group_index] для совместимости)
        idx = group_index or "0"
        files = {
            f"uploads[{idx}]": (file.filename, file_content, file.content_type or "application/octet-stream")
        }
        
        # Отправляем в n8n
        async with httpx.AsyncClient(timeout=120.0) as client:
            response = await client.post(
                N8N_DOCUMENT_UPLOAD_WEBHOOK,
                data=form_data,
                files=files,
            )
        
        response_text = response.text or ""
        
        if response.status_code == 200:
            logger.info(
                "✅ Document uploaded to n8n",
                extra={
                    "claim_id": claim_id,
                    "document_type": document_type,
                    "file_id": file_id,
                    "response_preview": response_text[:200],
                },
            )
            
            # Парсим ответ от n8n
            try:
                n8n_response = json.loads(response_text)
            except json.JSONDecodeError:
                n8n_response = {"raw": response_text}
            
            # Публикуем событие в Redis для фронтенда
            event_data = {
                "event_type": "document_uploaded",
                "status": "processing",
                "claim_id": claim_id,
                "session_id": session_id,
                "document_type": document_type,
                "file_id": file_id,
                "original_filename": file.filename,
                "timestamp": datetime.utcnow().isoformat(),
            }
            
            await redis_service.publish(
                f"ocr_events:{session_id}",
                json.dumps(event_data, ensure_ascii=False)
            )
            
            return {
                "success": True,
                "file_id": file_id,
                "document_type": document_type,
                "ocr_status": "processing",
                "message": "Документ загружен и отправлен на обработку",
                "n8n_response": n8n_response,
            }
        
        else:
            logger.error(
                "❌ n8n document upload error",
                extra={
                    "status_code": response.status_code,
                    "body": response_text[:500],
                },
            )
            raise HTTPException(
                status_code=response.status_code,
                detail=f"Ошибка n8n: {response_text}",
            )
    
    except httpx.TimeoutException:
        logger.error("⏱️ n8n document upload timeout")
        raise HTTPException(status_code=504, detail="Таймаут загрузки документа")
    
    except HTTPException:
        raise
    
    except Exception as e:
        logger.exception("❌ Document upload error")
        raise HTTPException(
            status_code=500,
            detail=f"Ошибка загрузки документа: {str(e)}",
        )


@router.post("/upload-multiple")
async def upload_multiple_documents(
    request: Request,
    files: List[UploadFile] = File(...),
    claim_id: str = Form(...),
    session_id: str = Form(...),
    document_type: str = Form(...),
    document_name: Optional[str] = Form(None),
    document_description: Optional[str] = Form(None),
    unified_id: Optional[str] = Form(None),
    contact_id: Optional[str] = Form(None),
    phone: Optional[str] = Form(None),
):
    """
    Загрузка нескольких файлов для одного документа (например, несколько страниц паспорта).
    Все файлы отправляются одним запросом в n8n.
    """
    try:
        logger.info(
            "📤 Multiple documents upload received",
            extra={
                "claim_id": claim_id,
                "session_id": session_id,
                "document_type": document_type,
                "files_count": len(files),
                "file_names": [f.filename for f in files],
            },
        )
        
        # Получаем IP клиента
        client_ip = request.client.host if request.client else "unknown"
        forwarded_for = request.headers.get("x-forwarded-for", "").split(",")[0].strip()
        if forwarded_for:
            client_ip = forwarded_for
        
        # Генерируем ID для каждого файла и читаем контент
        file_ids = []
        files_multipart = {}
        
        for i, file in enumerate(files):
            file_id = f"doc_{uuid.uuid4().hex[:12]}"
            file_ids.append(file_id)
            
            file_content = await file.read()
            files_multipart[f"uploads[{i}]"] = (
                file.filename, 
                file_content, 
                file.content_type or "application/octet-stream"
            )
        
        # Формируем данные формы
        form_data = {
            # Основные идентификаторы
            "form_id": "ticket_form",
            "stage": "document_upload",
            "session_id": session_id,
            "claim_id": claim_id,
            "client_ip": client_ip,
            
            # Идентификаторы пользователя
            "unified_id": unified_id or "",
            "contact_id": contact_id or "",
            "phone": phone or "",
            
            # Информация о документе
            "document_type": document_type,
            "files_count": str(len(files)),
            "upload_timestamp": datetime.utcnow().isoformat(),
        }
        
        # ✅ Получаем group_index из Form (индекс документа в documents_required)
        form_params = await request.form()
        group_index = form_params.get("group_index")
        if group_index:
            form_data["group_index"] = group_index
            logger.info(f"📋 group_index передан в n8n: {group_index}")
        
        # Добавляем информацию о каждом файле
        for i, (file, file_id) in enumerate(zip(files, file_ids)):
            form_data[f"file_ids[{i}]"] = file_id
            form_data[f"uploads_field_names[{i}]"] = document_type
            form_data[f"uploads_field_labels[{i}]"] = document_name or document_type
            form_data[f"uploads_descriptions[{i}]"] = document_description or ""
            form_data[f"original_filenames[{i}]"] = file.filename
        
        # Отправляем в n8n одним запросом
        async with httpx.AsyncClient(timeout=180.0) as client:
            response = await client.post(
                N8N_DOCUMENT_UPLOAD_WEBHOOK,
                data=form_data,
                files=files_multipart,
            )
        
        response_text = response.text or ""
        
        if response.status_code == 200:
            logger.info(
                "✅ Multiple documents uploaded to n8n",
                extra={
                    "claim_id": claim_id,
                    "document_type": document_type,
                    "file_ids": file_ids,
                    "files_count": len(files),
                },
            )
            
            # Парсим ответ от n8n
            try:
                n8n_response = json.loads(response_text)
            except json.JSONDecodeError:
                n8n_response = {"raw": response_text}
            
            # Публикуем событие в Redis
            event_data = {
                "event_type": "documents_uploaded",
                "status": "processing",
                "claim_id": claim_id,
                "session_id": session_id,
                "document_type": document_type,
                "file_ids": file_ids,
                "files_count": len(files),
                "original_filenames": [f.filename for f in files],
                "timestamp": datetime.utcnow().isoformat(),
            }
            
            await redis_service.publish(
                f"ocr_events:{session_id}",
                json.dumps(event_data, ensure_ascii=False)
            )
            
            return {
                "success": True,
                "file_ids": file_ids,
                "files_count": len(files),
                "document_type": document_type,
                "ocr_status": "processing",
                "message": f"Загружено {len(files)} файл(ов)",
                "n8n_response": n8n_response,
            }
        
        else:
            logger.error(
                "❌ n8n multiple upload error",
                extra={
                    "status_code": response.status_code,
                    "body": response_text[:500],
                },
            )
            raise HTTPException(
                status_code=response.status_code,
                detail=f"Ошибка n8n: {response_text}",
            )
    
    except httpx.TimeoutException:
        logger.error("⏱️ n8n multiple upload timeout")
        raise HTTPException(status_code=504, detail="Таймаут загрузки документов")
    
    except HTTPException:
        raise
    
    except Exception as e:
        logger.exception("❌ Multiple upload error")
        raise HTTPException(
            status_code=500,
            detail=f"Ошибка загрузки документов: {str(e)}",
        )


@router.get("/status/{claim_id}")
async def get_documents_status(claim_id: str):
    """
    Получить статус обработки документов для заявки.
    
    Возвращает:
    - Список загруженных документов и их OCR статус
    - Общий прогресс обработки
    """
    try:
        # TODO: Запрос в PostgreSQL для получения статуса документов
        # Пока возвращаем mock данные
        
        return {
            "success": True,
            "claim_id": claim_id,
            "documents": [],
            "ocr_progress": {
                "total": 0,
                "completed": 0,
                "processing": 0,
                "failed": 0,
            },
            "wizard_ready": False,
            "claim_ready": False,
        }
    
    except Exception as e:
        logger.exception("❌ Error getting documents status")
        raise HTTPException(
            status_code=500,
            detail=f"Ошибка получения статуса: {str(e)}",
        )



async def skip_document(
    request: Request,
    claim_id: str = Form(...),
    session_id: str = Form(...),
    document_type: str = Form(...),
    document_name: Optional[str] = Form(None),
    group_index: Optional[str] = Form(None),
    unified_id: Optional[str] = Form(None),
    contact_id: Optional[str] = Form(None),
    phone: Optional[str] = Form(None),
):
    """
    Пропуск документа (пользователь указал, что документа нет).
    
    Отправляет событие в n8n на тот же webhook, что и загрузка файлов,
    но с флагом skipped=true для обработки пропуска.
    """
    try:
        logger.info(
            "⏭️ Document skip received",
            extra={
                "claim_id": claim_id,
                "session_id": session_id,
                "document_type": document_type,
                "group_index": group_index,
            },
        )
        
        # Получаем IP клиента
        client_ip = request.client.host if request.client else "unknown"
        forwarded_for = request.headers.get("x-forwarded-for", "").split(",")[0].strip()
        if forwarded_for:
            client_ip = forwarded_for
        
        # Формируем данные в формате совместимом с существующим n8n воркфлоу
        form_data = {
            # Основные идентификаторы
            "form_id": "ticket_form",
            "stage": "document_skip",
            "session_id": session_id,
            "claim_id": claim_id,
            "client_ip": client_ip,
            
            # Идентификаторы пользователя
            "unified_id": unified_id or "",
            "contact_id": contact_id or "",
            "phone": phone or "",
            
            # Информация о документе
            "document_type": document_type,
            "document_name": document_name or document_type,
            "skipped": "true",  # ✅ Флаг пропуска документа
            "action": "skip",  # ✅ Действие: пропуск
            "skip_timestamp": datetime.utcnow().isoformat(),
            
            # Формат uploads_* для совместимости (без файлов)
            # ✅ Используем group_index для правильной индексации (по умолчанию 0)
            "uploads_field_names[{idx}]".format(idx=group_index or "0"): document_type,
            "uploads_field_labels[{idx}]".format(idx=group_index or "0"): document_name or document_type,
            "uploads_descriptions[{idx}]".format(idx=group_index or "0"): "",
            "files_count": "0",  # ✅ Нет файлов
        }
        
        # ✅ Добавляем group_index в данные формы
        if group_index:
            form_data["group_index"] = group_index
            logger.info(f"📋 group_index передан в n8n: {group_index}")
        
        # Отправляем в n8n на тот же webhook (без файлов)
        async with httpx.AsyncClient(timeout=60.0) as client:
            response = await client.post(
                N8N_DOCUMENT_UPLOAD_WEBHOOK,
                data=form_data,
            )
        
        response_text = response.text or ""
        
        if response.status_code == 200:
            logger.info(
                "✅ Document skip sent to n8n",
                extra={
                    "claim_id": claim_id,
                    "document_type": document_type,
                    "response_preview": response_text[:200],
                },
            )
            
            # Парсим ответ от n8n
            try:
                n8n_response = json.loads(response_text)
            except json.JSONDecodeError:
                n8n_response = {"raw": response_text}
            
            # Публикуем событие в Redis для фронтенда
            event_data = {
                "event_type": "document_skipped",
                "status": "skipped",
                "claim_id": claim_id,
                "session_id": session_id,
                "document_type": document_type,
                "document_name": document_name or document_type,
                "timestamp": datetime.utcnow().isoformat(),
            }
            
            await redis_service.publish(
                f"ocr_events:{session_id}",
                json.dumps(event_data, ensure_ascii=False)
            )
            
            return {
                "success": True,
                "document_type": document_type,
                "status": "skipped",
                "message": "Документ пропущен и сохранён",
                "n8n_response": n8n_response,
            }
        
        else:
            logger.error(
                "❌ n8n document skip error",
                extra={
                    "status_code": response.status_code,
                    "body": response_text[:500],
                },
            )
            raise HTTPException(
                status_code=response.status_code,
                detail=f"Ошибка n8n: {response_text}",
            )
    
    except httpx.TimeoutException:
        logger.error("⏱️ n8n document skip timeout")
        raise HTTPException(status_code=504, detail="Таймаут отправки пропуска документа")
    
    except HTTPException:
        raise
    
    except Exception as e:
        logger.exception("❌ Document skip error")
        raise HTTPException(status_code=500, detail=f"Ошибка пропуска документа: {str(e)}")



@router.post("/generate-list")
async def generate_documents_list(request: Request):
    """
    Запрос на генерацию списка документов для проблемы.
    
    Принимает описание проблемы, отправляет в n8n для быстрого AI-анализа.
    n8n публикует результат в Redis канал ocr_events:{session_id} с event_type=documents_list_ready.
    """
    try:
        body = await request.json()
        
        session_id = body.get("session_id")
        problem_description = body.get("problem_description")
        
        if not session_id or not problem_description:
            raise HTTPException(
                status_code=400,
                detail="session_id и problem_description обязательны",
            )
        
        logger.info(
            "📝 Generate documents list request",
            extra={
                "session_id": session_id,
                "description_length": len(problem_description),
            },
        )
        
        # Публикуем событие в Redis для n8n
        event_data = {
            "type": "generate_documents_list",
            "session_id": session_id,
            "claim_id": body.get("claim_id"),
            "unified_id": body.get("unified_id"),
            "phone": body.get("phone"),
            "problem_description": problem_description,
            "timestamp": datetime.utcnow().isoformat(),
        }
        
        channel = f"{settings.redis_prefix}documents_list"
        
        subscribers = await redis_service.publish(
            channel,
            json.dumps(event_data, ensure_ascii=False)
        )
        
        logger.info(
            "✅ Documents list request published",
            extra={
                "channel": channel,
                "subscribers": subscribers,
            },
        )
        
        return {
            "success": True,
            "message": "Запрос на генерацию списка документов отправлен",
            "channel": channel,
        }
    
    except HTTPException:
        raise
    
    except Exception as e:
        logger.exception("❌ Error generating documents list")
        raise HTTPException(
            status_code=500,
            detail=f"Ошибка генерации списка: {str(e)}",
        )




router.add_api_route("/skip", skip_document, methods=["POST"], tags=["Documents"])