Automazione Vertical Farming: Controllo Robotico via API

"""
Vertical Farm Environmental Controller
Controller PID per gestione LED, CO2, temperatura e irrigazione
"""
import time
import asyncio
import logging
from dataclasses import dataclass, field
from typing import Optional
from enum import Enum

logger = logging.getLogger(__name__)


class CropStage(Enum):
    GERMINATION = "germination"
    SEEDLING = "seedling"
    VEGETATIVE = "vegetative"
    MATURATION = "maturation"
    HARVEST_READY = "harvest_ready"


@dataclass
class LightRecipe:
    """Ricetta luminosa per una coltura in un determinato stadio"""
    crop_name: str
    stage: CropStage
    ppfd_target: float          # µmol/m²/s
    dli_target: float           # mol/m²/giorno
    photoperiod_hours: float    # ore di luce al giorno
    spectrum_red_pct: float     # % canale rosso (620-700nm)
    spectrum_blue_pct: float    # % canale blu (400-500nm)
    spectrum_white_pct: float   # % LED bianco full-spectrum
    spectrum_farred_pct: float  # % far-red (700-800nm)
    spectrum_uv_pct: float = 0.0

    def validate(self) -> bool:
        total = (self.spectrum_red_pct + self.spectrum_blue_pct +
                 self.spectrum_white_pct + self.spectrum_farred_pct +
                 self.spectrum_uv_pct)
        return abs(total - 100.0) < 0.1

    def ppfd_from_dli(self) -> float:
        """Calcola PPFD target dalle ore di fotoperiodo e DLI"""
        photoperiod_seconds = self.photoperiod_hours * 3600
        return (self.dli_target * 1_000_000) / photoperiod_seconds


@dataclass
class PIDController:
    """
    Controller PID generico per parametri ambientali.
    Usa anti-windup per prevenire integrator saturation.
    """
    kp: float
    ki: float
    kd: float
    setpoint: float
    output_min: float = 0.0
    output_max: float = 100.0
    _integral: float = field(default=0.0, init=False)
    _last_error: float = field(default=0.0, init=False)
    _last_time: float = field(default_factory=time.time, init=False)

    def compute(self, measured_value: float) -> float:
        current_time = time.time()
        dt = current_time - self._last_time
        if dt <= 0:
            return self._last_output if hasattr(self, '_last_output') else 0.0

        error = self.setpoint - measured_value

        # Proporzionale
        p_term = self.kp * error

        # Integrale con anti-windup (clamping)
        self._integral += error * dt
        i_term = self.ki * self._integral
        # Clamp integrale per prevenire windup
        i_max = (self.output_max - self.output_min) / self.ki if self.ki != 0 else 1000
        self._integral = max(-i_max, min(i_max, self._integral))
        i_term = self.ki * self._integral

        # Derivativo
        d_term = self.kd * (error - self._last_error) / dt if dt > 0 else 0.0

        output = p_term + i_term + d_term
        output = max(self.output_min, min(self.output_max, output))

        self._last_error = error
        self._last_time = current_time
        self._last_output = output
        return output


class EnvironmentalController:
    """
    Controller principale per una zona di coltivazione.
    Gestisce temperatura, CO2, umidita e irrigazione via PID.
    """
    def __init__(self, zone_id: str, recipe: LightRecipe):
        self.zone_id = zone_id
        self.recipe = recipe

        # PID temperatura: setpoint 21°C, banda ±1°C
        self.temp_pid = PIDController(
            kp=2.0, ki=0.5, kd=0.1,
            setpoint=21.0,
            output_min=-100.0,  # raffreddamento
            output_max=100.0    # riscaldamento
        )

        # PID CO2: setpoint 1200 ppm per crescita accelerata
        self.co2_pid = PIDController(
            kp=0.5, ki=0.1, kd=0.05,
            setpoint=1200.0,
            output_min=0.0,
            output_max=100.0    # % apertura valvola CO2
        )

        # PID umidita relativa: setpoint 70%
        self.humidity_pid = PIDController(
            kp=1.5, ki=0.3, kd=0.05,
            setpoint=70.0,
            output_min=0.0,
            output_max=100.0
        )

    def compute_led_pwm(self, current_hour: float) -> dict:
        """
        Calcola duty cycle PWM per ogni canale LED
        in base all'ora del giorno e alla ricetta.
        """
        # Determina se siamo nel fotoperiodo attivo
        # Fotoperiodo: ore 6:00 - (6 + photoperiod_hours)
        start_hour = 6.0
        end_hour = start_hour + self.recipe.photoperiod_hours

        if not (start_hour <= current_hour < end_hour):
            return {
                'red': 0.0, 'blue': 0.0,
                'white': 0.0, 'farred': 0.0, 'uv': 0.0
            }

        # Calcola intensità normalizzata (0-1) dal PPFD target
        # Assumendo che 100% PWM = 600 µmol/m²/s
        max_ppfd = 600.0
        intensity = min(self.recipe.ppfd_target / max_ppfd, 1.0)

        return {
            'red':    round(intensity * self.recipe.spectrum_red_pct / 100, 4),
            'blue':   round(intensity * self.recipe.spectrum_blue_pct / 100, 4),
            'white':  round(intensity * self.recipe.spectrum_white_pct / 100, 4),
            'farred': round(intensity * self.recipe.spectrum_farred_pct / 100, 4),
            'uv':     round(intensity * self.recipe.spectrum_uv_pct / 100, 4),
        }

    async def control_loop(self, sensor_reader, actuator_writer, interval: float = 30.0):
        """
        Loop di controllo asincrono: legge sensori, calcola PID, scrive attuatori.
        Frequenza default: ogni 30 secondi.
        """
        logger.info(f"Avvio loop controllo zona {self.zone_id}")
        while True:
            try:
                # Leggi sensori
                sensors = await sensor_reader.read_zone(self.zone_id)

                # Calcola output PID
                temp_output = self.temp_pid.compute(sensors['temperature'])
                co2_output = self.co2_pid.compute(sensors['co2_ppm'])
                humidity_output = self.humidity_pid.compute(sensors['humidity_rh'])

                # Calcola PWM LED
                from datetime import datetime
                current_hour = datetime.now().hour + datetime.now().minute / 60.0
                led_pwm = self.compute_led_pwm(current_hour)

                # Scrivi attuatori
                await actuator_writer.set_hvac(self.zone_id, temp_output, humidity_output)
                await actuator_writer.set_co2_valve(self.zone_id, co2_output)
                await actuator_writer.set_led_channels(self.zone_id, led_pwm)

                logger.debug(
                    f"Zona {self.zone_id} | "
                    f"T={sensors['temperature']:.1f}°C (PID:{temp_output:.1f}%) | "
                    f"CO2={sensors['co2_ppm']:.0f}ppm (valve:{co2_output:.1f}%) | "
                    f"RH={sensors['humidity_rh']:.1f}% | "
                    f"LED R:{led_pwm['red']:.2f} B:{led_pwm['blue']:.2f}"
                )

            except Exception as e:
                logger.error(f"Errore loop controllo zona {self.zone_id}: {e}")

            await asyncio.sleep(interval)


# --- Ricette standard per colture comuni ---

LETTUCE_VEGETATIVE = LightRecipe(
    crop_name="Lattuga Lollo",
    stage=CropStage.VEGETATIVE,
    ppfd_target=200.0,
    dli_target=17.0,
    photoperiod_hours=16.0,
    spectrum_red_pct=65.0,
    spectrum_blue_pct=20.0,
    spectrum_white_pct=10.0,
    spectrum_farred_pct=5.0,
    spectrum_uv_pct=0.0,
)

BASIL_VEGETATIVE = LightRecipe(
    crop_name="Basilico Genovese",
    stage=CropStage.VEGETATIVE,
    ppfd_target=250.0,
    dli_target=15.0,
    photoperiod_hours=16.0,
    spectrum_red_pct=60.0,
    spectrum_blue_pct=25.0,   # blue elevato per aromi
    spectrum_white_pct=10.0,
    spectrum_farred_pct=5.0,
    spectrum_uv_pct=0.0,
)

STRAWBERRY_FLOWERING = LightRecipe(
    crop_name="Fragola Elsanta",
    stage=CropStage.MATURATION,
    ppfd_target=350.0,
    dli_target=22.0,
    photoperiod_hours=12.0,  # fotoperiodo corto per fioritura
    spectrum_red_pct=55.0,
    spectrum_blue_pct=20.0,
    spectrum_white_pct=20.0,
    spectrum_farred_pct=5.0,
    spectrum_uv_pct=0.0,
)

"""
Irrigation Controller per sistema NFT
Gestione pompe, monitoraggio EC/pH, dosaggio nutrienti
"""
import asyncio
from dataclasses import dataclass
from typing import Optional
import logging

logger = logging.getLogger(__name__)

NUTRIENT_TARGETS = {
    "lettuce":    {"ec_ms_cm": 1.6, "ph": 6.0, "temp_c": 20.0},
    "basil":      {"ec_ms_cm": 1.8, "ph": 6.0, "temp_c": 21.0},
    "spinach":    {"ec_ms_cm": 2.0, "ph": 6.2, "temp_c": 20.0},
    "strawberry": {"ec_ms_cm": 2.2, "ph": 5.8, "temp_c": 18.0},
    "herbs":      {"ec_ms_cm": 1.4, "ph": 6.0, "temp_c": 21.0},
}

@dataclass
class NFTController:
    zone_id: str
    crop_type: str
    flow_rate_lpm: float = 1.5   # litri/minuto per canale
    channel_slope_pct: float = 2.0  # pendenza canale in %

    def get_targets(self) -> dict:
        return NUTRIENT_TARGETS.get(self.crop_type, NUTRIENT_TARGETS["lettuce"])

    async def check_and_adjust(self, ec_sensor: float, ph_sensor: float,
                                ec_doser, ph_doser) -> dict:
        targets = self.get_targets()
        actions = {}

        # Controllo EC
        ec_delta = targets["ec_ms_cm"] - ec_sensor
        if abs(ec_delta) > 0.2:
            if ec_delta > 0:
                # EC troppo bassa: aggiungi concentrato nutrienti
                dose_ml = ec_delta * 50  # ml di concentrato A+B
                await ec_doser.dose(zone=self.zone_id, ml=dose_ml, solution="AB")
                actions["ec_dosing"] = f"+{dose_ml:.1f}ml AB"
            else:
                # EC troppo alta: diluisci con acqua RO
                await ec_doser.dose_water(zone=self.zone_id, ml=abs(ec_delta) * 100)
                actions["ec_dilution"] = f"+{abs(ec_delta)*100:.0f}ml H2O"

        # Controllo pH
        ph_delta = targets["ph"] - ph_sensor
        if abs(ph_delta) > 0.3:
            if ph_delta > 0:
                # pH troppo basso: aggiungi pH-up (KOH)
                dose_ml = abs(ph_delta) * 10
                await ph_doser.dose(zone=self.zone_id, ml=dose_ml, solution="ph_up")
                actions["ph_adjust"] = f"pH-up +{dose_ml:.1f}ml"
            else:
                # pH troppo alto: aggiungi pH-down (H3PO4)
                dose_ml = abs(ph_delta) * 10
                await ph_doser.dose(zone=self.zone_id, ml=dose_ml, solution="ph_down")
                actions["ph_adjust"] = f"pH-down +{dose_ml:.1f}ml"

        logger.info(
            f"NFT zona {self.zone_id} | "
            f"EC: {ec_sensor:.2f} (target {targets['ec_ms_cm']:.2f}) | "
            f"pH: {ph_sensor:.2f} (target {targets['ph']:.2f}) | "
            f"Azioni: {actions}"
        )
        return actions

"""
ROS2 Node per Harvesting Robot in Vertical Farm
Gestisce pianificazione percorso, prelievo e deposito vassoi
"""
import rclpy
from rclpy.node import Node
from rclpy.action import ActionServer
from geometry_msgs.msg import Pose, PoseStamped
from std_msgs.msg import String, Bool
from sensor_msgs.msg import Image
import json
import asyncio

# Messaggi custom per la farm (definiti in farm_interfaces package)
# from farm_interfaces.msg import TrayInfo, HarvestStatus
# from farm_interfaces.action import HarvestTray
# from farm_interfaces.srv import GetZoneLayout


class HarvestingRobotNode(Node):
    """
    Nodo ROS2 per robot di raccolta in vertical farm.
    Si interfaccia con:
    - Sistema SCADA per ricevere job di raccolta
    - Controller braccio robotico (MoveIt2)
    - Sistema conveyor per deposito vassoi
    - Computer vision per verifica maturita
    """

    def __init__(self):
        super().__init__('harvesting_robot_node')

        # Publisher stato robot
        self.status_pub = self.create_publisher(
            String, '/farm/robot/harvest/status', 10
        )

        # Subscriber per job di raccolta da SCADA
        self.job_sub = self.create_subscription(
            String, '/farm/scada/harvest_jobs',
            self.on_harvest_job, 10
        )

        # Subscriber per immagine camera end-effector
        self.camera_sub = self.create_subscription(
            Image, '/robot/camera/raw',
            self.on_camera_frame, 10
        )

        # Client per servizio layout zona
        # self.layout_client = self.create_client(GetZoneLayout, '/farm/zone/layout')

        self.current_job: dict = {}
        self.is_busy = False
        self.get_logger().info('HarvestingRobotNode avviato')

    def on_harvest_job(self, msg: String):
        """Riceve job di raccolta dallo SCADA"""
        if self.is_busy:
            self.get_logger().warn('Robot occupato, job ignorato')
            return

        try:
            job = json.loads(msg.data)
            self.get_logger().info(
                f"Job ricevuto: zona={job['zone_id']}, "
                f"tray={job['tray_id']}, "
                f"crop={job['crop_type']}"
            )
            self.current_job = job
            self.is_busy = True
            # Avvia sequenza raccolta in thread separato
            self.executor.create_task(self.execute_harvest(job))
        except (json.JSONDecodeError, KeyError) as e:
            self.get_logger().error(f"Job malformato: {e}")

    async def execute_harvest(self, job: dict) -> bool:
        """
        Sequenza completa raccolta:
        1. Naviga verso zona target
        2. Verifica maturita con visione artificiale
        3. Preleva vassoio con braccio robotico
        4. Trasporta a conveyor di uscita
        5. Aggiorna SCADA
        """
        try:
            # Step 1: Navigazione
            self.publish_status("NAVIGATING", job)
            success = await self.navigate_to_zone(job['zone_id'], job['shelf_row'])
            if not success:
                self.publish_status("NAV_FAILED", job)
                return False

            # Step 2: Verifica maturita (computer vision)
            maturity_score = await self.check_crop_maturity(job['tray_id'])
            if maturity_score < 0.85:
                self.get_logger().warn(
                    f"Vassoio {job['tray_id']}: maturita {maturity_score:.2f} "
                    f"sotto soglia 0.85, raccolta posticipata"
                )
                self.publish_status("MATURITY_INSUFFICIENT", job)
                self.is_busy = False
                return False

            # Step 3: Raccolta
            self.publish_status("HARVESTING", job)
            await self.pick_tray(job['tray_id'], job['shelf_position'])

            # Step 4: Deposito su conveyor
            self.publish_status("DELIVERING", job)
            await self.deliver_to_conveyor(job['destination_line'])

            # Step 5: Completamento
            self.publish_status("COMPLETED", job)
            self.is_busy = False
            return True

        except Exception as e:
            self.get_logger().error(f"Errore harvest job {job.get('tray_id')}: {e}")
            self.publish_status("ERROR", job)
            self.is_busy = False
            return False

    def publish_status(self, status: str, job: dict):
        msg = String()
        msg.data = json.dumps({
            "robot_id": self.get_name(),
            "status": status,
            "tray_id": job.get("tray_id"),
            "zone_id": job.get("zone_id"),
            "timestamp": self.get_clock().now().to_msg().sec
        })
        self.status_pub.publish(msg)

    async def navigate_to_zone(self, zone_id: str, shelf_row: int) -> bool:
        """Naviga AGV verso la zona target (stub - usa Nav2 in produzione)"""
        self.get_logger().info(f"Navigazione verso zona {zone_id} fila {shelf_row}")
        await asyncio.sleep(2.0)  # simulazione movimento
        return True

    async def check_crop_maturity(self, tray_id: str) -> float:
        """Analisi visione artificiale per valutazione maturita (stub)"""
        # In produzione: inferenza YOLO/custom model su immagine camera
        await asyncio.sleep(0.5)
        return 0.92  # score maturita 0-1

    async def pick_tray(self, tray_id: str, position: dict) -> bool:
        """Controllo braccio robotico per prelievo vassoio via MoveIt2 (stub)"""
        await asyncio.sleep(1.5)
        return True

    async def deliver_to_conveyor(self, destination_line: str) -> bool:
        """Deposita vassoio su conveyor di uscita (stub)"""
        await asyncio.sleep(1.0)
        return True

    def on_camera_frame(self, msg: Image):
        """Callback per frame camera (elaborato async su richiesta)"""
        pass


def main(args=None):
    rclpy.init(args=args)
    node = HarvestingRobotNode()
    try:
        rclpy.spin(node)
    except KeyboardInterrupt:
        pass
    finally:
        node.destroy_node()
        rclpy.shutdown()

if __name__ == '__main__':
    main()

"""
FastAPI Backend per Gestione Vertical Farm
Endpoints: ricette colturali, zone, batch produzione, attuatori, sensori
"""
from fastapi import FastAPI, HTTPException, Depends, BackgroundTasks, status
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
from pydantic import BaseModel, Field, validator
from typing import Optional, List
from datetime import datetime, date
from enum import Enum
import uuid

app = FastAPI(
    title="Vertical Farm Control API",
    description="API per gestione vertical farm: ricette, zone, robot, sensori",
    version="2.1.0"
)

security = HTTPBearer()


# ============================================================
# MODELLI PYDANTIC
# ============================================================

class CropTypeEnum(str, Enum):
    LETTUCE = "lettuce"
    BASIL = "basil"
    SPINACH = "spinach"
    STRAWBERRY = "strawberry"
    MICROGREENS = "microgreens"
    HERBS = "herbs"


class GrowingSystemEnum(str, Enum):
    NFT = "nft"
    DWC = "dwc"
    AEROPONICS = "aeroponics"
    SUBSTRATE = "substrate"


class LightRecipeCreate(BaseModel):
    name: str = Field(..., min_length=3, max_length=100)
    crop_type: CropTypeEnum
    growth_stage: str
    ppfd_target: float = Field(..., ge=50, le=800)
    dli_target: float = Field(..., ge=5, le=40)
    photoperiod_hours: float = Field(..., ge=8, le=24)
    spectrum_red_pct: float = Field(..., ge=0, le=100)
    spectrum_blue_pct: float = Field(..., ge=0, le=100)
    spectrum_white_pct: float = Field(..., ge=0, le=100)
    spectrum_farred_pct: float = Field(default=0.0, ge=0, le=20)
    spectrum_uv_pct: float = Field(default=0.0, ge=0, le=10)
    notes: Optional[str] = None

    @validator('spectrum_blue_pct')
    def validate_spectrum_sum(cls, v, values):
        total = (values.get('spectrum_red_pct', 0) + v +
                 values.get('spectrum_white_pct', 0))
        # Tolleranza +/- 5% per arrotondamenti
        if total > 105:
            raise ValueError(f"Somma canali spettro {total}% supera 100%")
        return v


class BatchCreate(BaseModel):
    zone_id: str
    recipe_id: str
    crop_type: CropTypeEnum
    growing_system: GrowingSystemEnum
    seeding_date: date
    expected_harvest_date: date
    tray_count: int = Field(..., ge=1, le=10000)
    seeds_per_tray: int = Field(default=50, ge=1, le=500)
    client_order_id: Optional[str] = None

    @validator('expected_harvest_date')
    def harvest_after_seeding(cls, v, values):
        seeding = values.get('seeding_date')
        if seeding and v <= seeding:
            raise ValueError("La data di raccolta deve essere successiva alla semina")
        return v


class SensorReading(BaseModel):
    zone_id: str
    timestamp: datetime
    temperature_c: float
    humidity_rh: float
    co2_ppm: float
    ppfd_umol: Optional[float] = None
    ec_ms_cm: Optional[float] = None
    ph: Optional[float] = None
    water_temp_c: Optional[float] = None


class ActuatorCommand(BaseModel):
    zone_id: str
    command_type: str  # "led_update", "co2_valve", "pump_speed", "hvac"
    parameters: dict
    priority: int = Field(default=5, ge=1, le=10)  # 10 = emergenza


# ============================================================
# ROUTES: RICETTE COLTURALI
# ============================================================

@app.post("/api/v1/recipes", status_code=status.HTTP_201_CREATED)
async def create_recipe(
    recipe: LightRecipeCreate,
    credentials: HTTPAuthorizationCredentials = Depends(security)
):
    """
    Crea una nuova ricetta colturale nel sistema.
    Le ricette definiscono parametri luminosi, ambientali e irrigazione.
    """
    recipe_id = str(uuid.uuid4())
    # In produzione: salvataggio su PostgreSQL
    return {
        "recipe_id": recipe_id,
        "name": recipe.name,
        "crop_type": recipe.crop_type,
        "ppfd_target": recipe.ppfd_target,
        "dli_target": recipe.dli_target,
        "created_at": datetime.utcnow().isoformat(),
        "status": "active"
    }


@app.get("/api/v1/recipes/{recipe_id}")
async def get_recipe(recipe_id: str):
    """Recupera ricetta colturale per ID"""
    # Stub - in produzione: query PostgreSQL
    return {
        "recipe_id": recipe_id,
        "name": "Lattuga Lollo Rossa - Vegetativo",
        "crop_type": "lettuce",
        "ppfd_target": 200.0,
        "dli_target": 17.0,
        "photoperiod_hours": 16.0,
        "spectrum": {"red": 65, "blue": 20, "white": 10, "farred": 5},
        "env_targets": {"temp_c": 21.0, "humidity_rh": 70.0, "co2_ppm": 1200},
        "nutrient_targets": {"ec_ms_cm": 1.6, "ph": 6.0}
    }


@app.get("/api/v1/recipes")
async def list_recipes(
    crop_type: Optional[CropTypeEnum] = None,
    active_only: bool = True,
    limit: int = Field(default=50, le=200)
):
    """Lista ricette con filtro per tipo coltura"""
    return {
        "recipes": [],
        "total": 0,
        "filters": {"crop_type": crop_type, "active_only": active_only}
    }


# ============================================================
# ROUTES: BATCH PRODUZIONE
# ============================================================

@app.post("/api/v1/batches", status_code=status.HTTP_201_CREATED)
async def create_batch(
    batch: BatchCreate,
    background_tasks: BackgroundTasks,
    credentials: HTTPAuthorizationCredentials = Depends(security)
):
    """
    Avvia un nuovo batch di produzione.
    Associa zona, ricetta, dati di seeding e target harvest.
    Background: programma scheduling LED e irrigazione su SCADA.
    """
    batch_id = str(uuid.uuid4())
    background_tasks.add_task(schedule_batch_on_scada, batch_id, batch)
    return {
        "batch_id": batch_id,
        "zone_id": batch.zone_id,
        "crop_type": batch.crop_type,
        "seeding_date": batch.seeding_date.isoformat(),
        "expected_harvest_date": batch.expected_harvest_date.isoformat(),
        "tray_count": batch.tray_count,
        "status": "scheduled"
    }


async def schedule_batch_on_scada(batch_id: str, batch: BatchCreate):
    """Task background: invia configurazione a SCADA per scheduling"""
    # In produzione: chiamata API verso SCADA (Ignition, custom Python SCADA)
    pass


# ============================================================
# ROUTES: SENSORI E TELEMETRIA
# ============================================================

@app.post("/api/v1/telemetry")
async def ingest_sensor_data(reading: SensorReading):
    """
    Endpoint per ingestion dati sensori da edge controller.
    Validazione, allarmi e storicizzazione su InfluxDB/TimescaleDB.
    """
    alerts = []

    # Allarmi temperatura
    if reading.temperature_c > 28.0:
        alerts.append({"type": "HIGH_TEMP", "value": reading.temperature_c, "threshold": 28.0})
    elif reading.temperature_c < 16.0:
        alerts.append({"type": "LOW_TEMP", "value": reading.temperature_c, "threshold": 16.0})

    # Allarmi CO2
    if reading.co2_ppm > 2000:
        alerts.append({"type": "HIGH_CO2", "value": reading.co2_ppm, "threshold": 2000})

    # Allarmi pH
    if reading.ph is not None and (reading.ph < 5.0 or reading.ph > 7.5):
        alerts.append({"type": "PH_OUT_OF_RANGE", "value": reading.ph})

    # In produzione: write batch su InfluxDB e publish alert su Kafka/MQTT
    return {
        "status": "accepted",
        "zone_id": reading.zone_id,
        "timestamp": reading.timestamp.isoformat(),
        "alerts": alerts,
        "alert_count": len(alerts)
    }


@app.get("/api/v1/zones/{zone_id}/current")
async def get_zone_current_state(zone_id: str):
    """Stato ambientale corrente di una zona (last value da InfluxDB)"""
    # Stub
    return {
        "zone_id": zone_id,
        "timestamp": datetime.utcnow().isoformat(),
        "sensors": {
            "temperature_c": 21.3,
            "humidity_rh": 69.8,
            "co2_ppm": 1185,
            "ppfd_umol": 198.5,
            "ec_ms_cm": 1.62,
            "ph": 6.05
        },
        "actuators": {
            "led_pwm": {"red": 0.617, "blue": 0.192, "white": 0.098, "farred": 0.049},
            "co2_valve_pct": 12.5,
            "hvac_cooling_pct": 35.0,
            "pump_active": True
        },
        "active_batch_id": "b-2025-001-lollo",
        "days_since_seeding": 18
    }


# ============================================================
# ROUTES: CONTROLLO ATTUATORI
# ============================================================

@app.post("/api/v1/actuators/command")
async def send_actuator_command(
    command: ActuatorCommand,
    credentials: HTTPAuthorizationCredentials = Depends(security)
):
    """
    Invia comando manuale a un attuatore di zona.
    Usato per override manuali, manutenzione e test.
    Richiede autenticazione e viene loggato per audit.
    """
    allowed_commands = {"led_update", "co2_valve", "pump_speed", "hvac", "emergency_stop"}
    if command.command_type not in allowed_commands:
        raise HTTPException(
            status_code=400,
            detail=f"Tipo comando non valido: {command.command_type}"
        )

    command_id = str(uuid.uuid4())
    # In produzione: publish su MQTT/OPC-UA verso edge controller
    return {
        "command_id": command_id,
        "zone_id": command.zone_id,
        "command_type": command.command_type,
        "parameters": command.parameters,
        "status": "sent",
        "sent_at": datetime.utcnow().isoformat()
    }

"""
Digital Twin - Modello di Crescita Vegetale per Vertical Farm
Basato su Radiation Use Efficiency (RUE) + effetti temperatura/CO2
"""
import numpy as np
from dataclasses import dataclass, field
from typing import List, Optional
from datetime import datetime, timedelta


@dataclass
class PlantGrowthModel:
    """
    Modello semplificato di crescita per lattuga in sistema idroponico.
    Parametri calibrati su dati sperimentali per Lactuca sativa.
    """
    # Parametri biologici della coltura
    rue_base: float = 1.8           # g biomassa / MJ PAR intercettato
    temp_base: float = 5.0          # temperatura base (°C) - sotto non cresce
    temp_opt: float = 22.0          # temperatura ottimale
    temp_max: float = 32.0          # temperatura max sopravvivenza
    co2_base_ppm: float = 400.0     # CO2 ambient reference
    co2_enhancement: float = 0.002  # incremento RUE per ppm CO2 extra

    # Stato corrente della pianta
    fresh_weight_g: float = 0.5     # peso fresco iniziale (semenzale 5g DW)
    dry_weight_g: float = 0.05      # peso secco iniziale
    leaf_area_cm2: float = 5.0      # area fogliare iniziale
    days_since_seeding: int = 0

    # Target harvest
    target_fresh_weight_g: float = 150.0  # lattuga da 150g
    water_content: float = 0.95     # % acqua rispetto al peso fresco

    def temperature_factor(self, temp: float) -> float:
        """
        Fattore temperatura (0-1) usando funzione beta.
        temp_opt da il massimo rendimento (1.0).
        """
        if temp <= self.temp_base or temp >= self.temp_max:
            return 0.0
        if temp <= self.temp_opt:
            return (temp - self.temp_base) / (self.temp_opt - self.temp_base)
        else:
            return (self.temp_max - temp) / (self.temp_max - self.temp_opt)

    def co2_factor(self, co2_ppm: float) -> float:
        """Fattore arricchimento CO2 (1.0 ad ambient, >1 con arricchimento)"""
        extra_co2 = max(0, co2_ppm - self.co2_base_ppm)
        return 1.0 + (self.co2_enhancement * extra_co2)

    def par_intercepted_mj(self, ppfd: float, leaf_area_cm2: float,
                            photoperiod_h: float) -> float:
        """
        Calcola PAR intercettata dalla pianta in MJ/giorno.
        ppfd: µmol/m²/s -> conversione a W/m² (1 W/m² ≈ 4.6 µmol/m²/s per LED)
        """
        ppfd_wm2 = ppfd / 4.6
        par_w = ppfd_wm2 * (leaf_area_cm2 / 10000)  # in m²
        par_mj_day = par_w * photoperiod_h * 3600 / 1e6
        return par_mj_day

    def simulate_day(self, temp: float, co2_ppm: float,
                     ppfd: float, photoperiod_h: float) -> dict:
        """
        Simula un giorno di crescita e aggiorna lo stato della pianta.
        Restituisce delta giornaliero e stato aggiornato.
        """
        # Fattori ambientali
        tf = self.temperature_factor(temp)
        cf = self.co2_factor(co2_ppm)
        par_intercepted = self.par_intercepted_mj(ppfd, self.leaf_area_cm2, photoperiod_h)

        # Crescita biomassa secca (RUE model)
        delta_dw = self.rue_base * par_intercepted * tf * cf
        delta_fw = delta_dw / (1 - self.water_content)

        self.dry_weight_g += delta_dw
        self.fresh_weight_g += delta_fw

        # Aggiornamento area fogliare (SLA - specific leaf area)
        sla_cm2_per_g = 350  # cm²/g DW per lattuga
        self.leaf_area_cm2 = self.dry_weight_g * sla_cm2_per_g
        self.days_since_seeding += 1

        # Check harvest readiness
        harvest_ready = self.fresh_weight_g >= self.target_fresh_weight_g

        return {
            "day": self.days_since_seeding,
            "fresh_weight_g": round(self.fresh_weight_g, 2),
            "dry_weight_g": round(self.dry_weight_g, 3),
            "leaf_area_cm2": round(self.leaf_area_cm2, 1),
            "delta_fw_g": round(delta_fw, 3),
            "temp_factor": round(tf, 3),
            "co2_factor": round(cf, 3),
            "par_intercepted_mj": round(par_intercepted, 6),
            "harvest_ready": harvest_ready,
        }

    def simulate_full_cycle(self, daily_conditions: List[dict]) -> dict:
        """
        Simula l'intero ciclo colturale con condizioni giornaliere variabili.
        Restituisce proiezione completa e giorno stimato di raccolta.
        """
        days_log = []
        harvest_day = None

        for day_idx, cond in enumerate(daily_conditions):
            day_state = self.simulate_day(
                temp=cond.get('temp', 21.0),
                co2_ppm=cond.get('co2_ppm', 1200),
                ppfd=cond.get('ppfd', 200),
                photoperiod_h=cond.get('photoperiod_h', 16)
            )
            days_log.append(day_state)

            if day_state['harvest_ready'] and harvest_day is None:
                harvest_day = day_idx + 1

        return {
            "days_simulated": len(days_log),
            "final_fresh_weight_g": self.fresh_weight_g,
            "estimated_harvest_day": harvest_day,
            "daily_log": days_log,
            "achieved_target": self.fresh_weight_g >= self.target_fresh_weight_g
        }


# Esempio utilizzo digital twin
def predict_harvest_date(recipe: dict, seeding_date: datetime) -> datetime:
    """
    Usa il digital twin per predire la data di raccolta
    dato una ricetta ambientale costante.
    """
    model = PlantGrowthModel()

    # Condizioni giornaliere dalla ricetta (costanti per semplicità)
    daily_conditions = [{
        'temp': recipe.get('temp_c', 21.0),
        'co2_ppm': recipe.get('co2_ppm', 1200),
        'ppfd': recipe.get('ppfd_target', 200),
        'photoperiod_h': recipe.get('photoperiod_hours', 16)
    }] * 40  # massimo 40 giorni di simulazione

    result = model.simulate_full_cycle(daily_conditions)
    harvest_day = result.get('estimated_harvest_day', 35)
    return seeding_date + timedelta(days=harvest_day)

"""
Reinforcement Learning per Ottimizzazione Ricette Luminose
Usa Gymnasium + custom environment basato sul PlantGrowthModel
"""
import gymnasium as gym
import numpy as np
from gymnasium import spaces
from typing import Tuple, Optional


class VerticalFarmEnv(gym.Env):
    """
    Ambiente Gymnasium per ottimizzazione ricette luminose.

    Observation space: stato ambientale corrente + stato pianta
    Action space: aggiustamenti parametri LED (continuo)
    Reward: crescita giornaliera / consumo energetico
    """
    metadata = {'render_modes': ['human']}

    def __init__(self, crop_type: str = "lettuce", episode_days: int = 30):
        super().__init__()
        self.crop_type = crop_type
        self.episode_days = episode_days
        self.current_day = 0

        # Action space: [delta_ppfd, delta_red_ratio, delta_blue_ratio, delta_photoperiod]
        # Valori normalizzati in [-1, 1], scalati internamente
        self.action_space = spaces.Box(
            low=np.array([-1.0, -1.0, -1.0, -1.0], dtype=np.float32),
            high=np.array([1.0, 1.0, 1.0, 1.0], dtype=np.float32)
        )

        # Observation space: [ppfd, red_ratio, blue_ratio, photoperiod,
        #                      fresh_weight, leaf_area, days, temp, co2]
        self.observation_space = spaces.Box(
            low=np.array([50, 0, 0, 8, 0, 0, 0, 15, 400], dtype=np.float32),
            high=np.array([800, 1, 1, 24, 500, 5000, 45, 30, 2000], dtype=np.float32)
        )

        # Stato corrente
        self.ppfd = 200.0
        self.red_ratio = 0.65
        self.blue_ratio = 0.20
        self.photoperiod = 16.0
        self.plant_model = None

    def reset(self, seed: Optional[int] = None, **kwargs) -> Tuple[np.ndarray, dict]:
        super().reset(seed=seed)
        self.current_day = 0
        self.ppfd = 200.0
        self.red_ratio = 0.65
        self.blue_ratio = 0.20
        self.photoperiod = 16.0
        from digital_twin import PlantGrowthModel  # import locale
        self.plant_model = PlantGrowthModel()
        return self._get_obs(), {}

    def step(self, action: np.ndarray) -> Tuple[np.ndarray, float, bool, bool, dict]:
        # Applica azione con scaling
        self.ppfd = np.clip(self.ppfd + action[0] * 50, 50, 800)
        self.red_ratio = np.clip(self.red_ratio + action[1] * 0.1, 0.3, 0.8)
        self.blue_ratio = np.clip(self.blue_ratio + action[2] * 0.05, 0.1, 0.35)
        self.photoperiod = np.clip(self.photoperiod + action[3] * 1.0, 10, 22)

        # Simula giorno con nuove condizioni
        day_result = self.plant_model.simulate_day(
            temp=21.0, co2_ppm=1200,
            ppfd=self.ppfd, photoperiod_h=self.photoperiod
        )

        # Calcola consumo energetico (kWh/giorno per m² crescita)
        energy_kwh = (self.ppfd / 4.6) * (self.photoperiod / 1000)  # semplificato

        # Reward: crescita / energia (massimizza efficienza)
        growth = day_result['delta_fw_g']
        reward = growth / max(energy_kwh, 0.001) * 0.01

        # Penalita per harvest_ready raggiunto troppo tardi
        if self.current_day > 35 and not day_result['harvest_ready']:
            reward -= 5.0

        # Bonus per harvest_ready raggiunto nei tempi
        if day_result['harvest_ready'] and self.current_day <= 28:
            reward += 20.0

        self.current_day += 1
        done = day_result['harvest_ready'] or self.current_day >= self.episode_days

        return self._get_obs(), reward, done, False, day_result

    def _get_obs(self) -> np.ndarray:
        pm = self.plant_model
        return np.array([
            self.ppfd, self.red_ratio, self.blue_ratio, self.photoperiod,
            pm.fresh_weight_g if pm else 0.5,
            pm.leaf_area_cm2 if pm else 5.0,
            self.current_day, 21.0, 1200.0
        ], dtype=np.float32)

# Training con Stable-Baselines3
# from stable_baselines3 import PPO
# env = VerticalFarmEnv(crop_type="lettuce")
# model = PPO("MlpPolicy", env, verbose=1, learning_rate=3e-4)
# model.learn(total_timesteps=500_000)
# model.save("optimized_lettuce_recipe_v1")

"""
Bridge Modbus -> MQTT per vertical farm
Legge sensori via Modbus RTU e pubblica su MQTT broker
"""
import asyncio
import json
import time
import logging
from pymodbus.client import AsyncModbusSerialClient
import paho.mqtt.client as mqtt

logger = logging.getLogger(__name__)

# Mappa registri Modbus per sensore combo Temp/RH/CO2 (esempio Vaisala HMP60)
MODBUS_REGISTER_MAP = {
    "temperature": {"address": 0x0000, "count": 1, "scale": 0.1, "unit": "°C"},
    "humidity":    {"address": 0x0001, "count": 1, "scale": 0.1, "unit": "%RH"},
    "co2_ppm":     {"address": 0x0002, "count": 1, "scale": 1.0,  "unit": "ppm"},
    "ec_ms_cm":    {"address": 0x0010, "count": 1, "scale": 0.01, "unit": "mS/cm"},
    "ph":          {"address": 0x0011, "count": 1, "scale": 0.01, "unit": "pH"},
}


class ModbusMQTTBridge:
    def __init__(self, zone_id: str, modbus_port: str,
                 modbus_address: int, mqtt_broker: str, mqtt_port: int = 1883):
        self.zone_id = zone_id
        self.modbus_client = AsyncModbusSerialClient(
            port=modbus_port, baudrate=9600, timeout=3
        )
        self.mqtt_client = mqtt.Client(client_id=f"bridge-{zone_id}")
        self.mqtt_broker = mqtt_broker
        self.mqtt_port = mqtt_port
        self.mqtt_topic = f"farm/zones/{zone_id}/telemetry"

    async def connect(self):
        await self.modbus_client.connect()
        self.mqtt_client.connect(self.mqtt_broker, self.mqtt_port, keepalive=60)
        self.mqtt_client.loop_start()
        logger.info(f"Bridge avviato per zona {self.zone_id}")

    async def read_all_sensors(self, device_id: int = 1) -> dict:
        readings = {"zone_id": self.zone_id, "timestamp": time.time()}
        for sensor_name, reg in MODBUS_REGISTER_MAP.items():
            try:
                result = await self.modbus_client.read_holding_registers(
                    address=reg["address"],
                    count=reg["count"],
                    slave=device_id
                )
                if not result.isError():
                    raw_value = result.registers[0]
                    readings[sensor_name] = round(raw_value * reg["scale"], 3)
                else:
                    logger.warning(f"Errore lettura {sensor_name} zona {self.zone_id}")
                    readings[sensor_name] = None
            except Exception as e:
                logger.error(f"Eccezione Modbus {sensor_name}: {e}")
                readings[sensor_name] = None
        return readings

    async def publish_loop(self, interval_sec: float = 30.0):
        while True:
            readings = await self.read_all_sensors()
            payload = json.dumps(readings)
            result = self.mqtt_client.publish(
                topic=self.mqtt_topic,
                payload=payload,
                qos=1
            )
            if result.rc == mqtt.MQTT_ERR_SUCCESS:
                logger.debug(f"Pubblicato su {self.mqtt_topic}: {payload[:80]}...")
            else:
                logger.error(f"Errore publish MQTT: rc={result.rc}")
            await asyncio.sleep(interval_sec)

# docker-compose.yml per stack vertical farm (dev/staging)
version: '3.9'

services:

  # API principale
  farm-api:
    build: ./farm-api
    ports:
      - "8000:8000"
    environment:
      - DATABASE_URL=postgresql://farm:farm@postgres:5432/farmdb
      - MQTT_BROKER=emqx
      - INFLUXDB_URL=http://influxdb:8086
      - REDIS_URL=redis://redis:6379
    depends_on:
      - postgres
      - influxdb
      - emqx
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  # MQTT Broker
  emqx:
    image: emqx/emqx:5.8
    ports:
      - "1883:1883"   # MQTT
      - "8883:8883"   # MQTT TLS
      - "18083:18083" # Dashboard
    environment:
      - EMQX_NODE__COOKIE=farm-secret-cookie
    volumes:
      - emqx_data:/opt/emqx/data

  # Time-series database per dati sensori
  influxdb:
    image: influxdb:2.7
    ports:
      - "8086:8086"
    environment:
      - DOCKER_INFLUXDB_INIT_MODE=setup
      - DOCKER_INFLUXDB_INIT_USERNAME=admin
      - DOCKER_INFLUXDB_INIT_PASSWORD=farmpass123
      - DOCKER_INFLUXDB_INIT_ORG=verticalfarm
      - DOCKER_INFLUXDB_INIT_BUCKET=sensors
    volumes:
      - influxdb_data:/var/lib/influxdb2

  # PostgreSQL per dati applicativi (ricette, batch, inventory)
  postgres:
    image: postgres:16-alpine
    environment:
      - POSTGRES_DB=farmdb
      - POSTGRES_USER=farm
      - POSTGRES_PASSWORD=farm
    volumes:
      - postgres_data:/var/lib/postgresql/data

  # Redis per cache e job queue
  redis:
    image: redis:7-alpine
    command: redis-server --appendonly yes

  # Grafana per dashboard real-time
  grafana:
    image: grafana/grafana:11.0.0
    ports:
      - "3000:3000"
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin
    volumes:
      - grafana_data:/var/lib/grafana
    depends_on:
      - influxdb

  # Worker ML per digital twin e ottimizzazione
  ml-worker:
    build: ./ml-worker
    environment:
      - INFLUXDB_URL=http://influxdb:8086
      - REDIS_URL=redis://redis:6379
      - MODEL_PATH=/models
    volumes:
      - ml_models:/models

volumes:
  emqx_data:
  influxdb_data:
  postgres_data:
  grafana_data:
  ml_models: