import logging
import uuid

from ..config import settings
from ..outbound.gemini.gemini_client import GeminiClient
from ..outbound.postgres.database import AsyncSessionLocal
from ..outbound.postgres.entities.translated_article_entity import TranslatedArticleEntity
from ..outbound.postgres.repositories import summarise_job_repository
from ..outbound.postgres.repositories.translated_article_repository import TranslatedArticleRepository
from ..outbound.storage_client import get_storage_client
from .app import procrastinate_app

logger = logging.getLogger(__name__)


@procrastinate_app.task(queue="default")
async def regenerate_audio_for_job(job_id: str) -> None:
    uid = uuid.UUID(job_id)
    gemini_client = GeminiClient(settings.gemini_api_key)
    async with AsyncSessionLocal() as db:
        job = await summarise_job_repository.get_by_id(db, uid)
        article_repo = TranslatedArticleRepository(db)
        article_entity = await db.get(TranslatedArticleEntity, job.translated_article_id)
        await summarise_job_repository.mark_processing(db, job)

        try:
            voice = gemini_client.get_voice_by_language(article_entity.target_language)
            wav_bytes = await gemini_client.generate_audio(article_entity.target_body, voice)
            audio_key = f"audio/{job_id}.wav"
            get_storage_client().upload(audio_key, wav_bytes)

            await article_repo.update_audio(
                article_entity.id,
                audio_url=audio_key,
                target_body_transcript=article_entity.target_body_transcript,
            )
            await summarise_job_repository.mark_succeeded(db, job)

        except Exception as exc:
            await summarise_job_repository.mark_failed(db, job, str(exc))