"""
تسک‌های Celery برای pipeline سنجش‌ازدور و subdivision داده‌محور.
"""

import logging
from typing import Any

from config.celery import app
from django.conf import settings
from django.db import transaction
from django.utils import timezone
from django.utils.dateparse import parse_date

from .data_driven_subdivision import (
    DEFAULT_CLUSTER_FEATURES,
    DataDrivenSubdivisionError,
    create_remote_sensing_subdivision_result,
)
from .grid_analysis import create_or_get_analysis_grid_cells
from .models import (
    AnalysisGridCell,
    AnalysisGridObservation,
    BlockSubdivision,
    RemoteSensingRun,
    RemoteSensingSubdivisionResult,
    SoilLocation,
)
from .openeo_service import (
    OpenEOAuthenticationError,
    OpenEOExecutionError,
    OpenEOServiceError,
    compute_remote_sensing_metrics,
)

try:
    import requests
except ImportError:  # pragma: no cover - handled in stripped envs
    RequestException = Exception
else:
    RequestException = requests.RequestException


logger = logging.getLogger(__name__)

REMOTE_SENSING_TASK_MAX_RETRIES = 5
REMOTE_SENSING_TASK_RETRY_DELAY_SECONDS = 60
REMOTE_SENSING_TASK_RETRY_BACKOFF_MAX_SECONDS = 600
PERSISTED_OBSERVATION_FEATURES = (
    "ndvi",
    "ndwi",
    "soil_vv",
    "soil_vv_db",
)


def run_remote_sensing_analysis(
    *,
    soil_location_id: int,
    block_code: str = "",
    temporal_start: Any,
    temporal_end: Any,
    force_refresh: bool = False,
    task_id: str = "",
    run_id: int | None = None,
    cluster_count: int | None = None,
    selected_features: list[str] | None = None,
) -> dict[str, Any]:
    """
    اجرای سنکرون تحلیل سنجش‌ازدور برای یک location/block.
    این helper برای Celery task و هر orchestration داخلی دیگر قابل استفاده است.
    """
    start_date = _normalize_temporal_date(temporal_start, "temporal_start")
    end_date = _normalize_temporal_date(temporal_end, "temporal_end")
    if start_date > end_date:
        raise ValueError("temporal_start نمی‌تواند بعد از temporal_end باشد.")

    location = SoilLocation.objects.filter(pk=soil_location_id).first()
    if location is None:
        raise ValueError(f"SoilLocation با id={soil_location_id} پیدا نشد.")

    resolved_block_code = str(block_code or "").strip()
    subdivision = _resolve_block_subdivision(location, resolved_block_code)
    run = _get_or_create_remote_sensing_run(
        run_id=run_id,
        location=location,
        subdivision=subdivision,
        block_code=resolved_block_code,
        temporal_start=start_date,
        temporal_end=end_date,
        task_id=task_id,
        cluster_count=cluster_count,
        selected_features=selected_features or list(DEFAULT_CLUSTER_FEATURES),
    )
    _mark_run_running(run)

    try:
        _record_run_stage(
            run,
            "preparing_analysis_grid",
            {
                "block_code": resolved_block_code,
                "temporal_extent": {
                    "start_date": start_date.isoformat(),
                    "end_date": end_date.isoformat(),
                },
            },
        )
        grid_summary = create_or_get_analysis_grid_cells(
            location,
            block_code=resolved_block_code,
            block_subdivision=subdivision,
        )
        _record_run_stage(run, "analysis_grid_ready", {"grid_summary": grid_summary})
        all_cells = _load_grid_cells(location, resolved_block_code)
        cells_to_process = _select_cells_for_processing(
            all_cells=all_cells,
            temporal_start=start_date,
            temporal_end=end_date,
            force_refresh=force_refresh,
        )
        _record_run_stage(
            run,
            "analysis_cells_selected",
            {
                "cell_selection": {
                    "total_cell_count": len(all_cells),
                    "cell_count_to_process": len(cells_to_process),
                    "existing_cell_count": len(all_cells) - len(cells_to_process),
                    "force_refresh": force_refresh,
                }
            },
        )

        if not cells_to_process:
            observations = _load_observations(
                location=location,
                block_code=resolved_block_code,
                temporal_start=start_date,
                temporal_end=end_date,
            )
            if not _has_usable_observations(
                observations=observations,
                selected_features=selected_features or list(DEFAULT_CLUSTER_FEATURES),
            ):
                logger.warning(
                    "Cached observations are fully null, refetching remote metrics for run_id=%s",
                    run.id,
                )
                _record_run_stage(
                    run,
                    "using_cached_observations",
                    {"source": "database", "usable": False, "refetching": True},
                )
                cells_to_process = all_cells
            else:
                _record_run_stage(
                    run,
                    "using_cached_observations",
                    {"source": "database", "usable": True, "refetching": False},
                )
                subdivision_result = _ensure_subdivision_result(
                    location=location,
                    run=run,
                    subdivision=subdivision,
                    block_code=resolved_block_code,
                    observations=observations,
                    cluster_count=cluster_count,
                    selected_features=selected_features,
                )
                _record_run_stage(
                    run,
                    "clustering_completed",
                    _build_clustering_stage_metadata(subdivision_result),
                )
                summary = {
                    "status": "completed",
                    "source": "database",
                    "run_id": run.id,
                    "processed_cell_count": 0,
                    "created_observation_count": 0,
                    "updated_observation_count": 0,
                    "existing_observation_count": len(all_cells),
                    "failed_metric_count": 0,
                    "chunk_size_sqm": grid_summary["chunk_size_sqm"],
                    "block_code": resolved_block_code,
                    "cell_count": len(all_cells),
                    "subdivision_result_id": getattr(subdivision_result, "id", None),
                    "cluster_count": getattr(subdivision_result, "cluster_count", 0),
                }
                _mark_run_success(run, summary)
                return summary

        _record_run_stage(
            run,
            "fetching_remote_metrics",
            _build_remote_metric_stage_details(
                cells=cells_to_process,
                selected_features=selected_features,
            ),
        )
        progress_callback = _build_remote_metric_progress_callback(
            run=run,
            cells=cells_to_process,
            selected_features=selected_features,
        )
        remote_payload = compute_remote_sensing_metrics(
            cells_to_process,
            temporal_start=start_date,
            temporal_end=end_date,
            selected_features=selected_features or list(DEFAULT_CLUSTER_FEATURES),
            progress_callback=progress_callback,
        )
        _record_run_stage(
            run,
            "remote_metrics_fetched",
            {
                "failed_metric_count": len(remote_payload["metadata"].get("failed_metrics", [])),
                "service_metadata": remote_payload["metadata"],
            },
        )
        upsert_summary = _upsert_grid_observations(
            cells=cells_to_process,
            run=run,
            temporal_start=start_date,
            temporal_end=end_date,
            metric_payload=remote_payload,
        )
        _record_run_stage(run, "observations_persisted", upsert_summary)
        observations = _load_observations(
            location=location,
            block_code=resolved_block_code,
            temporal_start=start_date,
            temporal_end=end_date,
        )
        subdivision_result = _ensure_subdivision_result(
            location=location,
            run=run,
            subdivision=subdivision,
            block_code=resolved_block_code,
            observations=observations,
            cluster_count=cluster_count,
            selected_features=selected_features,
        )
        _record_run_stage(
            run,
            "clustering_completed",
            _build_clustering_stage_metadata(subdivision_result),
        )
        summary = {
            "status": "completed",
            "source": "openeo",
            "run_id": run.id,
            "processed_cell_count": len(cells_to_process),
            "created_observation_count": upsert_summary["created_count"],
            "updated_observation_count": upsert_summary["updated_count"],
            "existing_observation_count": len(all_cells) - len(cells_to_process),
            "failed_metric_count": len(remote_payload["metadata"].get("failed_metrics", [])),
            "chunk_size_sqm": grid_summary["chunk_size_sqm"],
            "block_code": resolved_block_code,
            "cell_count": len(all_cells),
            "subdivision_result_id": subdivision_result.id,
            "cluster_count": subdivision_result.cluster_count,
        }
        _mark_run_success(run, summary, remote_payload["metadata"])
        logger.info(
            "Remote sensing analysis completed",
            extra={
                "run_id": run.id,
                "soil_location_id": location.id,
                "block_code": resolved_block_code,
                "processed_cell_count": summary["processed_cell_count"],
            },
        )
        return summary
    except Exception as exc:
        _mark_run_failure(run, str(exc))
        raise


@app.task(
    bind=True,
    max_retries=REMOTE_SENSING_TASK_MAX_RETRIES,
    default_retry_delay=REMOTE_SENSING_TASK_RETRY_DELAY_SECONDS,
)
def run_remote_sensing_analysis_task(
    self,
    soil_location_id: int,
    block_code: str = "",
    temporal_start: Any = "",
    temporal_end: Any = "",
    force_refresh: bool = False,
    run_id: int | None = None,
    cluster_count: int | None = None,
    selected_features: list[str] | None = None,
):
    """
    اجرای async تحلیل سنجش‌ازدور برای location/block و ذخیره نتایج در DB.
    """
    logger.info(
        "Starting remote sensing analysis task",
        extra={
            "task_id": self.request.id,
            "soil_location_id": soil_location_id,
            "block_code": block_code,
            "temporal_start": temporal_start,
            "temporal_end": temporal_end,
            "force_refresh": force_refresh,
        },
    )
    try:
        return run_remote_sensing_analysis(
            soil_location_id=soil_location_id,
            block_code=block_code,
            temporal_start=temporal_start,
            temporal_end=temporal_end,
            force_refresh=force_refresh,
            task_id=self.request.id,
            run_id=run_id,
            cluster_count=cluster_count,
            selected_features=selected_features,
        )
    except OpenEOAuthenticationError:
        logger.exception(
            "Remote sensing auth failure",
            extra={"task_id": self.request.id, "soil_location_id": soil_location_id},
        )
        raise
    except (OpenEOExecutionError, OpenEOServiceError, RequestException, DataDrivenSubdivisionError) as exc:
        retry_count = self.request.retries + 1
        countdown = min(
            REMOTE_SENSING_TASK_RETRY_DELAY_SECONDS * (2 ** self.request.retries),
            REMOTE_SENSING_TASK_RETRY_BACKOFF_MAX_SECONDS,
        )
        _mark_run_retrying(
            run_id=run_id,
            task_id=self.request.id,
            error_message=str(exc),
            retry_count=retry_count,
            retry_delay_seconds=countdown,
        )
        logger.warning(
            "Transient remote sensing failure, retrying task",
            extra={
                "task_id": self.request.id,
                "soil_location_id": soil_location_id,
                "block_code": block_code,
                "retry_count": retry_count,
                "retry_delay_seconds": countdown,
                "error": str(exc),
            },
        )
        raise self.retry(exc=exc, countdown=countdown)


def _normalize_temporal_date(value: Any, field_name: str):
    if hasattr(value, "isoformat") and not isinstance(value, str):
        return value
    parsed = parse_date(str(value))
    if parsed is None:
        raise ValueError(f"{field_name} نامعتبر است.")
    return parsed


def _resolve_block_subdivision(location: SoilLocation, block_code: str) -> BlockSubdivision | None:
    if not block_code:
        return None
    return (
        BlockSubdivision.objects.filter(
            soil_location=location,
            block_code=block_code,
        )
        .order_by("-updated_at", "-id")
        .first()
    )


def _get_or_create_remote_sensing_run(
    *,
    run_id: int | None,
    location: SoilLocation,
    subdivision: BlockSubdivision | None,
    block_code: str,
    temporal_start,
    temporal_end,
    task_id: str,
    cluster_count: int | None,
    selected_features: list[str],
) -> RemoteSensingRun:
    queued_at = timezone.now().isoformat()
    if run_id is not None:
        run = RemoteSensingRun.objects.filter(pk=run_id, soil_location=location).first()
        if run is not None:
            metadata = dict(run.metadata or {})
            if task_id:
                metadata["task_id"] = task_id
            metadata.setdefault("status_label", "pending")
            metadata["stage"] = "queued"
            metadata["selected_features"] = selected_features
            metadata["requested_cluster_count"] = cluster_count
            metadata["pipeline"] = {
                "name": "remote_sensing_subdivision",
                "version": 2,
            }
            metadata["timestamps"] = {
                **dict(metadata.get("timestamps") or {}),
                "queued_at": queued_at,
            }
            run.block_subdivision = subdivision
            run.block_code = block_code
            run.chunk_size_sqm = int(getattr(settings, "SUBDIVISION_CHUNK_SQM", 900) or 900)
            run.temporal_start = temporal_start
            run.temporal_end = temporal_end
            run.metadata = metadata
            run.save(
                update_fields=[
                    "block_subdivision",
                    "block_code",
                    "chunk_size_sqm",
                    "temporal_start",
                    "temporal_end",
                    "metadata",
                    "updated_at",
                ]
            )
            return run
    metadata = {
        "status_label": "pending",
        "stage": "queued",
        "selected_features": selected_features,
        "requested_cluster_count": cluster_count,
        "pipeline": {
            "name": "remote_sensing_subdivision",
            "version": 2,
        },
        "timestamps": {"queued_at": queued_at},
    }
    if task_id:
        metadata["task_id"] = task_id
    return RemoteSensingRun.objects.create(
        soil_location=location,
        block_subdivision=subdivision,
        block_code=block_code,
        chunk_size_sqm=int(getattr(settings, "SUBDIVISION_CHUNK_SQM", 900) or 900),
        temporal_start=temporal_start,
        temporal_end=temporal_end,
        status=RemoteSensingRun.STATUS_PENDING,
        metadata=metadata,
    )


def _mark_run_running(run: RemoteSensingRun) -> None:
    metadata = dict(run.metadata or {})
    metadata["status_label"] = "running"
    metadata["stage"] = "running"
    metadata["timestamps"] = {
        **dict(metadata.get("timestamps") or {}),
        "started_at": timezone.now().isoformat(),
    }
    run.status = RemoteSensingRun.STATUS_RUNNING
    run.started_at = timezone.now()
    run.metadata = metadata
    run.save(update_fields=["status", "started_at", "metadata", "updated_at"])


def _mark_run_success(
    run: RemoteSensingRun,
    summary: dict[str, Any],
    service_metadata: dict[str, Any] | None = None,
) -> None:
    metadata = dict(run.metadata or {})
    metadata["summary"] = summary
    metadata["status_label"] = "completed"
    metadata["stage"] = "completed"
    metadata["timestamps"] = {
        **dict(metadata.get("timestamps") or {}),
        "completed_at": timezone.now().isoformat(),
    }
    if service_metadata:
        metadata["service"] = service_metadata
    run.status = RemoteSensingRun.STATUS_SUCCESS
    run.finished_at = timezone.now()
    run.error_message = ""
    run.metadata = metadata
    run.save(
        update_fields=[
            "status",
            "finished_at",
            "error_message",
            "metadata",
            "updated_at",
        ]
    )


def _mark_run_failure(run: RemoteSensingRun, error_message: str) -> None:
    metadata = dict(run.metadata or {})
    failed_stage = str(metadata.get("stage") or "").strip() or None
    stage_details = dict(metadata.get("stage_details") or {})
    metadata["status_label"] = "failed"
    metadata["stage"] = "failed"
    metadata["failed_stage"] = failed_stage
    metadata["failure_reason"] = error_message[:4000]
    metadata["stage_details"] = {
        **stage_details,
        "failed": {
            "failed_stage": failed_stage,
            "error_message": error_message[:4000],
            "failed_stage_details": stage_details.get(failed_stage, {}) if failed_stage else {},
        },
    }
    metadata["timestamps"] = {
        **dict(metadata.get("timestamps") or {}),
        "failed_at": timezone.now().isoformat(),
    }
    run.status = RemoteSensingRun.STATUS_FAILURE
    run.finished_at = timezone.now()
    run.error_message = error_message[:4000]
    run.metadata = metadata
    run.save(
        update_fields=[
            "status",
            "finished_at",
            "error_message",
            "metadata",
            "updated_at",
        ]
    )
    logger.exception(
        "Remote sensing analysis failed",
        extra={"run_id": run.id, "soil_location_id": run.soil_location_id, "block_code": run.block_code},
    )


def _mark_run_retrying(
    *,
    run_id: int | None,
    task_id: str,
    error_message: str,
    retry_count: int,
    retry_delay_seconds: int,
) -> None:
    run = None
    if run_id is not None:
        run = RemoteSensingRun.objects.filter(pk=run_id).first()
    if run is None and task_id:
        run = RemoteSensingRun.objects.filter(metadata__task_id=str(task_id)).first()
    if run is None:
        return

    metadata = dict(run.metadata or {})
    stage_details = dict(metadata.get("stage_details") or {})
    failed_stage = (
        str(metadata.get("failed_stage") or metadata.get("stage") or "").strip() or None
    )
    metadata["status_label"] = "retrying"
    metadata["stage"] = "retrying"
    metadata["failed_stage"] = failed_stage
    metadata.pop("failure_reason", None)
    metadata["stage_details"] = {
        **stage_details,
        "retrying": {
            "retry_count": retry_count,
            "retry_delay_seconds": retry_delay_seconds,
            "last_error": error_message[:4000],
            "failed_stage": failed_stage,
            "failed_stage_details": stage_details.get(failed_stage, {}) if failed_stage else {},
        },
    }
    metadata["timestamps"] = {
        **dict(metadata.get("timestamps") or {}),
        "retrying_at": timezone.now().isoformat(),
    }
    run.status = RemoteSensingRun.STATUS_RUNNING
    run.error_message = ""
    run.metadata = metadata
    run.save(update_fields=["status", "error_message", "metadata", "updated_at"])


def _load_grid_cells(location: SoilLocation, block_code: str) -> list[AnalysisGridCell]:
    queryset = AnalysisGridCell.objects.filter(soil_location=location)
    queryset = queryset.filter(block_code=block_code or "")
    return list(queryset.order_by("cell_code"))


def _load_observations(
    *,
    location: SoilLocation,
    block_code: str,
    temporal_start,
    temporal_end,
) -> list[AnalysisGridObservation]:
    queryset = (
        AnalysisGridObservation.objects.select_related("cell", "run")
        .filter(
            cell__soil_location=location,
            cell__block_code=block_code or "",
            temporal_start=temporal_start,
            temporal_end=temporal_end,
        )
        .order_by("cell__cell_code")
    )
    return list(queryset)


def _select_cells_for_processing(
    *,
    all_cells: list[AnalysisGridCell],
    temporal_start,
    temporal_end,
    force_refresh: bool,
) -> list[AnalysisGridCell]:
    if force_refresh:
        return all_cells

    existing_ids = set(
        AnalysisGridObservation.objects.filter(
            cell__in=all_cells,
            temporal_start=temporal_start,
            temporal_end=temporal_end,
        ).values_list("cell_id", flat=True)
    )
    return [cell for cell in all_cells if cell.id not in existing_ids]


def _has_usable_observations(
    *,
    observations: list[AnalysisGridObservation],
    selected_features: list[str],
) -> bool:
    for observation in observations:
        if any(getattr(observation, feature_name, None) is not None for feature_name in selected_features):
            return True
    return False


def _upsert_grid_observations(
    *,
    cells: list[AnalysisGridCell],
    run: RemoteSensingRun,
    temporal_start,
    temporal_end,
    metric_payload: dict[str, Any],
) -> dict[str, int]:
    result_by_cell = metric_payload.get("results", {})
    payload_diagnostics = metric_payload["metadata"].get("payload_diagnostics", {})
    payload_cell_codes = sorted(str(cell_code) for cell_code in result_by_cell.keys())
    db_cell_codes = [cell.cell_code for cell in cells]
    matched_cell_codes = sorted(set(db_cell_codes) & set(payload_cell_codes))
    unmatched_db_cell_codes = sorted(set(db_cell_codes) - set(payload_cell_codes))
    unmatched_payload_cell_codes = sorted(set(payload_cell_codes) - set(db_cell_codes))
    available_features = _collect_available_features(
        result_by_cell=result_by_cell,
        payload_diagnostics=payload_diagnostics,
    )
    payload_keys_sample = payload_cell_codes[:5]

    metadata_template = {
        "backend_name": metric_payload["metadata"].get("backend"),
        "backend_url": metric_payload["metadata"].get("backend_url"),
        "collections_used": metric_payload["metadata"].get("collections_used", []),
        "job_refs": metric_payload["metadata"].get("job_refs", {}),
        "failed_metrics": metric_payload["metadata"].get("failed_metrics", []),
        "payload_diagnostics": payload_diagnostics,
        "run_id": run.id,
    }

    logger.info(
        "Remote sensing payload/DB cell comparison: %s",
        {
            "run_id": run.id,
            "db_cell_count": len(db_cell_codes),
            "payload_cell_count": len(payload_cell_codes),
            "matched_cell_count": len(matched_cell_codes),
            "unmatched_db_cell_codes": unmatched_db_cell_codes,
            "unmatched_payload_cell_codes": unmatched_payload_cell_codes,
        },
    )
    if not matched_cell_codes:
        logger.error("No payload cells matched DB cell_codes for run_id=%s", run.id)

    created_count = 0
    updated_count = 0
    usable_observation_count = 0
    fully_null_observation_count = 0
    with transaction.atomic():
        for cell in cells:
            values = result_by_cell.get(cell.cell_code, {})
            defaults = {
                "run": run,
                "ndvi": values.get("ndvi"),
                "ndwi": values.get("ndwi"),
                "soil_vv": values.get("soil_vv"),
                "soil_vv_db": values.get("soil_vv_db"),
                "metadata": metadata_template,
            }
            persisted_values = [defaults[feature_name] for feature_name in PERSISTED_OBSERVATION_FEATURES]
            usable_values = [defaults[feature_name] for feature_name in DEFAULT_CLUSTER_FEATURES]
            if all(value is None for value in persisted_values):
                fully_null_observation_count += 1
                logger.warning(
                    "Persisting empty observation for cell=%s, run_id=%s",
                    cell.cell_code,
                    run.id,
                )
            if any(value is not None for value in usable_values):
                usable_observation_count += 1
            observation, created = AnalysisGridObservation.objects.update_or_create(
                cell=cell,
                temporal_start=temporal_start,
                temporal_end=temporal_end,
                defaults=defaults,
            )
            if created:
                created_count += 1
            else:
                updated_count += 1

    summary = {
        "created_count": created_count,
        "updated_count": updated_count,
        "total_observation_count": len(cells),
        "usable_observation_count": usable_observation_count,
        "fully_null_observation_count": fully_null_observation_count,
        "matched_cell_count": len(matched_cell_codes),
        "matched_cell_codes": matched_cell_codes,
        "unmatched_db_cell_codes": unmatched_db_cell_codes,
        "unmatched_payload_cell_codes": unmatched_payload_cell_codes,
        "payload_keys_sample": payload_keys_sample,
        "available_features": available_features,
    }
    logger.info("Grid observation upsert summary: %s", summary)
    if usable_observation_count == 0:
        diagnostics = {
            "job_ref": metadata_template["job_refs"],
            "total_cells": len(cells),
            "matched_cells": len(matched_cell_codes),
            "payload_keys_sample": payload_keys_sample,
            "available_features": available_features,
        }
        logger.error("All persisted observations are empty for run_id=%s", run.id)
        _store_empty_observation_diagnostics(run=run, diagnostics=diagnostics)
        summary["empty_observation_diagnostics"] = diagnostics

    return summary


def _collect_available_features(
    *,
    result_by_cell: dict[str, dict[str, Any]],
    payload_diagnostics: dict[str, Any],
) -> list[str]:
    available = {
        feature_name
        for values in result_by_cell.values()
        for feature_name, value in (values or {}).items()
        if value is not None
    }
    for metric_diagnostics in payload_diagnostics.values():
        available.update(metric_diagnostics.get("available_features", []))
    return sorted(str(feature_name) for feature_name in available)


def _store_empty_observation_diagnostics(*, run: RemoteSensingRun, diagnostics: dict[str, Any]) -> None:
    metadata = dict(run.metadata or {})
    metadata["diagnostics"] = {
        **dict(metadata.get("diagnostics") or {}),
        "empty_observations": diagnostics,
    }
    run.metadata = metadata
    run.save(update_fields=["metadata", "updated_at"])


def _build_remote_metric_stage_details(
    *,
    cells: list[AnalysisGridCell],
    selected_features: list[str] | None,
    active_metric: str | None = None,
    completed_metrics: list[str] | None = None,
    failed_metrics: list[dict[str, Any]] | None = None,
    metric_states: list[dict[str, Any]] | None = None,
) -> dict[str, Any]:
    features = list(selected_features or DEFAULT_CLUSTER_FEATURES)
    completed = list(completed_metrics or [])
    failed = list(failed_metrics or [])
    states = metric_states or [
        {
            "metric": metric_name,
            "status": (
                "completed"
                if metric_name in completed
                else "failed"
                if any(item.get("metric") == metric_name for item in failed)
                else "running"
                if metric_name == active_metric
                else "pending"
            ),
        }
        for metric_name in features
    ]
    return {
        "requested_cell_count": len(cells),
        "target_cells": [
            {
                "cell_code": cell.cell_code,
                "block_code": cell.block_code,
                "centroid_lat": str(cell.centroid_lat),
                "centroid_lon": str(cell.centroid_lon),
                "chunk_size_sqm": cell.chunk_size_sqm,
            }
            for cell in cells
        ],
        "metric_progress": {
            "total_metrics": len(features),
            "completed_metric_count": len(completed),
            "active_metric": active_metric,
            "completed_metrics": completed,
            "failed_metrics": failed,
            "states": states,
        },
    }


def _normalize_progress_metric_name(metric_name: str, features: list[str]) -> str:
    derived_metric_map = {
        "soil_vv": "soil_vv_db",
    }
    normalized = derived_metric_map.get(metric_name, metric_name)
    if normalized in features:
        return normalized
    return metric_name


def _resolve_progress_job_ref(candidate: str, job_refs: dict[str, Any]) -> Any:
    if candidate in job_refs:
        return job_refs.get(candidate)
    source_metric_map = {
        "soil_vv_db": "soil_vv",
    }
    return job_refs.get(source_metric_map.get(candidate, candidate))


def _build_remote_metric_progress_callback(
    *,
    run: RemoteSensingRun,
    cells: list[AnalysisGridCell],
    selected_features: list[str] | None,
):
    features = list(selected_features or DEFAULT_CLUSTER_FEATURES)
    completed_metrics: list[str] = []
    failed_metrics: list[dict[str, Any]] = []

    def callback(*, metric_name: str, state: str, metadata: dict[str, Any], metric_payload=None, error: str = "") -> None:
        progress_metric_name = _normalize_progress_metric_name(metric_name, features)
        if state == "completed" and progress_metric_name not in completed_metrics:
            completed_metrics.append(progress_metric_name)
        if state == "failed":
            failed_entry = {"metric": progress_metric_name, "error": error}
            if not any(
                item.get("metric") == progress_metric_name and item.get("error") == error
                for item in failed_metrics
            ):
                failed_metrics.append(failed_entry)

        stage_details = _build_remote_metric_stage_details(
            cells=cells,
            selected_features=features,
            active_metric=progress_metric_name if state == "running" else None,
            completed_metrics=completed_metrics,
            failed_metrics=failed_metrics,
            metric_states=[
                {
                    "metric": candidate,
                    "status": (
                        "completed"
                        if candidate in completed_metrics
                        else "failed"
                        if any(item.get("metric") == candidate for item in failed_metrics)
                        else "running"
                        if candidate == progress_metric_name and state == "running"
                        else "pending"
                    ),
                    "job_ref": _resolve_progress_job_ref(candidate, metadata.get("job_refs", {})),
                }
                for candidate in features
            ],
        )
        _record_run_stage(run, "fetching_remote_metrics", stage_details)

    return callback


def _ensure_subdivision_result(
    *,
    location: SoilLocation,
    run: RemoteSensingRun,
    subdivision: BlockSubdivision | None,
    block_code: str,
    observations: list[AnalysisGridObservation],
    cluster_count: int | None,
    selected_features: list[str] | None,
) -> RemoteSensingSubdivisionResult:
    if not observations:
        raise DataDrivenSubdivisionError("هیچ observation برای ساخت subdivision داده‌محور پیدا نشد.")
    result = create_remote_sensing_subdivision_result(
        location=location,
        run=run,
        observations=observations,
        block_subdivision=subdivision,
        block_code=block_code,
        selected_features=selected_features or list(DEFAULT_CLUSTER_FEATURES),
        explicit_k=cluster_count,
    )
    return result


def _record_run_stage(run: RemoteSensingRun, stage: str, details: dict[str, Any] | None = None) -> None:
    metadata = dict(run.metadata or {})
    metadata["stage"] = stage
    metadata["stage_details"] = {
        **dict(metadata.get("stage_details") or {}),
        stage: details or {},
    }
    metadata["timestamps"] = {
        **dict(metadata.get("timestamps") or {}),
        f"{stage}_at": timezone.now().isoformat(),
    }
    run.metadata = metadata
    run.save(update_fields=["metadata", "updated_at"])


def _build_clustering_stage_metadata(
    result: RemoteSensingSubdivisionResult,
) -> dict[str, Any]:
    metadata = dict(result.metadata or {})
    return {
        "subdivision_result_id": result.id,
        "cluster_count": result.cluster_count,
        "selected_features": result.selected_features,
        "used_cell_count": metadata.get("used_cell_count", 0),
        "skipped_cell_count": metadata.get("skipped_cell_count", 0),
        "skipped_cell_codes": result.skipped_cell_codes,
        "kmeans_params": metadata.get("kmeans_params", {}),
    }