Backend/crop_zoning/services.py

import math
import hashlib
from copy import deepcopy
from decimal import Decimal
from datetime import timedelta

from django.conf import settings
from django.core.exceptions import ImproperlyConfigured
from celery.result import AsyncResult
from kombu.exceptions import OperationalError
from django.db import transaction
from django.db.models import Prefetch
from django.utils import timezone
from farm_hub.models import FarmHub

from external_api_adapter.adapter import request as external_request

from .defaults import DEFAULT_AREA_FEATURE, DEFAULT_PRODUCTS_PAYLOAD
from .models import (
    CropArea,
    CropProduct,
    CropZone,
    CropZoneAnalysis,
    CropZoneCriteria,
    CropZoneCultivationRiskLayer,
    CropZoneRecommendation,
    CropZoneSoilQualityLayer,
    CropZoneWaterNeedLayer,
)

EARTH_RADIUS_METERS = 6378137.0
PRODUCT_DEFAULTS = DEFAULT_PRODUCTS_PAYLOAD["products"]
DEFAULT_CELL_SIDE_KM = 0.15
DEFAULT_ZONE_PAGE_SIZE = 10
RULE_BASED_ALGORITHM = "rule_based_v1"
RULE_BASED_PRODUCTS = {
    "wheat": {
        "water_need": "۴۵۰۰-۵۵۰۰ m³/ha",
        "water_need_level": "medium",
        "estimated_profit": "۱۵-۲۵ میلیون/هکتار",
        "reason": "دمای مناسب، خاک حاصلخیز، دسترسی به آب کافی",
    },
    "canola": {
        "water_need": "۵۰۰۰-۶۰۰۰ m³/ha",
        "water_need_level": "high",
        "estimated_profit": "۲۰-۳۵ میلیون/هکتار",
        "reason": "پایداری بهتر در برابر نوسان دما و پتانسیل سود اقتصادی مناسب",
    },
    "saffron": {
        "water_need": "۳۰۰۰-۴۰۰۰ m³/ha",
        "water_need_level": "low",
        "estimated_profit": "۵۰-۱۵۰ میلیون/هکتار",
        "reason": "اقلیم خشک‌تر و نیاز آبی کمتر این زون برای زعفران مناسب‌تر است",
    },
}
RULE_BASED_CROP_IDS = tuple(RULE_BASED_PRODUCTS.keys())
TASK_STATE_PENDING = "PENDING"
TASK_STATE_STARTED = "STARTED"
TASK_STATE_RETRY = "RETRY"
TASK_STATE_SUCCESS = "SUCCESS"
TASK_STATE_FAILURE = "FAILURE"
TASK_STATE_REVOKED = "REVOKED"
AI_LOCATION_DATA_PATH = "/api/location-data/"
AI_REMOTE_SENSING_PATH = "/api/location-data/remote-sensing/"
AI_CLUSTER_RECOMMENDATIONS_PATH = "/api/location-data/remote-sensing/cluster-recommendations/"


def get_default_cell_side_km():
    raw_value = getattr(settings, "CROP_ZONE_CELL_SIDE_KM", None)
    try:
        cell_side_km = float(raw_value)
    except (TypeError, ValueError):
        cell_side_km = 0
    if cell_side_km > 0:
        return cell_side_km

    raw_value = getattr(settings, "CROP_ZONE_CHUNK_AREA_SQM", 0)
    try:
        chunk_area = float(raw_value)
    except (TypeError, ValueError):
        chunk_area = 0
    if chunk_area > 0:
        return math.sqrt(chunk_area) / 1000.0

    return DEFAULT_CELL_SIDE_KM


def get_task_stale_seconds():
    raw_value = getattr(settings, "CROP_ZONE_TASK_STALE_SECONDS", 300)
    try:
        stale_seconds = int(raw_value)
    except (TypeError, ValueError):
        stale_seconds = 300
    return max(stale_seconds, 0)


def get_cell_side_km(cell_side_km=None):
    if cell_side_km is None or cell_side_km == "":
        resolved_value = get_default_cell_side_km()
    else:
        try:
            resolved_value = float(cell_side_km)
        except (TypeError, ValueError) as exc:
            raise ValueError("cell_side_km must be a positive number.") from exc

    if resolved_value <= 0:
        raise ValueError("cell_side_km must be a positive number.")
    return resolved_value


def get_chunk_area_sqm(cell_side_km=None):
    resolved_cell_side_km = get_cell_side_km(cell_side_km)
    return (resolved_cell_side_km * 1000.0) ** 2


def parse_positive_int(value, field_name, default=None):
    if value in {None, ""}:
        if default is None:
            raise ValueError(f"{field_name} must be a positive integer.")
        return default

    try:
        parsed_value = int(value)
    except (TypeError, ValueError) as exc:
        raise ValueError(f"{field_name} must be a positive integer.") from exc

    if parsed_value <= 0:
        raise ValueError(f"{field_name} must be a positive integer.")
    return parsed_value


def get_zone_page_request_params(query_params):
    return (
        parse_positive_int(query_params.get("page"), "page", default=1),
        parse_positive_int(query_params.get("page_size"), "page_size", default=DEFAULT_ZONE_PAGE_SIZE),
    )


def get_default_area_feature():
    return deepcopy(DEFAULT_AREA_FEATURE["area"])


def normalize_area_feature(area_feature):
    if area_feature is None:
        raise ValueError("Area polygon coordinates are required.")
    if not isinstance(area_feature, dict):
        raise ValueError("Area GeoJSON must be an object.")

    if area_feature.get("type") == "Feature":
        geometry = deepcopy(area_feature.get("geometry") or {})
        normalized_feature = {
            "type": "Feature",
            "properties": deepcopy(area_feature.get("properties") or {}),
            "geometry": geometry,
        }
    else:
        normalized_feature = {
            "type": "Feature",
            "properties": {},
            "geometry": deepcopy(area_feature),
        }

    geometry = normalized_feature.get("geometry") or {}
    if geometry.get("type") != "Polygon":
        raise ValueError("Area GeoJSON geometry type must be Polygon.")

    ring = get_polygon_ring(normalized_feature)
    if len(ring) < 4:
        raise ValueError("Area polygon must contain at least four coordinates.")

    return normalized_feature


def ensure_products_exist():
    for product in PRODUCT_DEFAULTS:
        CropProduct.objects.update_or_create(
            product_id=product["id"],
            defaults={"label": product["label"], "color": product["color"]},
        )


def get_products_payload():
    ensure_products_exist()
    products = CropProduct.objects.order_by("id")
    return {
        "products": [
            {"id": product.product_id, "label": product.label, "color": product.color}
            for product in products
        ]
    }


def get_polygon_ring(area_feature):
    geometry = (area_feature or {}).get("geometry", {})
    coordinates = geometry.get("coordinates", [])
    if not coordinates or not coordinates[0]:
        raise ValueError("Area polygon coordinates are required.")
    return coordinates[0]


def polygon_area_sqm(ring):
    if len(ring) < 4:
        return 0.0

    latitudes = [point[1] for point in ring]
    mean_latitude = math.radians(sum(latitudes) / len(latitudes))

    projected_points = []
    for longitude, latitude in ring:
        x = math.radians(longitude) * EARTH_RADIUS_METERS * math.cos(mean_latitude)
        y = math.radians(latitude) * EARTH_RADIUS_METERS
        projected_points.append((x, y))

    area = 0.0
    for index in range(len(projected_points) - 1):
        x1, y1 = projected_points[index]
        x2, y2 = projected_points[index + 1]
        area += (x1 * y2) - (x2 * y1)

    return abs(area) / 2.0


def normalize_points(ring):
    if len(ring) > 1 and ring[0] == ring[-1]:
        ring = ring[:-1]
    return [[point[0], point[1]] for point in ring]


def calculate_center(points):
    if not points:
        return {"longitude": 0.0, "latitude": 0.0}

    longitude = sum(point[0] for point in points) / len(points)
    latitude = sum(point[1] for point in points) / len(points)
    return {
        "longitude": round(longitude, 8),
        "latitude": round(latitude, 8),
    }


def get_bbox(points):
    longitudes = [point[0] for point in points]
    latitudes = [point[1] for point in points]
    return {
        "min_lng": min(longitudes),
        "max_lng": max(longitudes),
        "min_lat": min(latitudes),
        "max_lat": max(latitudes),
    }


def meters_to_latitude_delta(meters):
    return meters / 111320.0


def meters_to_longitude_delta(meters, latitude):
    longitude_factor = 111320.0 * math.cos(math.radians(latitude))
    if abs(longitude_factor) < 1e-9:
        longitude_factor = 1.0
    return meters / longitude_factor


def point_in_polygon(point, polygon_points):
    x, y = point
    inside = False
    point_count = len(polygon_points)
    if point_count < 3:
        return False

    for index in range(point_count):
        x1, y1 = polygon_points[index]
        x2, y2 = polygon_points[(index + 1) % point_count]
        intersects = ((y1 > y) != (y2 > y)) and (
            x < ((x2 - x1) * (y - y1) / ((y2 - y1) or 1e-12)) + x1
        )
        if intersects:
            inside = not inside

    return inside


def _orientation(point_a, point_b, point_c):
    value = ((point_b[1] - point_a[1]) * (point_c[0] - point_b[0])) - (
        (point_b[0] - point_a[0]) * (point_c[1] - point_b[1])
    )
    if abs(value) < 1e-12:
        return 0
    return 1 if value > 0 else 2


def _on_segment(point_a, point_b, point_c):
    return (
        min(point_a[0], point_c[0]) - 1e-12 <= point_b[0] <= max(point_a[0], point_c[0]) + 1e-12
        and min(point_a[1], point_c[1]) - 1e-12 <= point_b[1] <= max(point_a[1], point_c[1]) + 1e-12
    )


def segments_intersect(point_a, point_b, point_c, point_d):
    orientation_1 = _orientation(point_a, point_b, point_c)
    orientation_2 = _orientation(point_a, point_b, point_d)
    orientation_3 = _orientation(point_c, point_d, point_a)
    orientation_4 = _orientation(point_c, point_d, point_b)

    if orientation_1 != orientation_2 and orientation_3 != orientation_4:
        return True

    if orientation_1 == 0 and _on_segment(point_a, point_c, point_b):
        return True
    if orientation_2 == 0 and _on_segment(point_a, point_d, point_b):
        return True
    if orientation_3 == 0 and _on_segment(point_c, point_a, point_d):
        return True
    if orientation_4 == 0 and _on_segment(point_c, point_b, point_d):
        return True

    return False


def rectangle_contains_point(point, cell_points):
    min_lng = min(vertex[0] for vertex in cell_points)
    max_lng = max(vertex[0] for vertex in cell_points)
    min_lat = min(vertex[1] for vertex in cell_points)
    max_lat = max(vertex[1] for vertex in cell_points)
    return min_lng <= point[0] <= max_lng and min_lat <= point[1] <= max_lat


def polygon_intersects_cell(polygon_points, cell_points):
    cell_center = calculate_center(cell_points)
    if point_in_polygon([cell_center["longitude"], cell_center["latitude"]], polygon_points):
        return True

    if any(point_in_polygon(point, polygon_points) for point in cell_points):
        return True

    if any(rectangle_contains_point(point, cell_points) for point in polygon_points):
        return True

    polygon_edges = list(zip(polygon_points, polygon_points[1:] + polygon_points[:1]))
    cell_edges = list(zip(cell_points, cell_points[1:] + cell_points[:1]))
    return any(
        segments_intersect(start_a, end_a, start_b, end_b)
        for start_a, end_a in polygon_edges
        for start_b, end_b in cell_edges
    )


def build_square_points(left_lng, bottom_lat, right_lng, top_lat):
    return [
        [round(left_lng, 8), round(bottom_lat, 8)],
        [round(right_lng, 8), round(bottom_lat, 8)],
        [round(right_lng, 8), round(top_lat, 8)],
        [round(left_lng, 8), round(top_lat, 8)],
    ]


def build_zone_square(area_points, center, zone_area_sqm):
    if len(area_points) < 4:
        return area_points

    width = math.sqrt(max(zone_area_sqm, 1))
    half_width = width / 2.0
    delta_lat = meters_to_latitude_delta(half_width)
    delta_lng = meters_to_longitude_delta(half_width, center["latitude"])

    return build_square_points(
        center["longitude"] - delta_lng,
        center["latitude"] - delta_lat,
        center["longitude"] + delta_lng,
        center["latitude"] + delta_lat,
    )


def split_area_into_zones(area_feature, cell_side_km=None):
    area_ring = get_polygon_ring(area_feature)
    area_points = normalize_points(area_ring)
    area_center = calculate_center(area_points)
    total_area_sqm = polygon_area_sqm(area_ring)
    resolved_cell_side_km = get_cell_side_km(cell_side_km)
    chunk_area_sqm = get_chunk_area_sqm(resolved_cell_side_km)
    cell_side_meters = resolved_cell_side_km * 1000.0
    bbox = get_bbox(area_points)
    latitude_step = meters_to_latitude_delta(cell_side_meters)

    zones = []
    sequence = 0
    current_lat = bbox["min_lat"]

    while current_lat < bbox["max_lat"] - 1e-12:
        next_lat = current_lat + latitude_step
        row_center_lat = current_lat + (latitude_step / 2.0)
        longitude_step = meters_to_longitude_delta(cell_side_meters, row_center_lat)
        current_lng = bbox["min_lng"]

        while current_lng < bbox["max_lng"] - 1e-12:
            next_lng = current_lng + longitude_step
            zone_points = build_square_points(current_lng, current_lat, next_lng, next_lat)

            if polygon_intersects_cell(area_points, zone_points):
                zone_geometry = {
                    "type": "Polygon",
                    "coordinates": [[*zone_points, zone_points[0]]],
                }
                zone_area_sqm = polygon_area_sqm(zone_geometry["coordinates"][0])
                zones.append(
                    {
                        "zone_id": f"zone-{sequence}",
                        "geometry": zone_geometry,
                        "points": zone_points,
                        "center": calculate_center(zone_points),
                        "area_sqm": round(zone_area_sqm, 2),
                        "area_hectares": round(zone_area_sqm / 10000, 4),
                        "sequence": sequence,
                    }
                )
                sequence += 1

            current_lng = next_lng

        current_lat = next_lat

    if not zones:
        zone_points = build_zone_square(area_points, area_center, max(total_area_sqm, chunk_area_sqm))
        zone_geometry = {
            "type": "Polygon",
            "coordinates": [[*zone_points, zone_points[0]]],
        }
        zone_area_sqm = polygon_area_sqm(zone_geometry["coordinates"][0])
        zones.append(
            {
                "zone_id": "zone-0",
                "geometry": zone_geometry,
                "points": zone_points,
                "center": area_center,
                "area_sqm": round(zone_area_sqm, 2),
                "area_hectares": round(zone_area_sqm / 10000, 4),
                "sequence": 0,
            }
        )

    zone_count = len(zones)

    area_geometry = {
        "type": "Feature",
        "properties": {},
        "geometry": deepcopy(area_feature.get("geometry", {})),
    }
    area_geometry.setdefault("properties", {})
    area_geometry["properties"].update(
        {
            "center": area_center,
            "area_sqm": round(total_area_sqm, 2),
            "area_hectares": round(total_area_sqm / 10000, 4),
            "cell_side_km": round(resolved_cell_side_km, 4),
        }
    )

    return {
        "area": {
            "geometry": area_geometry,
            "points": area_points,
            "center": area_center,
            "area_sqm": total_area_sqm,
            "area_hectares": total_area_sqm / 10000,
            "chunk_area_sqm": chunk_area_sqm,
            "cell_side_km": resolved_cell_side_km,
            "zone_count": zone_count,
        },
        "zones": zones,
    }


def build_rule_based_zone_metrics(index, coords):
    if coords:
        first_longitude, first_latitude = coords[0]
    else:
        first_longitude, first_latitude = (0.0, 0.0)

    seed = int((index * 7) + math.floor(first_latitude * 100) + math.floor(first_longitude * 100))
    crop_id = RULE_BASED_CROP_IDS[abs(seed) % len(RULE_BASED_CROP_IDS)]
    crop_metadata = RULE_BASED_PRODUCTS[crop_id]

    match_percent = 60 + (abs(seed) % 35)
    criteria = [
        {"name": "دما", "value": 55 + (abs(seed + 11) % 40)},
        {"name": "بارش", "value": 55 + (abs(seed + 17) % 40)},
        {"name": "خاک", "value": 55 + (abs(seed + 23) % 40)},
        {"name": "آب", "value": 55 + (abs(seed + 29) % 40)},
    ]
    soil_quality_score = criteria[2]["value"]
    soil_level = _pick_level(soil_quality_score, 65, 85)
    cultivation_risk_score = max(1, min(100, round(100 - match_percent + ((abs(seed) % 9) - 4))))
    cultivation_risk_level = "low" if cultivation_risk_score <= 30 else "medium" if cultivation_risk_score <= 60 else "high"

    return {
        "soil_quality_score": soil_quality_score,
        "soil_level": soil_level,
        "water_need_level": crop_metadata["water_need_level"],
        "water_need_value": crop_metadata["water_need"],
        "cultivation_risk_level": cultivation_risk_level,
        "recommended_crop": crop_id,
        "match_percent": match_percent,
        "estimated_profit": crop_metadata["estimated_profit"],
        "reason": crop_metadata["reason"],
        "criteria": criteria,
        "algorithm": RULE_BASED_ALGORITHM,
    }


def build_initial_zone_payload(zone):
    recommendation = getattr(zone, "recommendation", None)
    return {
        "zoneId": zone.zone_id,
        "geometry": zone.geometry,
        "crop": recommendation.product.product_id if recommendation else "",
        "matchPercent": recommendation.match_percent if recommendation else 0,
        "waterNeed": recommendation.water_need if recommendation else "",
        "estimatedProfit": recommendation.estimated_profit if recommendation else "",
    }


def build_area_zone_payload(zone):
    base_payload = _build_area_layer_zone_base_payload(zone)
    recommendation = getattr(zone, "recommendation", None)
    water_need_layer = getattr(zone, "water_need_layer", None)
    soil_quality_layer = getattr(zone, "soil_quality_layer", None)
    cultivation_risk_layer = getattr(zone, "cultivation_risk_layer", None)
    base_payload.update(
        {
            "crop": recommendation.product.product_id if recommendation else "",
            "matchPercent": recommendation.match_percent if recommendation else 0,
            "waterNeed": recommendation.water_need if recommendation else "",
            "estimatedProfit": recommendation.estimated_profit if recommendation else "",
            "waterNeedLayer": {
                "level": getattr(water_need_layer, "level", ""),
                "value": getattr(water_need_layer, "value", ""),
                "color": getattr(water_need_layer, "color", ""),
            },
            "soilQualityLayer": {
                "level": getattr(soil_quality_layer, "level", ""),
                "score": getattr(soil_quality_layer, "score", 0),
                "color": getattr(soil_quality_layer, "color", ""),
            },
            "cultivationRiskLayer": {
                "level": getattr(cultivation_risk_layer, "level", ""),
                "color": getattr(cultivation_risk_layer, "color", ""),
            },
        }
    )
    return base_payload


def _serialize_cluster_candidate(candidate_payload):
    if not isinstance(candidate_payload, dict):
        return None

    return {
        "plantId": candidate_payload.get("plant_id"),
        "plantName": str(candidate_payload.get("plant_name") or ""),
        "position": candidate_payload.get("position"),
        "stage": str(candidate_payload.get("stage") or ""),
        "score": candidate_payload.get("score"),
        "predictedYield": candidate_payload.get("predicted_yield"),
        "predictedYieldTons": candidate_payload.get("predicted_yield_tons"),
        "biomass": candidate_payload.get("biomass"),
        "maxLai": candidate_payload.get("max_lai"),
        "simulationEngine": candidate_payload.get("simulation_engine"),
        "simulationModelName": candidate_payload.get("simulation_model_name"),
        "simulationWarning": str(candidate_payload.get("simulation_warning") or ""),
        "supportingMetrics": deepcopy(candidate_payload.get("supporting_metrics") or {}),
    }


def _get_zone_ai_cluster_payload(zone):
    analysis = getattr(zone, "analysis", None)
    raw_response = getattr(analysis, "raw_response", None)
    if not isinstance(raw_response, dict):
        return {}

    cluster_payload = raw_response.get("cluster_recommendation") or {}
    if isinstance(cluster_payload, dict):
        return cluster_payload
    return {}


def _build_zone_cluster_info(zone, cluster_payload):
    cluster_block = cluster_payload.get("cluster_block") or {}
    return {
        "blockCode": str(cluster_payload.get("block_code") or ""),
        "clusterUuid": str(cluster_payload.get("cluster_uuid") or cluster_block.get("uuid") or zone.zone_id),
        "subBlockCode": str(cluster_payload.get("sub_block_code") or cluster_block.get("sub_block_code") or zone.zone_id),
        "clusterLabel": cluster_payload.get("cluster_label"),
        "cellCount": cluster_block.get("cell_count"),
        "cellCodes": deepcopy(cluster_block.get("cell_codes") or []),
        "centerCellCode": cluster_block.get("center_cell_code"),
        "centerCellLat": cluster_block.get("center_cell_lat"),
        "centerCellLon": cluster_block.get("center_cell_lon"),
        "sourceMetadata": deepcopy(cluster_payload.get("source_metadata") or {}),
    }


def _build_zone_cluster_metrics(cluster_payload):
    if not cluster_payload:
        return {
            "satelliteMetrics": {},
            "sensorMetrics": {},
            "resolvedMetrics": {},
            "criteria": [],
        }

    suggested_plant = cluster_payload.get("suggested_plant")
    return {
        "satelliteMetrics": deepcopy(cluster_payload.get("satellite_metrics") or {}),
        "sensorMetrics": deepcopy(cluster_payload.get("sensor_metrics") or {}),
        "resolvedMetrics": deepcopy(cluster_payload.get("resolved_metrics") or {}),
        "criteria": _build_metric_criteria(cluster_payload, suggested_plant),
    }


def _build_zone_crop_prediction(cluster_payload):
    if not cluster_payload:
        return {"suggestedPlant": None, "candidatePlants": []}

    return {
        "suggestedPlant": _serialize_cluster_candidate(cluster_payload.get("suggested_plant")),
        "candidatePlants": [
            item
            for item in (
                _serialize_cluster_candidate(candidate_payload)
                for candidate_payload in (cluster_payload.get("candidate_plants") or [])
            )
            if item is not None
        ],
    }


def _attach_ai_zone_payload(base_payload, zone):
    cluster_payload = _get_zone_ai_cluster_payload(zone)
    base_payload["clusterInfo"] = _build_zone_cluster_info(zone, cluster_payload)
    base_payload["clusterMetrics"] = _build_zone_cluster_metrics(cluster_payload)
    base_payload["cropPrediction"] = _build_zone_crop_prediction(cluster_payload)
    return base_payload


def _build_area_layer_zone_base_payload(zone):
    return _attach_ai_zone_payload(
        {
        "zoneId": zone.zone_id,
        "zoneUuid": str(zone.uuid),
        "geometry": zone.geometry,
        "center": zone.center,
        "area_sqm": zone.area_sqm,
        "area_hectares": zone.area_hectares,
        "sequence": zone.sequence,
        "processing_status": zone.processing_status,
        "processing_error": zone.processing_error,
        },
        zone,
    )


def build_water_need_area_zone_payload(zone):
    base_payload = _build_area_layer_zone_base_payload(zone)
    water_need_layer = getattr(zone, "water_need_layer", None)
    base_payload["waterNeedLayer"] = {
        "level": getattr(water_need_layer, "level", ""),
        "value": getattr(water_need_layer, "value", ""),
        "color": getattr(water_need_layer, "color", ""),
    }
    return base_payload


def build_soil_quality_area_zone_payload(zone):
    base_payload = _build_area_layer_zone_base_payload(zone)
    soil_quality_layer = getattr(zone, "soil_quality_layer", None)
    base_payload["soilQualityLayer"] = {
        "level": getattr(soil_quality_layer, "level", ""),
        "score": getattr(soil_quality_layer, "score", 0),
        "color": getattr(soil_quality_layer, "color", ""),
    }
    return base_payload


def build_cultivation_risk_area_zone_payload(zone):
    base_payload = _build_area_layer_zone_base_payload(zone)
    cultivation_risk_layer = getattr(zone, "cultivation_risk_layer", None)
    base_payload["cultivationRiskLayer"] = {
        "level": getattr(cultivation_risk_layer, "level", ""),
        "color": getattr(cultivation_risk_layer, "color", ""),
    }
    return base_payload


def persist_zone_analysis_metrics(zone, metrics):
    ensure_products_exist()
    product = CropProduct.objects.get(product_id=metrics["recommended_crop"])
    recommendation, _ = CropZoneRecommendation.objects.update_or_create(
        crop_zone=zone,
        defaults={
            "product": product,
            "match_percent": metrics["match_percent"],
            "water_need": metrics["water_need_value"],
            "estimated_profit": metrics["estimated_profit"],
            "reason": metrics["reason"],
        },
    )
    CropZoneCriteria.objects.filter(recommendation=recommendation).delete()
    CropZoneCriteria.objects.bulk_create(
        [
            CropZoneCriteria(
                recommendation=recommendation,
                name=item["name"],
                value=item["value"],
                sequence=index,
            )
            for index, item in enumerate(metrics["criteria"])
        ]
    )
    CropZoneWaterNeedLayer.objects.update_or_create(
        crop_zone=zone,
        defaults={
            "level": metrics["water_need_level"],
            "value": metrics["water_need_value"],
            "color": _get_level_color_map("water", metrics["water_need_level"]),
        },
    )
    CropZoneSoilQualityLayer.objects.update_or_create(
        crop_zone=zone,
        defaults={
            "level": metrics["soil_level"],
            "score": metrics["soil_quality_score"],
            "color": _get_level_color_map("soil", metrics["soil_level"]),
        },
    )
    CropZoneCultivationRiskLayer.objects.update_or_create(
        crop_zone=zone,
        defaults={
            "level": metrics["cultivation_risk_level"],
            "color": _get_level_color_map("risk", metrics["cultivation_risk_level"]),
        },
    )
    return recommendation


def ensure_rule_based_zone_data(zone, force=False):
    has_recommendation = CropZoneRecommendation.objects.filter(crop_zone=zone).exists()
    if has_recommendation and not force:
        return zone

    metrics = build_rule_based_zone_metrics(zone.sequence, zone.points)
    persist_zone_analysis_metrics(zone, metrics)
    return zone


def _get_level_color_map(layer_name, level):
    mappings = {
        "water": {"low": "#7dd3fc", "medium": "#0ea5e9", "high": "#0369a1"},
        "soil": {"low": "#ef4444", "medium": "#eab308", "high": "#22c55e"},
        "risk": {"low": "#22c55e", "medium": "#f59e0b", "high": "#ef4444"},
    }
    return mappings[layer_name][level]


def _pick_level(score, low_threshold, high_threshold):
    if score >= high_threshold:
        return "high"
    if score >= low_threshold:
        return "medium"
    return "low"


def _format_range(start, end, suffix):
    return f"{start}-{end} {suffix}"


def _derive_analysis_metrics(depths):
    if not depths:
        return {
            "soil_quality_score": 0,
            "soil_level": "low",
            "water_need_level": "high",
            "water_need_value": "0-0 m³/ha",
            "cultivation_risk_level": "high",
            "recommended_crop": PRODUCT_DEFAULTS[0]["id"],
            "match_percent": 0,
            "estimated_profit": "0-0 میلیون/هکتار",
            "reason": "داده تحلیل خاک موجود نیست",
            "criteria": [],
        }

    avg_ph = sum(item.get("phh2o", 0) for item in depths) / len(depths)
    avg_soc = sum(item.get("soc", 0) for item in depths) / len(depths)
    avg_clay = sum(item.get("clay", 0) for item in depths) / len(depths)
    avg_nitrogen = sum(item.get("nitrogen", 0) for item in depths) / len(depths)
    avg_wv0033 = sum(item.get("wv0033", 0) for item in depths) / len(depths)

    soil_quality_score = max(0, min(100, round((avg_soc * 20) + (avg_nitrogen * 120) + (avg_wv0033 * 120) + (20 - abs(avg_ph - 7) * 10))))
    soil_level = _pick_level(soil_quality_score, 50, 80)

    water_base = round(3000 + (avg_clay * 70))
    water_need_value = _format_range(water_base, water_base + 1000, "m³/ha")
    water_need_level = "low" if water_base < 4000 else "medium" if water_base < 5000 else "high"

    cultivation_risk_score = max(0, min(100, round(100 - soil_quality_score + abs(avg_ph - 7) * 8)))
    cultivation_risk_level = "low" if cultivation_risk_score <= 30 else "medium" if cultivation_risk_score <= 55 else "high"

    if water_need_level == "low" and soil_quality_score >= 85:
        recommended_crop = "saffron"
        estimated_profit = "۵۰-۱۵۰ میلیون/هکتار"
    elif soil_quality_score >= 70:
        recommended_crop = "wheat"
        estimated_profit = "۱۵-۲۵ میلیون/هکتار"
    else:
        recommended_crop = "canola"
        estimated_profit = "۲۰-۳۵ میلیون/هکتار"

    match_percent = max(1, min(100, round((soil_quality_score * 0.55) + ((100 - cultivation_risk_score) * 0.45))))
    reason = "خاک و شرایط رطوبتی این زون برای محصول پیشنهادی مناسب ارزیابی شده است"
    criteria = [
        {"name": "دما", "value": max(1, min(100, round(70 + (avg_ph - 6.5) * 10)))},
        {"name": "بارش", "value": max(1, min(100, round(60 + avg_wv0033 * 100)))},
        {"name": "خاک", "value": soil_quality_score},
        {"name": "آب", "value": max(1, min(100, round(100 - ((water_base - 3000) / 30))))},
    ]

    return {
        "soil_quality_score": soil_quality_score,
        "soil_level": soil_level,
        "water_need_level": water_need_level,
        "water_need_value": water_need_value,
        "cultivation_risk_level": cultivation_risk_level,
        "recommended_crop": recommended_crop,
        "match_percent": match_percent,
        "estimated_profit": estimated_profit,
        "reason": reason,
        "criteria": criteria,
    }


def fetch_soil_data_for_zone(zone):
    center = zone.center or calculate_center(zone.points)
    payload = {
        "lon": center["longitude"],
        "lat": center["latitude"],
        "zone": {
            "id": zone.zone_id,
            "geometry": zone.geometry,
            "center": center,
            "area_sqm": zone.area_sqm,
            "area_hectares": zone.area_hectares,
        },
    }
    return external_request("ai", "/soil-data", method="POST", payload=payload).data


def analyze_and_store_zone_soil_data(zone_id):
    ensure_products_exist()
    zone = CropZone.objects.select_related("crop_area").get(id=zone_id)
    if zone.processing_status == CropZone.STATUS_COMPLETED:
        return zone

    zone.processing_status = CropZone.STATUS_PROCESSING
    zone.processing_error = ""
    zone.save(update_fields=["processing_status", "processing_error", "updated_at"])

    try:
        adapter_data = fetch_soil_data_for_zone(zone)
        soil_data = adapter_data.get("data", {}) if isinstance(adapter_data, dict) else {}
        depths = soil_data.get("depths", [])
        metrics = _derive_analysis_metrics(depths)
        product = CropProduct.objects.get(product_id=metrics["recommended_crop"])

        CropZoneAnalysis.objects.update_or_create(
            crop_zone=zone,
            defaults={
                "source": soil_data.get("source", ""),
                "external_record_id": str(soil_data.get("id", "")),
                "longitude": Decimal(str(soil_data.get("lon", zone.center.get("longitude", 0)))),
                "latitude": Decimal(str(soil_data.get("lat", zone.center.get("latitude", 0)))),
                "raw_response": adapter_data if isinstance(adapter_data, dict) else {},
                "depths": depths,
            },
        )
        persist_zone_analysis_metrics(zone, metrics)
        zone.processing_status = CropZone.STATUS_COMPLETED
        zone.processing_error = ""
        zone.save(update_fields=["processing_status", "processing_error", "updated_at"])
    except Exception as exc:
        zone.processing_status = CropZone.STATUS_FAILED
        zone.processing_error = str(exc)
        zone.save(update_fields=["processing_status", "processing_error", "updated_at"])
        raise

    return zone


def _get_stale_zone_ids(zones):
    completed_task_ids = {
        zone.task_id
        for zone in zones
        if zone.processing_status == CropZone.STATUS_COMPLETED and zone.task_id
    }
    stale_before = timezone.now() - timedelta(seconds=get_task_stale_seconds())
    stale_zone_ids = []

    for zone in zones:
        if zone.processing_status == CropZone.STATUS_COMPLETED or not zone.task_id:
            continue
        if zone.task_id in completed_task_ids:
            stale_zone_ids.append(zone.id)
            continue
        if zone.updated_at > stale_before:
            continue

        try:
            task_state = AsyncResult(zone.task_id).state
        except Exception:
            task_state = TASK_STATE_PENDING

        if task_state in {
            TASK_STATE_PENDING,
            TASK_STATE_SUCCESS,
            TASK_STATE_FAILURE,
            TASK_STATE_REVOKED,
        }:
            stale_zone_ids.append(zone.id)

    return stale_zone_ids


def dispatch_zone_processing_tasks(crop_area_id=None, zone_ids=None, force=False):
    from .tasks import process_zone_soil_data

    queryset = CropZone.objects.all()
    if crop_area_id is not None:
        queryset = queryset.filter(crop_area_id=crop_area_id)
    if zone_ids is not None:
        queryset = queryset.filter(id__in=zone_ids)

    zones = list(queryset.only("id", "task_id", "processing_status").order_by("sequence", "id"))
    for zone in zones:
        if zone.processing_status == CropZone.STATUS_COMPLETED:
            continue
        if not force and zone.processing_status == CropZone.STATUS_PROCESSING and zone.task_id:
            continue
        if not force and zone.processing_status == CropZone.STATUS_PENDING and zone.task_id:
            continue

        try:
            async_result = process_zone_soil_data.delay(zone.id)
            task_identifier = getattr(async_result, "id", "") or str(uuid.uuid4())
            processing_error = ""
        except OperationalError as exc:
            task_identifier = str(uuid.uuid4())
            processing_error = f"Celery broker unavailable: {exc}"
        except Exception as exc:
            task_identifier = str(uuid.uuid4())
            processing_error = f"Celery dispatch failed: {exc}"

        update_fields = {
            "task_id": task_identifier,
            "processing_status": CropZone.STATUS_PENDING,
        }
        update_fields["processing_error"] = processing_error
        CropZone.objects.filter(id=zone.id).update(**update_fields)


def create_missing_zones_for_area(crop_area):
    if crop_area.zones.exists():
        return list(crop_area.zones.order_by("sequence", "id"))

    area_feature = normalize_area_feature(crop_area.geometry)
    zoning_result = split_area_into_zones(
        area_feature,
        cell_side_km=math.sqrt(max(crop_area.chunk_area_sqm, 1)) / 1000.0,
    )
    zones = CropZone.objects.bulk_create(
        [
            CropZone(
                crop_area=crop_area,
                zone_id=zone["zone_id"],
                geometry=zone["geometry"],
                points=zone["points"],
                center=zone["center"],
                area_sqm=round(zone["area_sqm"], 2),
                area_hectares=round(zone["area_hectares"], 4),
                sequence=zone["sequence"],
            )
            for zone in zoning_result["zones"]
        ]
    )
    crop_area.zone_count = len(zones)
    crop_area.save(update_fields=["zone_count", "updated_at"])
    return list(crop_area.zones.order_by("sequence", "id"))


def get_farm_for_uuid(farm_uuid, owner=None):
    if not farm_uuid:
        raise ValueError("farm_uuid is required.")

    filters = {"farm_uuid": farm_uuid}
    if owner is not None:
        filters["owner"] = owner

    try:
        return FarmHub.objects.get(**filters)
    except FarmHub.DoesNotExist as exc:
        raise ValueError("Farm not found.") from exc


def _raise_ai_response_error(response, default_message):
    payload = response.data if isinstance(response.data, dict) else {}
    message = payload.get("msg") or payload.get("message") or default_message
    if response.status_code >= 500:
        raise ImproperlyConfigured(message)
    raise ValueError(message)


def _unwrap_ai_response(response, *, expected_statuses):
    if response.status_code not in expected_statuses:
        _raise_ai_response_error(response, f"AI location_data API returned status {response.status_code}.")

    payload = response.data if isinstance(response.data, dict) else {}
    if "data" in payload:
        return payload["data"]
    return payload


def _request_ai_location_data(path, *, method="GET", payload=None, query=None):
    return external_request(
        "ai",
        path,
        method=method,
        payload=payload,
        query=query,
    )


def _feature_from_geometry(geometry):
    if not isinstance(geometry, dict):
        return get_default_area_feature()
    if geometry.get("type") == "Feature":
        return normalize_area_feature(geometry)
    return normalize_area_feature(
        {
            "type": "Feature",
            "properties": {},
            "geometry": geometry,
        }
    )


def _upsert_crop_area_snapshot(farm, area_feature):
    normalized_feature = normalize_area_feature(area_feature)
    ring = get_polygon_ring(normalized_feature)
    points = normalize_points(ring)
    area_sqm = round(polygon_area_sqm(ring), 2)
    area_hectares = round(area_sqm / 10000.0, 4)
    defaults = {
        "geometry": normalized_feature,
        "points": points,
        "center": calculate_center(points),
        "area_sqm": area_sqm,
        "area_hectares": area_hectares,
        "chunk_area_sqm": round(get_chunk_area_sqm(), 2),
    }

    crop_area = farm.current_crop_area
    if crop_area is None:
        crop_area = CropArea.objects.create(
            farm=farm,
            zone_count=0,
            **defaults,
        )
        farm.current_crop_area = crop_area
        farm.save(update_fields=["current_crop_area", "updated_at"])
        return crop_area

    for field_name, value in defaults.items():
        setattr(crop_area, field_name, value)
    crop_area.save(update_fields=[*defaults.keys(), "updated_at"])
    return crop_area


def _get_farm_area_feature(farm, fallback=None):
    if fallback is not None:
        return normalize_area_feature(fallback)

    crop_area = farm.current_crop_area or farm.crop_areas.order_by("-created_at", "-id").first()
    if crop_area is not None and crop_area.geometry:
        return normalize_area_feature(crop_area.geometry)

    return get_default_area_feature()


def _build_processing_layer_payload(farm, remote_payload, *, page, page_size):
    area_feature = _get_farm_area_feature(
        farm,
        fallback=((remote_payload.get("location") or {}).get("farm_boundary")),
    )
    location = remote_payload.get("location") or {}
    run = remote_payload.get("run") or {}
    status_value = str(remote_payload.get("status") or "").lower()
    task_status = "PROCESSING" if status_value == "processing" else "PENDING"

    return {
        "task": {
            "status": task_status,
            "stage": status_value or "queued",
            "stage_label": "در حال دریافت تقسیم بندی و متریک ها از AI",
            "area_uuid": str(getattr(farm.current_crop_area, "uuid", "")) if farm.current_crop_area_id else "",
            "total_zones": 0,
            "completed_zones": 0,
            "processing_zones": 0,
            "pending_zones": 0,
            "failed_zones": 0,
            "remaining_zones": 0,
            "progress_percent": 0,
            "summary": {
                "done": 0,
                "in_progress": 0,
                "remaining": 0,
                "failed": 0,
            },
            "message": "تقسیم بندی و متریک های کشت در AI در حال آماده سازی است.",
            "failed_zone_errors": [],
            "cell_side_km": round(get_default_cell_side_km(), 4),
            "task_id": remote_payload.get("task_id") or (run.get("metadata") or {}).get("task_id"),
        },
        "area": area_feature,
        "zones": [],
        "location": location,
        "farmerBlocks": deepcopy(((location.get("block_layout") or {}).get("blocks") or [])),
        "clusterBlocks": [],
        "pagination": {
            "page": page,
            "page_size": page_size,
            "total_pages": 0,
            "total_zones": 0,
            "returned_zones": 0,
            "has_next": False,
            "has_previous": False,
        },
    }


def _hash_color(value):
    digest = hashlib.md5(str(value).encode("utf-8")).hexdigest()
    return f"#{digest[:6]}"


def _clamp_percent(value, *, default=0):
    try:
        numeric = float(value)
    except (TypeError, ValueError):
        return default
    return max(0, min(100, round(numeric)))


def _extract_zone_points(geometry):
    coordinates = (geometry or {}).get("coordinates") or []
    if not coordinates or not coordinates[0]:
        return []
    ring = coordinates[0]
    return ring[:-1] if len(ring) > 1 and ring[0] == ring[-1] else ring


def _build_metric_criteria(cluster_payload, suggested_plant):
    resolved_metrics = cluster_payload.get("resolved_metrics") or {}
    criteria = []

    ndvi_score = _clamp_percent((resolved_metrics.get("ndvi") or 0) * 100)
    criteria.append({"name": "NDVI", "value": ndvi_score})

    ndwi_raw = resolved_metrics.get("ndwi")
    ndwi_score = _clamp_percent(((float(ndwi_raw) + 1.0) / 2.0) * 100) if ndwi_raw is not None else 0
    criteria.append({"name": "NDWI", "value": ndwi_score})

    soil_moisture = resolved_metrics.get("soil_moisture")
    if soil_moisture is not None:
        criteria.append({"name": "رطوبت خاک", "value": _clamp_percent(soil_moisture)})

    nitrogen = resolved_metrics.get("nitrogen")
    if nitrogen is not None:
        criteria.append({"name": "نیتروژن", "value": _clamp_percent(float(nitrogen) * 4)})

    if suggested_plant is not None:
        criteria.append({"name": "امتیاز AI", "value": _clamp_percent(suggested_plant.get("score"))})

    return criteria[:4]


def _derive_layer_bundle(cluster_payload, suggested_plant):
    resolved_metrics = cluster_payload.get("resolved_metrics") or {}
    criteria = _build_metric_criteria(cluster_payload, suggested_plant)
    soil_score = next((item["value"] for item in criteria if item["name"] in {"NDVI", "نیتروژن"}), 0)
    if soil_score >= 75:
        soil_level = "high"
    elif soil_score >= 45:
        soil_level = "medium"
    else:
        soil_level = "low"

    moisture_value = resolved_metrics.get("soil_moisture")
    ndwi_raw = resolved_metrics.get("ndwi")
    if moisture_value is not None:
        water_score = _clamp_percent(100 - float(moisture_value))
        water_value_text = f"{round(float(moisture_value), 2)}% soil moisture"
    elif ndwi_raw is not None:
        water_score = _clamp_percent(100 - (((float(ndwi_raw) + 1.0) / 2.0) * 100))
        water_value_text = f"NDWI {round(float(ndwi_raw), 3)}"
    else:
        water_score = 0
        water_value_text = ""
    if water_score >= 65:
        water_level = "high"
    elif water_score >= 35:
        water_level = "medium"
    else:
        water_level = "low"

    ai_score = _clamp_percent((suggested_plant or {}).get("score"))
    risk_score = max(0, min(100, round((100 - soil_score) * 0.6 + (100 - ai_score) * 0.4)))
    if risk_score >= 65:
        risk_level = "high"
    elif risk_score >= 35:
        risk_level = "medium"
    else:
        risk_level = "low"

    return {
        "criteria": criteria,
        "soil": {
            "score": soil_score,
            "level": soil_level,
            "color": _get_level_color_map("soil", soil_level),
        },
        "water": {
            "level": water_level,
            "value": water_value_text,
            "color": _get_level_color_map("water", water_level),
        },
        "risk": {
            "level": risk_level,
            "color": _get_level_color_map("risk", risk_level),
        },
    }


def _sync_crop_area_from_ai(farm, remote_payload, recommendation_payload=None):
    location_payload = remote_payload.get("location") or {}
    area_feature = _get_farm_area_feature(
        farm,
        fallback=location_payload.get("farm_boundary"),
    )
    crop_area = _upsert_crop_area_snapshot(farm, area_feature)
    subdivision_result = remote_payload.get("subdivision_result") or {}
    cluster_blocks = subdivision_result.get("cluster_blocks") or []
    recommendation_map = {}
    for cluster in (recommendation_payload or {}).get("clusters", []):
        cluster_uuid = str(cluster.get("cluster_uuid") or ((cluster.get("cluster_block") or {}).get("uuid") or ""))
        if cluster_uuid:
            recommendation_map[cluster_uuid] = cluster

    existing_zones = {zone.zone_id: zone for zone in crop_area.zones.all()}
    retained_zone_ids = []

    with transaction.atomic():
        for sequence, cluster_block in enumerate(
            sorted(cluster_blocks, key=lambda item: (item.get("cluster_label") is None, item.get("cluster_label"), item.get("sub_block_code") or ""))
        ):
            zone_id = str(cluster_block.get("uuid") or cluster_block.get("sub_block_code") or f"cluster-{sequence}")
            geometry = cluster_block.get("geometry") or {}
            points = _extract_zone_points(geometry)
            area_sqm = round(polygon_area_sqm((geometry.get("coordinates") or [[points]])[0]), 2) if geometry.get("coordinates") else 0.0
            area_hectares = round(area_sqm / 10000.0, 4)
            zone_defaults = {
                "geometry": geometry,
                "points": points,
                "center": {
                    "longitude": float(cluster_block.get("centroid_lon") or 0),
                    "latitude": float(cluster_block.get("centroid_lat") or 0),
                },
                "area_sqm": area_sqm,
                "area_hectares": area_hectares,
                "sequence": sequence,
                "processing_status": CropZone.STATUS_COMPLETED,
                "processing_error": "",
                "task_id": str(((remote_payload.get("run") or {}).get("metadata") or {}).get("task_id") or ""),
            }
            zone = existing_zones.get(zone_id)
            if zone is None:
                zone = CropZone.objects.create(crop_area=crop_area, zone_id=zone_id, **zone_defaults)
            else:
                for field_name, value in zone_defaults.items():
                    setattr(zone, field_name, value)
                zone.save(update_fields=[*zone_defaults.keys(), "updated_at"])
            retained_zone_ids.append(zone.zone_id)

            cluster_payload = recommendation_map.get(zone_id, {})
            suggested_plant = cluster_payload.get("suggested_plant")
            layer_bundle = _derive_layer_bundle(cluster_payload, suggested_plant)

            product_id = str((suggested_plant or {}).get("plant_name") or (suggested_plant or {}).get("plant_id") or "")
            if product_id:
                product, _ = CropProduct.objects.update_or_create(
                    product_id=product_id,
                    defaults={
                        "label": str((suggested_plant or {}).get("plant_name") or product_id),
                        "color": _hash_color(product_id),
                    },
                )
                recommendation, _ = CropZoneRecommendation.objects.update_or_create(
                    crop_zone=zone,
                    defaults={
                        "product": product,
                        "match_percent": _clamp_percent((suggested_plant or {}).get("score")),
                        "water_need": layer_bundle["water"]["value"],
                        "estimated_profit": (
                            f"{round(float((suggested_plant or {}).get('predicted_yield_tons')), 2)} ton/ha"
                            if (suggested_plant or {}).get("predicted_yield_tons") is not None
                            else ""
                        ),
                        "reason": "پیشنهاد محصول بر اساس متریک های سنجش از دور و تحلیل کلاستر AI تولید شده است.",
                    },
                )
                CropZoneCriteria.objects.filter(recommendation=recommendation).delete()
                CropZoneCriteria.objects.bulk_create(
                    [
                        CropZoneCriteria(
                            recommendation=recommendation,
                            name=item["name"],
                            value=item["value"],
                            sequence=index,
                        )
                        for index, item in enumerate(layer_bundle["criteria"])
                    ]
                )
            else:
                CropZoneRecommendation.objects.filter(crop_zone=zone).delete()

            CropZoneWaterNeedLayer.objects.update_or_create(
                crop_zone=zone,
                defaults=layer_bundle["water"],
            )
            CropZoneSoilQualityLayer.objects.update_or_create(
                crop_zone=zone,
                defaults=layer_bundle["soil"],
            )
            CropZoneCultivationRiskLayer.objects.update_or_create(
                crop_zone=zone,
                defaults=layer_bundle["risk"],
            )
            CropZoneAnalysis.objects.update_or_create(
                crop_zone=zone,
                defaults={
                    "source": "ai_location_data",
                    "external_record_id": zone_id,
                    "latitude": zone.center.get("latitude"),
                    "longitude": zone.center.get("longitude"),
                    "raw_response": {
                        "remote_sensing": remote_payload,
                        "cluster_recommendation": cluster_payload,
                    },
                    "depths": [],
                },
            )

        CropZone.objects.filter(crop_area=crop_area).exclude(zone_id__in=retained_zone_ids).delete()
        crop_area.zone_count = len(retained_zone_ids)
        crop_area.chunk_area_sqm = subdivision_result.get("chunk_size_sqm") or crop_area.chunk_area_sqm
        crop_area.save(update_fields=["zone_count", "chunk_area_sqm", "updated_at"])

    return crop_area


def _get_ai_remote_sensing_payload(*, farm_uuid, page, page_size):
    response = _request_ai_location_data(
        AI_REMOTE_SENSING_PATH,
        method="GET",
        query={
            "farm_uuid": str(farm_uuid),
            "page": page,
            "page_size": page_size,
        },
    )
    return _unwrap_ai_response(response, expected_statuses={200})


def _start_ai_remote_sensing(*, farm_uuid):
    response = _request_ai_location_data(
        AI_REMOTE_SENSING_PATH,
        method="POST",
        payload={"farm_uuid": str(farm_uuid)},
    )
    return _unwrap_ai_response(response, expected_statuses={202})


def _get_ai_cluster_recommendations(*, farm_uuid):
    response = _request_ai_location_data(
        AI_CLUSTER_RECOMMENDATIONS_PATH,
        method="GET",
        query={"farm_uuid": str(farm_uuid)},
    )
    return _unwrap_ai_response(response, expected_statuses={200})


def _build_ai_layer_context(remote_payload, recommendation_payload=None):
    location = deepcopy(remote_payload.get("location") or {})
    subdivision_result = deepcopy(remote_payload.get("subdivision_result") or {})
    run = deepcopy(remote_payload.get("run") or {})
    return {
        "source": {
            "type": "ai_location_data",
            "service": "ai",
            "status": str(remote_payload.get("status") or ""),
        },
        "location": location,
        "farmerBlocks": deepcopy(((location.get("block_layout") or {}).get("blocks") or [])),
        "clusterBlocks": deepcopy(subdivision_result.get("cluster_blocks") or []),
        "subdivisionSummary": {
            "clusterCount": subdivision_result.get("cluster_count")
            or len(subdivision_result.get("cluster_blocks") or []),
            "chunkSizeSqm": subdivision_result.get("chunk_size_sqm") or remote_payload.get("chunk_size_sqm"),
            "selectedFeatures": deepcopy(
                subdivision_result.get("selected_features")
                or run.get("selected_features")
                or []
            ),
            "temporalExtent": deepcopy(remote_payload.get("temporal_extent") or {}),
            "summary": deepcopy(remote_payload.get("summary") or {}),
        },
        "registeredPlants": deepcopy((recommendation_payload or {}).get("registered_plants") or []),
        "evaluatedPlantCount": (recommendation_payload or {}).get("evaluated_plant_count"),
    }


def _get_latest_layer_payload_from_ai(zone_builder, *, farm_uuid, owner=None, page=1, page_size=DEFAULT_ZONE_PAGE_SIZE):
    farm = get_farm_for_uuid(farm_uuid, owner=owner)
    remote_payload = _get_ai_remote_sensing_payload(
        farm_uuid=farm_uuid,
        page=page,
        page_size=page_size,
    )
    remote_status = str(remote_payload.get("status") or "").lower()
    if remote_status == "not_found":
        remote_payload = _start_ai_remote_sensing(farm_uuid=farm_uuid)
        return _build_processing_layer_payload(farm, remote_payload, page=page, page_size=page_size)
    if remote_status != "success":
        return _build_processing_layer_payload(farm, remote_payload, page=page, page_size=page_size)

    recommendation_payload = None
    try:
        recommendation_payload = _get_ai_cluster_recommendations(farm_uuid=farm_uuid)
    except ValueError:
        recommendation_payload = None

    crop_area = _sync_crop_area_from_ai(farm, remote_payload, recommendation_payload)
    return _build_latest_area_layer_payload(
        zone_builder,
        area=crop_area,
        page=page,
        page_size=page_size,
        extra_payload=_build_ai_layer_context(remote_payload, recommendation_payload),
    )


def ensure_latest_area_ready_for_processing(farm_uuid, area_feature=None, owner=None):
    farm = get_farm_for_uuid(farm_uuid, owner=owner)
    return _upsert_crop_area_snapshot(farm, _get_farm_area_feature(farm, fallback=area_feature))


def create_zones_and_dispatch(area_feature, cell_side_km=None, farm=None):
    if farm is None:
        raise ValueError("farm is required.")

    crop_area = _upsert_crop_area_snapshot(farm, area_feature)
    CropZone.objects.filter(crop_area=crop_area).delete()
    crop_area.zone_count = 0
    crop_area.chunk_area_sqm = round(get_chunk_area_sqm(cell_side_km), 2)
    crop_area.save(update_fields=["zone_count", "chunk_area_sqm", "updated_at"])
    return crop_area, []


def _zones_queryset(zone_ids=None):
    queryset = CropZone.objects.select_related(
        "recommendation__product",
        "water_need_layer",
        "soil_quality_layer",
        "cultivation_risk_layer",
        "analysis",
    ).prefetch_related(
        Prefetch("recommendation__criteria", queryset=CropZoneCriteria.objects.order_by("sequence", "id"))
    ).order_by("sequence", "id")
    if zone_ids:
        queryset = queryset.filter(zone_id__in=zone_ids)
    return queryset


def _get_idle_area_payload(page, page_size):
    return {
        "task": {
            "status": "IDLE",
            "area_uuid": "",
            "total_zones": 0,
            "completed_zones": 0,
            "processing_zones": 0,
            "pending_zones": 0,
            "failed_zones": 0,
            "failed_zone_errors": [],
            "cell_side_km": round(get_default_cell_side_km(), 4),
        },
        "area": get_default_area_feature(),
        "zones": [],
        "pagination": {
            "page": page,
            "page_size": page_size,
            "total_pages": 0,
            "total_zones": 0,
            "returned_zones": 0,
            "has_next": False,
            "has_previous": False,
        },
    }


def _build_latest_area_layer_payload(
    zone_builder,
    area=None,
    page=1,
    page_size=DEFAULT_ZONE_PAGE_SIZE,
    extra_payload=None,
):
    area = area or CropArea.objects.order_by("-created_at", "-id").first()
    if not area:
        return _get_idle_area_payload(page, page_size)

    status_zones = list(area.zones.only("zone_id", "task_id", "processing_status", "processing_error"))
    total_zones = len(status_zones)
    completed_zones = sum(1 for zone in status_zones if zone.processing_status == CropZone.STATUS_COMPLETED)
    processing_zones = sum(1 for zone in status_zones if zone.processing_status == CropZone.STATUS_PROCESSING)
    failed_zones = sum(1 for zone in status_zones if zone.processing_status == CropZone.STATUS_FAILED)
    pending_zones = sum(1 for zone in status_zones if zone.processing_status == CropZone.STATUS_PENDING)
    total_pages = math.ceil(total_zones / page_size) if total_zones else 0
    start_index = (page - 1) * page_size
    end_index = start_index + page_size
    zones = list(_zones_queryset().filter(crop_area=area)[start_index:end_index])

    if failed_zones:
        task_status = "FAILURE"
    elif total_zones and completed_zones == total_zones:
        task_status = "SUCCESS"
    elif processing_zones or completed_zones:
        task_status = "PROCESSING"
    else:
        task_status = "PENDING"

    current_stage = "waiting_to_start"
    if failed_zones:
        current_stage = "failed"
    elif total_zones and completed_zones == total_zones:
        current_stage = "completed"
    elif processing_zones:
        current_stage = "processing_zones"
    elif pending_zones and completed_zones:
        current_stage = "continuing_processing"
    elif pending_zones:
        current_stage = "queued"

    progress_percent = 0
    if total_zones:
        progress_percent = round((completed_zones / total_zones) * 100, 2)

    payload = {
        "task": {
            "status": task_status,
            "stage": current_stage,
            "stage_label": {
                "waiting_to_start": "در انتظار شروع پردازش",
                "queued": "تسک ساخته شده و در صف پردازش است",
                "processing_zones": "در حال پردازش زون‌ها",
                "continuing_processing": "بخشی از زون‌ها پردازش شده و بقیه در صف هستند",
                "completed": "پردازش همه زون‌ها کامل شده است",
                "failed": "پردازش بعضی زون‌ها با خطا مواجه شده است",
            }[current_stage],
            "area_uuid": str(area.uuid),
            "total_zones": total_zones,
            "completed_zones": completed_zones,
            "processing_zones": processing_zones,
            "pending_zones": pending_zones,
            "failed_zones": failed_zones,
            "remaining_zones": max(total_zones - completed_zones, 0),
            "progress_percent": progress_percent,
            "summary": {
                "done": completed_zones,
                "in_progress": processing_zones,
                "remaining": pending_zones,
                "failed": failed_zones,
            },
            "message": f"از مجموع {total_zones} زون، {completed_zones} زون پردازش شده، {processing_zones} زون در حال پردازش و {pending_zones} زون باقی مانده است.",
            "failed_zone_errors": [
                {
                    "zoneId": zone.zone_id,
                    "error": zone.processing_error,
                }
                for zone in status_zones
                if zone.processing_status == CropZone.STATUS_FAILED and zone.processing_error
            ],
            "cell_side_km": round(math.sqrt(max(area.chunk_area_sqm, 1)) / 1000.0, 4),
        },
        "area": area.geometry,
        "zones": [zone_builder(zone) for zone in zones],
        "pagination": {
            "page": page,
            "page_size": page_size,
            "total_pages": total_pages,
            "total_zones": total_zones,
            "returned_zones": len(zones),
            "has_next": page < total_pages,
            "has_previous": page > 1 and total_pages > 0,
        },
    }
    if extra_payload:
        payload.update(extra_payload)
    return payload


def get_latest_area_payload(*, farm_uuid, owner=None, page=1, page_size=DEFAULT_ZONE_PAGE_SIZE):
    return _get_latest_layer_payload_from_ai(
        build_area_zone_payload,
        farm_uuid=farm_uuid,
        owner=owner,
        page=page,
        page_size=page_size,
    )


def get_latest_water_need_payload(*, farm_uuid, owner=None, page=1, page_size=DEFAULT_ZONE_PAGE_SIZE):
    return _get_latest_layer_payload_from_ai(
        build_water_need_area_zone_payload,
        farm_uuid=farm_uuid,
        owner=owner,
        page=page,
        page_size=page_size,
    )


def get_latest_soil_quality_payload(*, farm_uuid, owner=None, page=1, page_size=DEFAULT_ZONE_PAGE_SIZE):
    return _get_latest_layer_payload_from_ai(
        build_soil_quality_area_zone_payload,
        farm_uuid=farm_uuid,
        owner=owner,
        page=page,
        page_size=page_size,
    )


def get_latest_cultivation_risk_payload(*, farm_uuid, owner=None, page=1, page_size=DEFAULT_ZONE_PAGE_SIZE):
    return _get_latest_layer_payload_from_ai(
        build_cultivation_risk_area_zone_payload,
        farm_uuid=farm_uuid,
        owner=owner,
        page=page,
        page_size=page_size,
    )


def get_initial_zones_payload(crop_area):
    zones = _zones_queryset().filter(crop_area=crop_area)
    return {
        "total_area_hectares": crop_area.area_hectares,
        "total_area_sqm": crop_area.area_sqm,
        "zone_count": crop_area.zone_count,
        "zones": [build_initial_zone_payload(zone) for zone in zones],
    }


def get_water_need_payload(zone_ids=None):
    zones = _zones_queryset(zone_ids)
    return {
        "zones": [
            {
                "zoneId": zone.zone_id,
                "geometry": zone.geometry,
                "level": getattr(zone.water_need_layer, "level", ""),
                "value": getattr(zone.water_need_layer, "value", ""),
                "color": getattr(zone.water_need_layer, "color", ""),
            }
            for zone in zones
        ]
    }


def get_soil_quality_payload(zone_ids=None):
    zones = _zones_queryset(zone_ids)
    return {
        "zones": [
            {
                "zoneId": zone.zone_id,
                "geometry": zone.geometry,
                "level": getattr(zone.soil_quality_layer, "level", ""),
                "score": getattr(zone.soil_quality_layer, "score", 0),
                "color": getattr(zone.soil_quality_layer, "color", ""),
            }
            for zone in zones
        ]
    }


def get_cultivation_risk_payload(zone_ids=None):
    zones = _zones_queryset(zone_ids)
    return {
        "zones": [
            {
                "zoneId": zone.zone_id,
                "geometry": zone.geometry,
                "level": getattr(zone.cultivation_risk_layer, "level", ""),
                "color": getattr(zone.cultivation_risk_layer, "color", ""),
            }
            for zone in zones
        ]
    }


def get_zone_details_payload(zone_id, *, farm_uuid=None, owner=None):
    zone_filters = {"zone_id": zone_id}
    if farm_uuid:
        _get_latest_layer_payload_from_ai(
            build_area_zone_payload,
            farm_uuid=farm_uuid,
            owner=owner,
            page=1,
            page_size=DEFAULT_ZONE_PAGE_SIZE,
        )
        zone_filters["crop_area__farm__farm_uuid"] = farm_uuid
    if owner is not None:
        zone_filters["crop_area__farm__owner"] = owner

    zone = _zones_queryset().get(**zone_filters)
    recommendation = getattr(zone, "recommendation", None)
    criteria = recommendation.criteria.all() if recommendation else []
    cluster_payload = _get_zone_ai_cluster_payload(zone)
    return {
        "zoneId": zone.zone_id,
        "crop": recommendation.product.product_id if recommendation else "",
        "matchPercent": recommendation.match_percent if recommendation else 0,
        "waterNeed": recommendation.water_need if recommendation else "",
        "estimatedProfit": recommendation.estimated_profit if recommendation else "",
        "reason": recommendation.reason if recommendation else "",
        "criteria": [{"name": item.name, "value": item.value} for item in criteria],
        "area_hectares": zone.area_hectares,
        "clusterInfo": _build_zone_cluster_info(zone, cluster_payload),
        "clusterMetrics": _build_zone_cluster_metrics(cluster_payload),
        "cropPrediction": _build_zone_crop_prediction(cluster_payload),
    }