"""arq task: scan an indexable source and import its files into the library.

Heavy work (directory walk + file copies) belongs off the request cycle
(CLAUDE.md). The HTTP endpoint enqueues this; the worker runs it with its own
transactional session.
"""

import uuid
from typing import Any

from app.application.import_service import LibraryImportService
from app.core.config import get_settings
from app.core.logging import get_logger
from app.infrastructure.db import session_scope
from app.infrastructure.db.repositories import (
    SqlAlchemyArtistRepository,
    SqlAlchemyTrackRepository,
)
from app.infrastructure.sources.registry import build_source_registry
from app.infrastructure.storage.provider import get_file_storage
from app.workers.queue import enqueue_enrich

log = get_logger("worker.import")


async def scan_local_folder(
    _ctx: dict[str, Any], *, source: str = "local", added_by: str | None = None
) -> dict[str, Any]:
    registry = build_source_registry(get_settings())
    backend = registry.indexable(source)
    actor = uuid.UUID(added_by) if added_by else None

    async with session_scope() as session:
        service = LibraryImportService(
            tracks=SqlAlchemyTrackRepository(session),
            artists=SqlAlchemyArtistRepository(session),
            storage=get_file_storage(),
        )
        summary = await service.scan_and_import(backend, added_by=actor)

    # Enqueue enrichment only after the import transaction has committed above,
    # so the enrich worker is guaranteed to see the new rows.
    for track_id in summary.imported_ids:
        await enqueue_enrich(track_id)

    return {
        "source": summary.source,
        "seen": summary.seen,
        "imported": summary.imported,
        "skipped": summary.skipped,
        "failed": summary.failed,
    }
