UPDATE

rag/services/fertilization.py

@@ -5,6 +5,8 @@
 import json
 import logging
 
+from django.apps import apps
+
 from farm_data.models import SensorData
 from rag.api_provider import get_chat_client
 from rag.chat import (
@@ -23,23 +25,153 @@ KB_NAME = "fertilization"
 SERVICE_ID = "fertilization"
 
 DEFAULT_FERTILIZATION_PROMPT = (
-    "بر اساس داده‌های خاک (NPK، pH)، مشخصات گیاه، مرحله رشد و پایگاه دانش کودهی، "
-    "یک توصیه کودهی دقیق بده. "
-    "پاسخ حتماً به فرمت JSON با ساختار زیر باشد:\n"
-    '{\n'
-    '    "plan": {\n'
-    '        "npkRatio": "<str>",\n'
-    '        "amountPerHectare": "<str>",\n'
-    '        "applicationMethod": "<str>",\n'
-    '        "applicationInterval": "<str>",\n'
-    '        "reasoning": "<str>"\n'
-    '    }\n'
-    '}\n'
-    "فقط JSON خروجی بده، بدون توضیح اضافی. "
-    "مقادیر را بر اساس شرایط واقعی خاک و گیاه محاسبه کن."
+    "از داده های خاک، مرحله رشد و خروجی بهینه ساز شبیه سازی برای ساخت توصیه کودهی استفاده کن. "
+    "اگر بلوک [خروجی بهینه ساز شبیه سازی] وجود داشت، همان را مرجع اصلی فرمول، مقدار، روش مصرف و اعتبار قرار بده. "
+    "پاسخ فقط JSON معتبر با کلید sections باشد."
 )
 
 
+def _get_optimizer():
+    return apps.get_app_config("crop_simulation").get_recommendation_optimizer()
+
+
+def _unique_items(items: list[str]) -> list[str]:
+    seen = set()
+    output = []
+    for item in items:
+        normalized = (item or "").strip()
+        if not normalized or normalized in seen:
+            continue
+        seen.add(normalized)
+        output.append(normalized)
+    return output
+
+
+def _find_section(sections: list[dict], section_type: str) -> dict | None:
+    for section in sections:
+        if isinstance(section, dict) and section.get("type") == section_type:
+            return section
+    return None
+
+
+def _build_fertilization_fallback(*, optimized_result: dict | None) -> dict:
+    if optimized_result:
+        recommended = optimized_result["recommended_strategy"]
+        list_items = [
+            f"دوز پیشنهادی: {recommended['amount_kg_per_ha']} کیلوگرم در هکتار",
+            f"روش مصرف: {recommended['application_method']}",
+            f"پنجره اجرا: {recommended['validity_period']}",
+        ]
+        warning_text = "قبل از اختلاط یا محلول سازی، سازگاری کود با آب و شرایط مزرعه بررسی شود."
+        return {
+            "sections": [
+                {
+                    "type": "recommendation",
+                    "title": "برنامه کودهی بهینه",
+                    "icon": "leaf",
+                    "content": (
+                        f"سناریوی {recommended['label']} برای این مزرعه مناسب تر ارزیابی شد."
+                    ),
+                    "fertilizerType": recommended["fertilizer_type"],
+                    "amount": f"{recommended['amount_kg_per_ha']} کیلوگرم در هکتار",
+                    "applicationMethod": recommended["application_method"],
+                    "timing": recommended["timing"],
+                    "validityPeriod": recommended["validity_period"],
+                    "expandableExplanation": " ".join(recommended.get("reasoning", [])),
+                },
+                {
+                    "type": "list",
+                    "title": "نکات اجرایی و اختلاط",
+                    "icon": "list",
+                    "items": _unique_items(list_items),
+                },
+                {
+                    "type": "warning",
+                    "title": "هشدار کودهی",
+                    "icon": "alert-triangle",
+                    "content": warning_text,
+                },
+            ]
+        }
+
+    return {
+        "sections": [
+            {
+                "type": "recommendation",
+                "title": "برنامه کودهی پیشنهادی",
+                "icon": "leaf",
+                "content": "پیشنهاد کودهی بر اساس داده های فعلی با قطعیت متوسط آماده شده است.",
+                "fertilizerType": "کود کامل متعادل",
+                "amount": "پس از پایش دوباره عناصر اصلی تعیین شود",
+                "applicationMethod": "ترجیحا همراه آب آبیاری",
+                "timing": "صبح زود",
+                "validityPeriod": "معتبر برای 5 روز آینده",
+                "expandableExplanation": "به دلیل محدود بودن داده های تغذیه ای، تصمیم نهایی باید با پایش مجدد تکمیل شود.",
+            },
+            {
+                "type": "list",
+                "title": "نکات اجرایی و اختلاط",
+                "icon": "list",
+                "items": [
+                    "قبل از مصرف، EC و pH محلول بررسی شود.",
+                    "در صورت مشاهده بارش موثر، زمان مصرف بازبینی شود.",
+                ],
+            },
+            {
+                "type": "warning",
+                "title": "هشدار کودهی",
+                "icon": "alert-triangle",
+                "content": "بدون بررسی دوباره مزرعه از مصرف سنگین کود خودداری شود.",
+            },
+        ]
+    }
+
+
+def _merge_fertilization_response(
+    *,
+    parsed_result: dict,
+    optimized_result: dict | None,
+) -> dict:
+    fallback = _build_fertilization_fallback(optimized_result=optimized_result)
+    if not isinstance(parsed_result, dict):
+        return fallback
+
+    sections = parsed_result.get("sections")
+    if not isinstance(sections, list):
+        return fallback
+
+    recommendation = _find_section(sections, "recommendation") or {}
+    list_section = _find_section(sections, "list") or {}
+    warning_section = _find_section(sections, "warning") or {}
+
+    fallback_recommendation = fallback["sections"][0]
+    fallback_list = fallback["sections"][1]
+    fallback_warning = fallback["sections"][2]
+
+    merged_recommendation = {**recommendation, **fallback_recommendation}
+    merged_recommendation["content"] = recommendation.get("content") or fallback_recommendation["content"]
+    merged_recommendation["title"] = recommendation.get("title") or fallback_recommendation["title"]
+    merged_recommendation["expandableExplanation"] = (
+        recommendation.get("expandableExplanation")
+        or fallback_recommendation["expandableExplanation"]
+    )
+
+    merged_list = {
+        **fallback_list,
+        **list_section,
+        "items": _unique_items(
+            list(list_section.get("items", [])) + list(fallback_list["items"])
+        )[:5],
+    }
+    merged_warning = {
+        **fallback_warning,
+        **warning_section,
+        "content": warning_section.get("content") or fallback_warning["content"],
+    }
+
+    return {"sections": [merged_recommendation, merged_list, merged_warning]}
+
+
 def get_fertilization_recommendation(
     sensor_uuid: str,
     plant_name: str | None = None,
@@ -80,15 +212,38 @@ def get_fertilization_recommendation(
     user_query = query or "توصیه کودهی برای مزرعه من چیست؟"
 
     sensor = (
-        SensorData.objects.prefetch_related("plants")
+        SensorData.objects.select_related("center_location")
+        .prefetch_related("plants")
         .filter(farm_uuid=sensor_uuid)
         .first()
     )
     resolved_plant_name = plant_name
+    plant = None
     if not resolved_plant_name and sensor is not None:
         plant = sensor.plants.first()
         if plant is not None:
             resolved_plant_name = plant.name
+    elif sensor is not None and plant_name:
+        plant = sensor.plants.filter(name=plant_name).first() or sensor.plants.first()
+
+    forecasts = []
+    optimized_result = None
+    if sensor is not None and getattr(sensor, "center_location", None) is not None:
+        from weather.models import WeatherForecast
+
+        forecasts = list(
+            WeatherForecast.objects.filter(
+                location=sensor.center_location,
+                forecast_date__isnull=False,
+            ).order_by("forecast_date")[:7]
+        )
+    if sensor is not None and plant is not None:
+        optimized_result = _get_optimizer().optimize_fertilization(
+            sensor=sensor,
+            plant=plant,
+            forecasts=forecasts,
+            growth_stage=growth_stage,
+        )
 
     context = build_rag_context(
         user_query, sensor_uuid, config=cfg, limit=limit, kb_name=KB_NAME, service_id=SERVICE_ID,
@@ -99,6 +254,11 @@ def get_fertilization_recommendation(
         plant_text = build_plant_text(resolved_plant_name, growth_stage)
         if plant_text:
             extra_parts.append("[اطلاعات گیاه]\n" + plant_text)
+    if optimized_result is not None:
+        extra_parts.append(
+            "[خروجی بهینه ساز شبیه سازی]\n"
+            + optimized_result["context_text"]
+        )
     if extra_parts:
         context = "\n\n---\n\n".join(extra_parts) + ("\n\n---\n\n" + context if context else "")
 
@@ -132,14 +292,9 @@ def get_fertilization_recommendation(
         raw = response.choices[0].message.content.strip()
     except Exception as exc:
         logger.error("Fertilization recommendation error for %s: %s", sensor_uuid, exc)
-        result = {
-            "fertilizer_needed": None,
-            "fertilizer_type": None,
-            "amount_kg_per_hectare": None,
-            "reason": f"خطا در دریافت توصیه: {exc}",
-            "npk_status": None,
-            "raw_response": None,
-        }
+        result = _build_fertilization_fallback(optimized_result=optimized_result)
+        result["error"] = f"خطا در دریافت توصیه: {exc}"
+        result["raw_response"] = None
         _fail_audit_log(
             audit_log,
             str(exc),
@@ -153,13 +308,14 @@ def get_fertilization_recommendation(
             cleaned = cleaned.strip("`").removeprefix("json").strip()
         result = json.loads(cleaned)
     except (json.JSONDecodeError, ValueError):
-        result = {
-            "plan": {
-                "reasoning": raw,
-            },
-        }
+        result = {}
 
+    result = _merge_fertilization_response(
+        parsed_result=result,
+        optimized_result=optimized_result,
+    )
     result["raw_response"] = raw
+    result["simulation_optimizer"] = optimized_result
     _complete_audit_log(
         audit_log,
         json.dumps(result, ensure_ascii=False, default=str),