# app.py - Основное FastAPI приложение
from fastapi import FastAPI, UploadFile, File, Form, WebSocket, WebSocketDisconnect
from fastapi.responses import HTMLResponse, JSONResponse, FileResponse
from fastapi.staticfiles import StaticFiles
from fastapi.templating import Jinja2Templates
from fastapi.middleware.cors import CORSMiddleware
from pydantic import BaseModel
import whisper
import openai
import asyncio
import json
import os
import tempfile
import uuid
import logging
from typing import Optional, List
from datetime import datetime
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate
from langchain.chat_models import ChatOpenAI
from dataclasses import dataclass
import soundfile as sf
import numpy as np
from concurrent.futures import ThreadPoolExecutor
import aiofiles

# Настройка логирования
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Модели данных
class TranscriptionRequest(BaseModel):
    audio_data: Optional[str] = None  # base64 encoded
    language: str = "ru"

class SummaryRequest(BaseModel):
    text: str
    summary_type: str = "detailed"  # detailed, brief, bullet

class AudioFileRequest(BaseModel):
    filename: str
    content_type: str

# Конфигурация
@dataclass
class Config:
    WHISPER_MODEL_SIZE = "base"
    OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", "")
    SAMPLE_RATE = 16000
    CHUNK_SIZE = 1024
    MAX_FILE_SIZE = 50 * 1024 * 1024  # 50MB

    # Пути
    UPLOAD_FOLDER = "uploads"
    STATIC_FOLDER = "static"
    TEMPLATES_FOLDER = "templates"

# Создание директорий
os.makedirs(Config.UPLOAD_FOLDER, exist_ok=True)
os.makedirs(Config.STATIC_FOLDER, exist_ok=True)
os.makedirs(Config.TEMPLATES_FOLDER, exist_ok=True)

# Инициализация приложения
app = FastAPI(
    title="Audio to Summary AI",
    description="Веб-приложение для преобразования звука в текст и создания конспектов",
    version="1.0.0"
)

# CORS middleware
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# Монтирование статических файлов
app.mount("/static", StaticFiles(directory=Config.STATIC_FOLDER), name="static")
templates = Jinja2Templates(directory=Config.TEMPLATES_FOLDER)

# Глобальные переменные
whisper_model = None
llm_chain = None
executor = ThreadPoolExecutor(max_workers=4)

# Инициализация моделей
async def init_models():
    """Инициализация AI моделей"""
    global whisper_model, llm_chain

    logger.info("Инициализация моделей...")

    # Загрузка Whisper модели
    try:
        whisper_model = whisper.load_model(Config.WHISPER_MODEL_SIZE)
        logger.info(f"Whisper модель '{Config.WHISPER_MODEL_SIZE}' загружена")
    except Exception as e:
        logger.error(f"Ошибка загрузки Whisper: {e}")

    # Инициализация LangChain для конспектов
    if Config.OPENAI_API_KEY:
        try:
            llm = ChatOpenAI(
                openai_api_key=Config.OPENAI_API_KEY,
                model_name="gpt-3.5-turbo",
                temperature=0.3,
                max_tokens=1000
            )

            prompt_template = PromptTemplate(
                input_variables=["text", "summary_type"],
                template="""
                На основе предоставленного текста создай конспект следующего типа: {summary_type}

                Варианты типов:
                - detailed: Детальный структурированный конспект с разделами
                - brief: Краткое изложение (3-5 предложений)
                - bullet: Маркированный список ключевых пунктов

                Текст:
                {text}

                Конспект:
                """
            )

            llm_chain = LLMChain(llm=llm, prompt=prompt_template)
            logger.info("LangChain модель инициализирована")
        except Exception as e:
            logger.error(f"Ошибка инициализации LangChain: {e}")
    else:
        logger.warning("OPENAI_API_KEY не установлен, функция конспектов отключена")

@app.on_event("startup")
async def startup_event():
    """Запуск при старте приложения"""
    await init_models()

# 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 send_personal_message(self, message: str, websocket: WebSocket):
        await websocket.send_text(message)

    async def broadcast(self, message: str):
        for connection in self.active_connections:
            await connection.send_text(message)

manager = ConnectionManager()

# Вспомогательные функции
def save_audio_file(file_content: bytes, extension: str = "wav") -> str:
    """Сохранение аудиофайла"""
    filename = f"{uuid.uuid4()}.{extension}"
    filepath = os.path.join(Config.UPLOAD_FOLDER, filename)

    with open(filepath, "wb") as f:
        f.write(file_content)

    return filepath

def transcribe_audio(audio_path: str, language: str = "ru") -> str:
    """Транскрибирование аудио с помощью Whisper"""
    try:
        result = whisper_model.transcribe(
            audio_path,
            language=language,
            fp16=False,
            task="transcribe"
        )
        return result["text"]
    except Exception as e:
        logger.error(f"Ошибка транскрибирования: {e}")
        raise

def generate_summary(text: str, summary_type: str = "detailed") -> str:
    """Генерация конспекта"""
    if not llm_chain:
        raise ValueError("LLM модель не инициализирована. Проверьте OPENAI_API_KEY.")

    try:
        # Разбиваем текст если он слишком длинный
        text_splitter = RecursiveCharacterTextSplitter(
            chunk_size=3000,
            chunk_overlap=200,
            length_function=len,
        )

        chunks = text_splitter.split_text(text)

        if len(chunks) == 1:
            result = llm_chain.run(text=text, summary_type=summary_type)
            return result
        else:
            # Обрабатываем каждый чанк и объединяем результаты
            summaries = []
            for chunk in chunks:
                summary = llm_chain.run(text=chunk, summary_type=summary_type)
                summaries.append(summary)

            # Объединяем все конспекты
            combined_summary = "\n\n".join(summaries)

            # Создаем финальный обобщенный конспект
            final_summary = llm_chain.run(
                text=combined_summary,
                summary_type="brief"
            )
            return final_summary

    except Exception as e:
        logger.error(f"Ошибка генерации конспекта: {e}")
        raise

# API endpoints
@app.get("/", response_class=HTMLResponse)
async def read_root():
    """Главная страница"""
    html_content = """
    <!DOCTYPE html>
    <html lang="ru">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Audio to Summary AI</title>
        <style>
            * {
                margin: 0;
                padding: 0;
                box-sizing: border-box;
            }

            body {
                font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, sans-serif;
                background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
                min-height: 100vh;
                padding: 20px;
            }

            .container {
                max-width: 1200px;
                margin: 0 auto;
                background: white;
                border-radius: 20px;
                box-shadow: 0 20px 60px rgba(0,0,0,0.3);
                overflow: hidden;
            }

            header {
                background: linear-gradient(90deg, #4f46e5, #7c3aed);
                color: white;
                padding: 30px;
                text-align: center;
            }

            h1 {
                font-size: 2.5rem;
                margin-bottom: 10px;
            }

            .subtitle {
                font-size: 1.2rem;
                opacity: 0.9;
                margin-bottom: 20px;
            }

            .main-content {
                display: grid;
                grid-template-columns: 1fr 1fr;
                gap: 30px;
                padding: 30px;
            }

            @media (max-width: 768px) {
                .main-content {
                    grid-template-columns: 1fr;
                }
            }

            .panel {
                background: #f8fafc;
                border-radius: 15px;
                padding: 25px;
                border: 1px solid #e2e8f0;
            }

            .panel h2 {
                color: #1e293b;
                margin-bottom: 20px;
                font-size: 1.5rem;
                display: flex;
                align-items: center;
                gap: 10px;
            }

            .panel h2 i {
                color: #4f46e5;
            }

            .controls {
                display: flex;
                gap: 15px;
                margin-bottom: 20px;
                flex-wrap: wrap;
            }

            button {
                padding: 12px 24px;
                border: none;
                border-radius: 10px;
                font-size: 1rem;
                font-weight: 600;
                cursor: pointer;
                transition: all 0.3s ease;
                display: flex;
                align-items: center;
                gap: 8px;
            }

            .btn-primary {
                background: linear-gradient(90deg, #4f46e5, #7c3aed);
                color: white;
            }

            .btn-primary:hover {
                transform: translateY(-2px);
                box-shadow: 0 5px 15px rgba(79, 70, 229, 0.4);
            }

            .btn-secondary {
                background: #e2e8f0;
                color: #475569;
            }

            .btn-secondary:hover {
                background: #cbd5e1;
            }

            .btn-danger {
                background: #ef4444;
                color: white;
            }

            .btn-danger:hover {
                background: #dc2626;
            }

            .status {
                padding: 15px;
                border-radius: 10px;
                margin-bottom: 20px;
                font-weight: 600;
            }

            .status.recording {
                background: #fee2e2;
                color: #dc2626;
                border: 2px solid #fca5a5;
            }

            .status.processing {
                background: #fef3c7;
                color: #d97706;
                border: 2px solid #fbbf24;
            }

            .status.success {
                background: #d1fae5;
                color: #059669;
                border: 2px solid #34d399;
            }

            textarea {
                width: 100%;
                min-height: 200px;
                padding: 15px;
                border: 2px solid #e2e8f0;
                border-radius: 10px;
                font-size: 1rem;
                font-family: inherit;
                resize: vertical;
                margin-bottom: 15px;
            }

            textarea:focus {
                outline: none;
                border-color: #4f46e5;
            }

            .file-input {
                width: 100%;
                padding: 15px;
                border: 2px dashed #cbd5e1;
                border-radius: 10px;
                text-align: center;
                margin-bottom: 20px;
                cursor: pointer;
                transition: border-color 0.3s;
            }

            .file-input:hover {
                border-color: #4f46e5;
            }

            .summary-type {
                display: flex;
                gap: 10px;
                margin-bottom: 20px;
            }

            .summary-type label {
                flex: 1;
                padding: 10px;
                border: 2px solid #e2e8f0;
                border-radius: 8px;
                text-align: center;
                cursor: pointer;
                transition: all 0.3s;
            }

            .summary-type input:checked + label {
                background: #4f46e5;
                color: white;
                border-color: #4f46e5;
            }

            .hidden {
                display: none;
            }

            .audio-visualizer {
                height: 100px;
                background: #1e293b;
                border-radius: 10px;
                margin-bottom: 20px;
                overflow: hidden;
            }

            .loading {
                display: inline-block;
                width: 20px;
                height: 20px;
                border: 3px solid #e2e8f0;
                border-top: 3px solid #4f46e5;
                border-radius: 50%;
                animation: spin 1s linear infinite;
            }

            @keyframes spin {
                0% { transform: rotate(0deg); }
                100% { transform: rotate(360deg); }
            }

            footer {
                text-align: center;
                padding: 20px;
                color: #64748b;
                border-top: 1px solid #e2e8f0;
            }

            .icon {
                font-size: 1.2em;
            }
        </style>
        <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0/css/all.min.css">
    </head>
    <body>
        <div class="container">
            <header>
                <h1><i class="fas fa-microphone-alt icon"></i> Audio to Summary AI</h1>
                <p class="subtitle">Преобразуйте речь в текст и создавайте интеллектуальные конспекты</p>
            </header>

            <div class="main-content">
                <!-- Левая панель: Аудио -->
                <div class="panel">
                    <h2><i class="fas fa-microphone icon"></i> Запись аудио</h2>

                    <div class="controls">
                        <button id="startRecord" class="btn-primary">
                            <i class="fas fa-record-vinyl"></i> Начать запись
                        </button>
                        <button id="stopRecord" class="btn-danger" disabled>
                            <i class="fas fa-stop"></i> Остановить
                        </button>
                        <button id="uploadFile" class="btn-secondary">
                            <i class="fas fa-upload"></i> Загрузить файл
                        </button>
                    </div>

                    <div class="audio-visualizer" id="visualizer">
                        <!-- Визуализатор аудио -->
                    </div>

                    <div class="status hidden" id="status"></div>

                    <div class="file-input" id="dropZone">
                        <i class="fas fa-cloud-upload-alt" style="font-size: 2em; color: #94a3b8; margin-bottom: 10px;"></i>
                        <p>Перетащите аудиофайл сюда или кликните для выбора</p>
                        <p style="font-size: 0.9em; color: #64748b; margin-top: 10px;">
                            Поддерживаемые форматы: MP3, WAV, M4A, OGG
                        </p>
                        <input type="file" id="audioFile" accept="audio/*" class="hidden">
                    </div>

                    <div class="controls">
                        <button id="transcribeBtn" class="btn-primary" disabled>
                            <i class="fas fa-language"></i> Транскрибировать
                        </button>
                        <button id="clearBtn" class="btn-secondary">
                            <i class="fas fa-trash"></i> Очистить
                        </button>
                    </div>
                </div>

                <!-- Правая панель: Текст и конспект -->
                <div class="panel">
                    <h2><i class="fas fa-file-alt icon"></i> Текст и конспект</h2>

                    <textarea id="transcription" placeholder="Транскрипция появится здесь..."></textarea>

                    <div class="summary-type">
                        <input type="radio" id="detailed" name="summaryType" value="detailed" checked>
                        <label for="detailed">Детальный</label>

                        <input type="radio" id="brief" name="summaryType" value="brief">
                        <label for="brief">Краткий</label>

                        <input type="radio" id="bullet" name="summaryType" value="bullet">
                        <label for="bullet">Список</label>
                    </div>

                    <div class="controls">
                        <button id="summarizeBtn" class="btn-primary" disabled>
                            <i class="fas fa-brain"></i> Создать конспект
                        </button>
                        <button id="copyBtn" class="btn-secondary" disabled>
                            <i class="fas fa-copy"></i> Копировать
                        </button>
                        <button id="downloadBtn" class="btn-secondary" disabled>
                            <i class="fas fa-download"></i> Скачать
                        </button>
                    </div>

                    <textarea id="summary" placeholder="Конспект появится здесь..." readonly></textarea>
                </div>
            </div>

            <footer>
                <p>Audio to Summary AI &copy; 2024 | Преобразование речи в текст с помощью нейросетей</p>
            </footer>
        </div>

        <script>
            // Глобальные переменные
            let mediaRecorder = null;
            let audioChunks = [];
            let isRecording = false;
            let audioContext = null;
            let analyser = null;
            let dataArray = null;

            // Элементы DOM
            const startBtn = document.getElementById('startRecord');
            const stopBtn = document.getElementById('stopRecord');
            const uploadBtn = document.getElementById('uploadFile');
            const transcribeBtn = document.getElementById('transcribeBtn');
            const clearBtn = document.getElementById('clearBtn');
            const summarizeBtn = document.getElementById('summarizeBtn');
            const copyBtn = document.getElementById('copyBtn');
            const downloadBtn = document.getElementById('downloadBtn');
            const audioFile = document.getElementById('audioFile');
            const dropZone = document.getElementById('dropZone');
            const transcriptionArea = document.getElementById('transcription');
            const summaryArea = document.getElementById('summary');
            const statusDiv = document.getElementById('status');
            const visualizer = document.getElementById('visualizer');

            // WebSocket соединение
            let ws = null;

            function connectWebSocket() {
                const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
                const wsUrl = `${protocol}//${window.location.host}/ws`;

                ws = new WebSocket(wsUrl);

                ws.onopen = () => {
                    console.log('WebSocket подключен');
                    showStatus('Готов к записи', 'success');
                };

                ws.onmessage = (event) => {
                    const data = JSON.parse(event.data);
                    handleWebSocketMessage(data);
                };

                ws.onerror = (error) => {
                    console.error('WebSocket ошибка:', error);
                    showStatus('Ошибка соединения', 'recording');
                };

                ws.onclose = () => {
                    console.log('WebSocket отключен');
                    setTimeout(connectWebSocket, 3000);
                };
            }

            function handleWebSocketMessage(data) {
                switch(data.type) {
                    case 'transcription':
                        transcriptionArea.value = data.text;
                        transcribeBtn.disabled = false;
                        summarizeBtn.disabled = false;
                        showStatus('Транскрибирование завершено', 'success');
                        break;

                    case 'summary':
                        summaryArea.value = data.text;
                        copyBtn.disabled = false;
                        downloadBtn.disabled = false;
                        showStatus('Конспект создан', 'success');
                        break;

                    case 'error':
                        showStatus(data.message, 'recording');
                        break;

                    case 'status':
                        showStatus(data.message, 'processing');
                        break;
                }
            }

            // Управление записью
            startBtn.addEventListener('click', async () => {
                try {
                    const stream = await navigator.mediaDevices.getUserMedia({
                        audio: {
                            echoCancellation: true,
                            noiseSuppression: true,
                            sampleRate: 16000
                        }
                    });

                    // Настройка визуализатора
                    setupAudioVisualizer(stream);

                    mediaRecorder = new MediaRecorder(stream, {
                        mimeType: 'audio/webm;codecs=opus'
                    });

                    mediaRecorder.ondataavailable = (event) => {
                        if (event.data.size > 0) {
                            audioChunks.push(event.data);
                        }
                    };

                    mediaRecorder.onstop = async () => {
                        const audioBlob = new Blob(audioChunks, { type: 'audio/webm' });
                        await sendAudioToServer(audioBlob);
                        audioChunks = [];

                        // Остановка визуализатора
                        if (audioContext) {
                            audioContext.close();
                        }
                    };

                    mediaRecorder.start(1000); // Собираем данные каждую секунду
                    isRecording = true;

                    startBtn.disabled = true;
                    stopBtn.disabled = false;

                    showStatus('Идет запись...', 'recording');

                } catch (error) {
                    console.error('Ошибка доступа к микрофону:', error);
                    showStatus('Ошибка доступа к микрофону', 'recording');
                }
            });

            stopBtn.addEventListener('click', () => {
                if (mediaRecorder && isRecording) {
                    mediaRecorder.stop();
                    isRecording = false;

                    startBtn.disabled = false;
                    stopBtn.disabled = true;

                    showStatus('Обработка записи...', 'processing');

                    // Остановка всех треков
                    mediaRecorder.stream.getTracks().forEach(track => track.stop());
                }
            });

            function setupAudioVisualizer(stream) {
                audioContext = new (window.AudioContext || window.webkitAudioContext)();
                analyser = audioContext.createAnalyser();
                const source = audioContext.createMediaStreamSource(stream);

                source.connect(analyser);
                analyser.fftSize = 256;
                const bufferLength = analyser.frequencyBinCount;
                dataArray = new Uint8Array(bufferLength);

                drawVisualizer();
            }

            function drawVisualizer() {
                if (!isRecording || !analyser) return;

                requestAnimationFrame(drawVisualizer);

                analyser.getByteFrequencyData(dataArray);

                const width = visualizer.clientWidth;
                const height = visualizer.clientHeight;
                const barWidth = (width / dataArray.length) * 2.5;

                let canvas = visualizer.querySelector('canvas');
                if (!canvas) {
                    canvas = document.createElement('canvas');
                    visualizer.innerHTML = '';
                    visualizer.appendChild(canvas);
                }

                canvas.width = width;
                canvas.height = height;

                const ctx = canvas.getContext('2d');
                ctx.clearRect(0, 0, width, height);

                let barHeight;
                let x = 0;

                for(let i = 0; i < bufferLength; i++) {
                    barHeight = dataArray[i] * 2;

                    const gradient = ctx.createLinearGradient(0, 0, 0, height);
                    gradient.addColorStop(0, '#4f46e5');
                    gradient.addColorStop(1, '#7c3aed');

                    ctx.fillStyle = gradient;
                    ctx.fillRect(x, height - barHeight, barWidth, barHeight);

                    x += barWidth + 1;
                }
            }

            // Загрузка файлов
            dropZone.addEventListener('click', () => {
                audioFile.click();
            });

            audioFile.addEventListener('change', async (e) => {
                const file = e.target.files[0];
                if (file) {
                    await handleAudioFile(file);
                }
            });

            // Drag and drop
            dropZone.addEventListener('dragover', (e) => {
                e.preventDefault();
                dropZone.style.borderColor = '#4f46e5';
                dropZone.style.background = '#f1f5f9';
            });

            dropZone.addEventListener('dragleave', () => {
                dropZone.style.borderColor = '#cbd5e1';
                dropZone.style.background = '';
            });

            dropZone.addEventListener('drop', async (e) => {
                e.preventDefault();
                dropZone.style.borderColor = '#cbd5e1';
                dropZone.style.background = '';

                const file = e.dataTransfer.files[0];
                if (file && file.type.startsWith('audio/')) {
                    await handleAudioFile(file);
                } else {
                    showStatus('Пожалуйста, выберите аудиофайл', 'recording');
                }
            });

            async function handleAudioFile(file) {
                showStatus('Загружаем файл...', 'processing');

                const formData = new FormData();
                formData.append('file', file);

                try {
                    const response = await fetch('/upload', {
                        method: 'POST',
                        body: formData
                    });

                    const result = await response.json();

                    if (response.ok) {
                        showStatus('Файл загружен', 'success');
                        transcribeBtn.disabled = false;
                        // Автоматически транскрибируем
                        transcribeAudio(result.filename);
                    } else {
                        showStatus(result.detail || 'Ошибка загрузки', 'recording');
                    }
                } catch (error) {
                    console.error('Ошибка загрузки файла:', error);
                    showStatus('Ошибка загрузки файла', 'recording');
                }
            }

            async function sendAudioToServer(audioBlob) {
                const formData = new FormData();
                formData.append('file', audioBlob, 'recording.webm');

                try {
                    const response = await fetch('/upload', {
                        method: 'POST',
                        body: formData
                    });

                    const result = await response.json();

                    if (response.ok) {
                        transcribeAudio(result.filename);
                    }
                } catch (error) {
                    console.error('Ошибка отправки аудио:', error);
                    showStatus('Ошибка отправки аудио', 'recording');
                }
            }

            async function transcribeAudio(filename) {
                showStatus('Транскрибируем...', 'processing');

                try {
                    const response = await fetch('/transcribe', {
                        method: 'POST',
                        headers: {
                            'Content-Type': 'application/json',
                        },
                        body: JSON.stringify({
                            filename: filename,
                            language: 'ru'
                        })
                    });

                    const result = await response.json();

                    if (response.ok) {
                        transcriptionArea.value = result.transcription;
                        transcribeBtn.disabled = false;
                        summarizeBtn.disabled = false;
                        showStatus('Транскрибирование завершено', 'success');
                    } else {
                        showStatus(result.detail || 'Ошибка транскрибирования', 'recording');
                    }
                } catch (error) {
                    console.error('Ошибка транскрибирования:', error);
                    showStatus('Ошибка транскрибирования', 'recording');
                }
            }

            // Создание конспекта
            summarizeBtn.addEventListener('click', async () => {
                const text = transcriptionArea.value;
                const summaryType = document.querySelector('input[name="summaryType"]:checked').value;

                if (!text.trim()) {
                    showStatus('Сначала создайте транскрипцию', 'recording');
                    return;
                }

                showStatus('Создаем конспект...', 'processing');

                try {
                    const response = await fetch('/summarize', {
                        method: 'POST',
                        headers: {
                            'Content-Type': 'application/json',
                        },
                        body: JSON.stringify({
                            text: text,
                            summary_type: summaryType
                        })
                    });

                    const result = await response.json();

                    if (response.ok) {
                        summaryArea.value = result.summary;
                        copyBtn.disabled = false;
                        downloadBtn.disabled = false;
                        showStatus('Конспект создан', 'success');
                    } else {
                        showStatus(result.detail || 'Ошибка создания конспекта', 'recording');
                    }
                } catch (error) {
                    console.error('Ошибка создания конспекта:', error);
                    showStatus('Ошибка создания конспекта', 'recording');
                }
            });

            // Вспомогательные функции
            clearBtn.addEventListener('click', () => {
                transcriptionArea.value = '';
                summaryArea.value = '';
                transcribeBtn.disabled = true;
                summarizeBtn.disabled = true;
                copyBtn.disabled = true;
                downloadBtn.disabled = true;
                showStatus('Очищено', 'success');
            });

            copyBtn.addEventListener('click', () => {
                summaryArea.select();
                document.execCommand('copy');
                showStatus('Скопировано в буфер', 'success');
            });

            downloadBtn.addEventListener('click', () => {
                const text = summaryArea.value;
                const blob = new Blob([text], { type: 'text/plain' });
                const url = URL.createObjectURL(blob);
                const a = document.createElement('a');
                a.href = url;
                a.download = `конспект_${new Date().toISOString().slice(0, 10)}.txt`;
                document.body.appendChild(a);
                a.click();
                document.body.removeChild(a);
                URL.revokeObjectURL(url);
            });

            function showStatus(message, type) {
                statusDiv.textContent = message;
                statusDiv.className = `status ${type}`;
                statusDiv.classList.remove('hidden');

                if (type === 'success') {
                    setTimeout(() => {
                        statusDiv.classList.add('hidden');
                    }, 3000);
                }
            }

            // Инициализация
            connectWebSocket();

            // Проверка поддержки MediaRecorder
            if (!navigator.mediaDevices || !navigator.mediaDevices.getUserMedia) {
                showStatus('Ваш браузер не поддерживает запись аудио', 'recording');
                startBtn.disabled = true;
            }

            if (!window.MediaRecorder) {
                showStatus('MediaRecorder не поддерживается', 'recording');
                startBtn.disabled = true;
            }
        </script>
    </body>
    </html>
    """
    return HTMLResponse(content=html_content)

@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket):
    """WebSocket endpoint для реального времени"""
    await manager.connect(websocket)
    try:
        while True:
            data = await websocket.receive_text()
            # Обработка сообщений от клиента
            message = json.loads(data)
            await handle_websocket_message(message, websocket)
    except WebSocketDisconnect:
        manager.disconnect(websocket)

async def handle_websocket_message(message: dict, websocket: WebSocket):
    """Обработка WebSocket сообщений"""
    message_type = message.get("type")

    if message_type == "audio_chunk":
        # Обработка аудио чанков в реальном времени
        await process_realtime_audio(message["data"], websocket)
    elif message_type == "transcribe":
        await websocket.send_json({
            "type": "status",
            "message": "Транскрибирование начато"
        })
    elif message_type == "summarize":
        await websocket.send_json({
            "type": "status",
            "message": "Создание конспекта начато"
        })

async def process_realtime_audio(audio_data: str, websocket: WebSocket):
    """Обработка аудио в реальном времени"""
    try:
        # Декодирование base64 аудио
        import base64
        audio_bytes = base64.b64decode(audio_data)

        # Сохранение во временный файл
        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tmp_file:
            tmp_file.write(audio_bytes)
            tmp_path = tmp_file.name

        # Транскрибирование
        loop = asyncio.get_event_loop()
        transcription = await loop.run_in_executor(
            executor,
            transcribe_audio,
            tmp_path,
            "ru"
        )

        # Отправка результата
        await websocket.send_json({
            "type": "transcription",
            "text": transcription
        })

        # Удаление временного файла
        os.unlink(tmp_path)

    except Exception as e:
        logger.error(f"Ошибка обработки аудио: {e}")
        await websocket.send_json({
            "type": "error",
            "message": f"Ошибка обработки аудио: {str(e)}"
        })

@app.post("/upload")
async def upload_audio_file(file: UploadFile = File(...)):
    """Загрузка аудиофайла"""
    try:
        # Проверка размера файла
        file.file.seek(0, 2)  # Перемещаемся в конец файла
        file_size = file.file.tell()
        file.file.seek(0)  # Возвращаемся в начало

        if file_size > Config.MAX_FILE_SIZE:
            return JSONResponse(
                status_code=400,
                content={"detail": "Файл слишком большой. Максимум 50MB"}
            )

        # Проверка типа файла
        if not file.content_type.startswith("audio/"):
            return JSONResponse(
                status_code=400,
                content={"detail": "Пожалуйста, загрузите аудиофайл"}
            )

        # Чтение файла
        contents = await file.read()

        # Определение расширения
        extension = file.filename.split(".")[-1] if "." in file.filename else "wav"

        # Сохранение файла
        filename = f"{uuid.uuid4()}.{extension}"
        filepath = os.path.join(Config.UPLOAD_FOLDER, filename)

        async with aiofiles.open(filepath, "wb") as f:
            await f.write(contents)

        return {"filename": filename, "message": "Файл успешно загружен"}

    except Exception as e:
        logger.error(f"Ошибка загрузки файла: {e}")
        return JSONResponse(
            status_code=500,
            content={"detail": f"Ошибка загрузки файла: {str(e)}"}
        )

@app.post("/transcribe")
async def transcribe_endpoint(request: dict):
    """Транскрибирование аудиофайла"""
    try:
        filename = request.get("filename")
        language = request.get("language", "ru")

        if not filename:
            return JSONResponse(
                status_code=400,
                content={"detail": "Не указано имя файла"}
            )

        filepath = os.path.join(Config.UPLOAD_FOLDER, filename)

        if not os.path.exists(filepath):
            return JSONResponse(
                status_code=404,
                content={"detail": "Файл не найден"}
            )

        # Транскрибирование
        loop = asyncio.get_event_loop()
        transcription = await loop.run_in_executor(
            executor,
            transcribe_audio,
            filepath,
            language
        )

        return {
            "transcription": transcription,
            "filename": filename,
            "language": language
        }

    except Exception as e:
        logger.error(f"Ошибка транскрибирования: {e}")
        return JSONResponse(
            status_code=500,
            content={"detail": f"Ошибка транскрибирования: {str(e)}"}
        )

@app.post("/summarize")
async def summarize_endpoint(request: SummaryRequest):
    """Создание конспекта из текста"""
    try:
        if not llm_chain:
            return JSONResponse(
                status_code=400,
                content={"detail": "OpenAI API ключ не настроен. Функция конспектов недоступна."}
            )

        if not request.text.strip():
            return JSONResponse(
                status_code=400,
                content={"detail": "Текст не может быть пустым"}
            )

        # Генерация конспекта
        loop = asyncio.get_event_loop()
        summary = await loop.run_in_executor(
            executor,
            generate_summary,
            request.text,
            request.summary_type
        )

        return {
            "summary": summary,
            "summary_type": request.summary_type,
            "length": len(summary)
        }

    except ValueError as e:
        return JSONResponse(
            status_code=400,
            content={"detail": str(e)}
        )
    except Exception as e:
        logger.error(f"Ошибка создания конспекта: {e}")
        return JSONResponse(
            status_code=500,
            content={"detail": f"Ошибка создания конспекта: {str(e)}"}
        )

@app.get("/files")
async def list_files():
    """Получение списка загруженных файлов"""
    try:
        files = []
        for filename in os.listdir(Config.UPLOAD_FOLDER):
            filepath = os.path.join(Config.UPLOAD_FOLDER, filename)
            stats = os.stat(filepath)
            files.append({
                "name": filename,
                "size": stats.st_size,
                "modified": datetime.fromtimestamp(stats.st_mtime).isoformat()
            })

        return {"files": files}
    except Exception as e:
        logger.error(f"Ошибка получения списка файлов: {e}")
        return JSONResponse(
            status_code=500,
            content={"detail": f"Ошибка: {str(e)}"}
        )

@app.delete("/files/{filename}")
async def delete_file(filename: str):
    """Удаление файла"""
    try:
        filepath = os.path.join(Config.UPLOAD_FOLDER, filename)

        if not os.path.exists(filepath):
            return JSONResponse(
                status_code=404,
                content={"detail": "Файл не найден"}
            )

        os.remove(filepath)
        return {"message": f"Файл {filename} удален"}

    except Exception as e:
        logger.error(f"Ошибка удаления файла: {e}")
        return JSONResponse(
            status_code=500,
            content={"detail": f"Ошибка удаления: {str(e)}"}
        )

@app.get("/health")
async def health_check():
    """Проверка здоровья приложения"""
    return {
        "status": "healthy",
        "whisper_loaded": whisper_model is not None,
        "llm_loaded": llm_chain is not None,
        "timestamp": datetime.now().isoformat()
    }

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