"""Export activity."""

from app.domain.enums import AssetType, OrderStatus, StepStatus
from app.infra.db.models.asset import AssetORM
from app.infra.db.session import get_session_factory
from temporalio import activity

from app.workers.activities.tryon_activities import create_step_record, jsonable, load_order_and_run, utc_now
from app.workers.workflows.types import MockActivityResult, StepActivityInput


@activity.defn
async def run_export_activity(payload: StepActivityInput) -> MockActivityResult:
    """Finalize the chosen source asset as the order's exported deliverable."""

    if payload.source_asset_id is None:
        raise ValueError("run_export_activity requires source_asset_id")

    async with get_session_factory()() as session:
        order, workflow_run = await load_order_and_run(session, payload.order_id, payload.workflow_run_id)
        step = create_step_record(payload)
        session.add(step)

        order.status = OrderStatus.RUNNING
        workflow_run.status = OrderStatus.RUNNING
        workflow_run.current_step = payload.step_name
        await session.flush()

        try:
            source_asset = await session.get(AssetORM, payload.source_asset_id)
            if source_asset is None:
                raise ValueError(f"Source asset {payload.source_asset_id} not found")
            if source_asset.order_id != payload.order_id:
                raise ValueError(
                    f"Source asset {payload.source_asset_id} does not belong to order {payload.order_id}"
                )

            metadata = {
                **payload.metadata,
                "source_asset_id": payload.source_asset_id,
                "selected_asset_id": payload.selected_asset_id,
            }
            metadata = {key: value for key, value in metadata.items() if value is not None}

            asset = AssetORM(
                order_id=payload.order_id,
                asset_type=AssetType.FINAL,
                step_name=payload.step_name,
                uri=source_asset.uri,
                metadata_json=jsonable(metadata),
            )
            session.add(asset)
            await session.flush()

            result = MockActivityResult(
                step_name=payload.step_name,
                success=True,
                asset_id=asset.id,
                uri=asset.uri,
                score=0.95,
                passed=True,
                message="mock success",
                metadata=jsonable(metadata) or {},
            )

            order.final_asset_id = asset.id
            order.status = OrderStatus.SUCCEEDED
            workflow_run.status = OrderStatus.SUCCEEDED

            step.step_status = StepStatus.SUCCEEDED
            step.output_json = jsonable(result)
            step.ended_at = utc_now()
            await session.commit()
            return result
        except Exception as exc:
            step.step_status = StepStatus.FAILED
            step.error_message = str(exc)
            step.ended_at = utc_now()
            order.status = OrderStatus.FAILED
            workflow_run.status = OrderStatus.FAILED
            await session.commit()
            raise