Sistema di Tracciabilità Alimentare: Blockchain, RFID e IoT

# Struttura SGTIN-96 (96 bit)
# {Header}.{Filter}.{Partition}.{CompanyPrefix}.{ItemReference}.{SerialNumber}

# Esempio SGTIN per Parmigiano Reggiano DOP
# EPC URN format:
urn:epc:id:sgtin:8012345.067890.123456789

# Decodifica:
# 8012345    = GS1 Company Prefix (assegnato a caseificio specifico)
# 067890     = Item Reference (codice prodotto specifico - forma DOP 24 mesi)
# 123456789  = Serial Number (numero forma univoco)

# Conversione a GTIN-14:
# 0 8012345 067890 [check digit]
# GTIN-14: 08012345067890X

# Python: lettura e parsing SGTIN
import re
from dataclasses import dataclass

@dataclass
class SGTIN:
    company_prefix: str
    item_reference: str
    serial_number: str
    gtin: str = ""

    def to_urn(self) -> str:
        return f"urn:epc:id:sgtin:{self.company_prefix}.{self.item_reference}.{self.serial_number}"

    def to_gtin14(self) -> str:
        """Calcola GTIN-14 da company prefix + item reference"""
        raw = self.company_prefix + self.item_reference
        # Calcola check digit GS1 (Luhn-like algorithm)
        total = 0
        for i, digit in enumerate(reversed(raw)):
            n = int(digit)
            if i % 2 == 0:
                n *= 3
            total += n
        check = (10 - (total % 10)) % 10
        return f"0{raw}{check}"


def parse_epc_urn(urn: str) -> SGTIN:
    """Parsa un EPC URN SGTIN e restituisce oggetto strutturato"""
    pattern = r"urn:epc:id:sgtin:(\d+)\.(\d+)\.(\d+)"
    match = re.match(pattern, urn)
    if not match:
        raise ValueError(f"URN non valido: {urn}")

    sgtin = SGTIN(
        company_prefix=match.group(1),
        item_reference=match.group(2),
        serial_number=match.group(3)
    )
    sgtin.gtin = sgtin.to_gtin14()
    return sgtin


# Utilizzo
epc = parse_epc_urn("urn:epc:id:sgtin:8012345.067890.123456789")
print(f"Company: {epc.company_prefix}")   # 8012345
print(f"GTIN-14: {epc.gtin}")             # 080123450678906
print(f"URN: {epc.to_urn()}")

import asyncio
import json
from datetime import datetime, timezone
from dataclasses import dataclass, field, asdict
from typing import Optional
import httpx

@dataclass
class RFIDEvent:
    """Evento RFID catturato da lettore industriale"""
    epc: str                      # Electronic Product Code
    antenna_id: int               # ID antenna che ha letto il tag
    rssi: float                   # Signal strength in dBm
    timestamp: str                # ISO 8601 UTC
    reader_id: str                # ID lettore (es. "DOCK-01")
    location: str                 # Posizione fisica (es. "INGRESSO-MAGAZZINO")
    direction: Optional[str] = None  # "IN" | "OUT" | None

    @classmethod
    def from_reader_data(cls, raw: dict, reader_id: str, location: str) -> "RFIDEvent":
        return cls(
            epc=raw["epc"],
            antenna_id=raw.get("antenna", 1),
            rssi=raw.get("rssi", -70.0),
            timestamp=datetime.now(timezone.utc).isoformat(),
            reader_id=reader_id,
            location=location
        )


class RFIDEventProcessor:
    """
    Processore eventi RFID con deduplicazione e buffer
    Gestisce reader industriali via REST API (compatibile Zebra, Impinj)
    """

    def __init__(self, reader_url: str, reader_id: str, location: str):
        self.reader_url = reader_url
        self.reader_id = reader_id
        self.location = location
        self._seen_epcs: dict[str, float] = {}     # EPC -> timestamp last seen
        self.dedup_window_seconds = 2.0           # Anti-bounce window

    def _is_duplicate(self, epc: str, now: float) -> bool:
        """Filtra letture duplicate nel finestra temporale"""
        last_seen = self._seen_epcs.get(epc)
        if last_seen and (now - last_seen) < self.dedup_window_seconds:
            return True
        self._seen_epcs[epc] = now
        return False

    async def poll_reader(self) -> list[RFIDEvent]:
        """Interroga il lettore RFID e restituisce eventi unici"""
        async with httpx.AsyncClient(timeout=5.0) as client:
            resp = await client.get(f"{self.reader_url}/api/v1/tags")
            resp.raise_for_status()
            tags_raw = resp.json().get("tags", [])

        now = datetime.now(timezone.utc).timestamp()
        events = []
        for raw in tags_raw:
            epc = raw.get("epc", "")
            if not epc or self._is_duplicate(epc, now):
                continue
            event = RFIDEvent.from_reader_data(raw, self.reader_id, self.location)
            events.append(event)

        return events

    async def stream_events(self, callback, poll_interval: float = 0.5):
        """Stream continuo di eventi RFID con callback"""
        print(f"Avvio polling RFID reader {self.reader_id} @ {self.reader_url}")
        while True:
            try:
                events = await self.poll_reader()
                for event in events:
                    await callback(event)
            except Exception as e:
                print(f"Errore reader {self.reader_id}: {e}")
            await asyncio.sleep(poll_interval)


# Utilizzo
async def handle_rfid_event(event: RFIDEvent):
    print(f"Lotto {event.epc} rilevato in {event.location} @ {event.timestamp}")
    # Invia a pipeline tracciabilita
    await send_to_traceability_pipeline(event)

async def send_to_traceability_pipeline(event: RFIDEvent):
    async with httpx.AsyncClient() as client:
        await client.post(
            "http://traceability-api:8000/api/v1/events",
            json=asdict(event)
        )

# GS1 Digital Link URI format
# https://{domain}/{primary-key-qualifier}/{value}/{data-qualifier}/{value}?{params}

# Esempio per Parmigiano Reggiano DOP:
# https://trace.parmigianoreggiano.it/01/08012345678905/10/LOT2025001A/17/261231

# Decodifica:
# /01/ = GTIN (Application Identifier AI 01)
# 08012345678905 = GTIN-14 della forma di Parmigiano
# /10/ = Batch/Lot Number (AI 10)
# LOT2025001A = numero lotto specifico
# /17/ = Expiration Date (AI 17)
# 261231 = 31 dicembre 2026

# Python: generazione GS1 Digital Link QR Code
import qrcode
from urllib.parse import urlencode

def generate_gs1_digital_link(
    gtin: str,          # 14 digits
    lot: str,           # batch number
    expiry: str,        # YYMMDD format
    domain: str,
    serial: str = None
) -> str:
    """
    Genera URI GS1 Digital Link compliant (GS1 General Specifications 24.0)
    """
    # Validazione GTIN-14
    if len(gtin) != 14 or not gtin.isdigit():
        raise ValueError(f"GTIN deve essere 14 cifre, ricevuto: {gtin}")

    # Build URI path
    uri = f"https://{domain}/01/{gtin}/10/{lot}/17/{expiry}"

    if serial:
        uri += f"/21/{serial}"

    return uri


def generate_gs1_qr_code(digital_link_uri: str, output_path: str) -> None:
    """
    Genera QR Code GS1 Digital Link con specifiche standard
    Versione QR: automatica, ECC Level M (minimo GS1)
    """
    qr = qrcode.QRCode(
        version=None,           # auto-size
        error_correction=qrcode.constants.ERROR_CORRECT_M,
        box_size=10,
        border=4,               # quiet zone: min 4 moduli standard GS1
    )
    qr.add_data(digital_link_uri)
    qr.make(fit=True)

    img = qr.make_image(fill_color="black", back_color="white")
    img.save(output_path)
    print(f"QR Code salvato in: {output_path}")


# Esempio utilizzo
gtin_parmigiano = "08012345678905"
lot_number = "PR2025A001"
expiry_date = "261231"   # 31 dicembre 2026

uri = generate_gs1_digital_link(
    gtin=gtin_parmigiano,
    lot=lot_number,
    expiry=expiry_date,
    domain="trace.parmigianoreggiano.it",
    serial="FRM042025001"  # numero forma specifico
)
print(f"Digital Link URI: {uri}")
# Output: https://trace.parmigianoreggiano.it/01/08012345678905/10/PR2025A001/17/261231/21/FRM042025001

generate_gs1_qr_code(uri, "/output/parmigiano_qr.png")

// Chaincode Go per Hyperledger Fabric 2.x
// File: food_trace_chaincode.go

package main

import (
    "encoding/json"
    "fmt"
    "time"

    "github.com/hyperledger/fabric-contract-api-go/contractapi"
)

// FoodLot rappresenta un lotto alimentare on-chain
type FoodLot struct{
    LotID          string    `json:"lot_id"`
    ProductGTIN    string    `json:"product_gtin"`
    ProducerGLN    string    `json:"producer_gln"`
    ProductionDate string    `json:"production_date"`
    ExpiryDate     string    `json:"expiry_date"`
    CertificateIDs []string  `json:"certificate_ids"`
    LotStatus      string    `json:"lot_status"`       // ACTIVE | RECALLED | EXPIRED
    CreatedAt      string    `json:"created_at"`
    UpdatedAt      string    `json:"updated_at"`
}

// TraceEvent rappresenta un evento di tracciamento sulla supply chain
type TraceEvent struct{
    EventID      string    `json:"event_id"`
    LotID        string    `json:"lot_id"`
    EventType    string    `json:"event_type"`    // CREATED | SHIPPED | RECEIVED | TRANSFORMED | SOLD
    ActorGLN     string    `json:"actor_gln"`     // GS1 Global Location Number dell'attore
    Location     string    `json:"location"`
    Timestamp    string    `json:"timestamp"`
    Temperature  *float64  `json:"temperature,omitempty"`
    Humidity     *float64  `json:"humidity,omitempty"`
    Notes        string    `json:"notes,omitempty"`
    DataHash     string    `json:"data_hash"`     // SHA-256 di dati off-chain
}

// FoodTraceContract e il contratto principale
type FoodTraceContract struct{
    contractapi.Contract
}

// RegisterLot registra un nuovo lotto alimentare
func (c *FoodTraceContract) RegisterLot(
    ctx contractapi.TransactionContextInterface,
    lotID, productGTIN, producerGLN, productionDate, expiryDate string,
    certificateIDs []string,
) error {
    // Verifica che il lotto non esista gia
    existing, err := ctx.GetStub().GetState(lotID)
    if err != nil {
        return fmt.Errorf("errore accesso ledger: %v", err)
    }
    if existing != nil {
        return fmt.Errorf("lotto %s già registrato", lotID)
    }

    now := time.Now().UTC().Format(time.RFC3339)
    lot := FoodLot{
        LotID:          lotID,
        ProductGTIN:    productGTIN,
        ProducerGLN:    producerGLN,
        ProductionDate: productionDate,
        ExpiryDate:     expiryDate,
        CertificateIDs: certificateIDs,
        LotStatus:      "ACTIVE",
        CreatedAt:      now,
        UpdatedAt:      now,
    }

    lotJSON, err := json.Marshal(lot)
    if err != nil {
        return err
    }

    return ctx.GetStub().PutState(lotID, lotJSON)
}

// AddTraceEvent aggiunge un evento di tracciamento al lotto
func (c *FoodTraceContract) AddTraceEvent(
    ctx contractapi.TransactionContextInterface,
    eventJSON string,
) error {
    var event TraceEvent
    if err := json.Unmarshal([]byte(eventJSON), &event); err != nil {
        return fmt.Errorf("JSON evento non valido: %v", err)
    }

    // Verifica che il lotto esista e sia attivo
    lotBytes, err := ctx.GetStub().GetState(event.LotID)
    if err != nil || lotBytes == nil {
        return fmt.Errorf("lotto %s non trovato", event.LotID)
    }

    var lot FoodLot
    json.Unmarshal(lotBytes, &lot)
    if lot.LotStatus != "ACTIVE" {
        return fmt.Errorf("lotto non attivo (status: %s)", lot.LotStatus)
    }

    event.Timestamp = time.Now().UTC().Format(time.RFC3339)

    // Chiave composita per eventi: "EVENT" + lotID + eventID
    eventKey, err := ctx.GetStub().CreateCompositeKey("EVENT", []string{event.LotID, event.EventID})
    if err != nil {
        return err
    }

    eventJSON, err := json.Marshal(event)
    if err != nil {
        return err
    }

    return ctx.GetStub().PutState(eventKey, eventJSON)
}

// GetLotHistory restituisce la storia completa di un lotto
func (c *FoodTraceContract) GetLotHistory(
    ctx contractapi.TransactionContextInterface,
    lotID string,
) ([]TraceEvent, error) {
    iterator, err := ctx.GetStub().GetStateByPartialCompositeKey("EVENT", []string{lotID})
    if err != nil {
        return nil, err
    }
    defer iterator.Close()

    var events []TraceEvent
    for iterator.HasNext() {
        result, err := iterator.Next()
        if err != nil {
            continue
        }
        var event TraceEvent
        if err := json.Unmarshal(result.Value, &event); err == nil {
            events = append(events, event)
        }
    }
    return events, nil
}

// RecallLot avvia un recall su un lotto
func (c *FoodTraceContract) RecallLot(
    ctx contractapi.TransactionContextInterface,
    lotID, reason string,
) error {
    lotBytes, err := ctx.GetStub().GetState(lotID)
    if err != nil || lotBytes == nil {
        return fmt.Errorf("lotto %s non trovato", lotID)
    }

    var lot FoodLot
    json.Unmarshal(lotBytes, &lot)
    lot.LotStatus = "RECALLED"
    lot.UpdatedAt = time.Now().UTC().Format(time.RFC3339)

    lotJSON, _ := json.Marshal(lot)
    return ctx.GetStub().PutState(lotID, lotJSON)
}

# food_traceability_api.py
# FastAPI backend per sistema di tracciabilita alimentare
# Integra PostgreSQL (dati) + Hyperledger Fabric (trust layer)

from fastapi import FastAPI, HTTPException, Depends, status
from pydantic import BaseModel, Field, field_validator
from datetime import datetime, timezone, date
from typing import Optional, List
import hashlib
import json
import uuid
import asyncpg

app = FastAPI(
    title="Food Traceability API",
    description="Sistema di tracciabilita alimentare end-to-end",
    version="2.0.0"
)

# ---- Modelli Pydantic ----

class LotRegistration(BaseModel):
    """Schema per registrazione nuovo lotto alimentare"""
    lot_id: str = Field(..., min_length=3, max_length=50, pattern=r"^[A-Z0-9\-]+$")
    product_gtin: str = Field(..., min_length=14, max_length=14)
    producer_gln: str = Field(..., description="GS1 Global Location Number del produttore")
    product_name: str = Field(..., max_length=200)
    production_date: date
    expiry_date: date
    quantity_kg: float = Field(..., gt=0)
    origin_country: str = Field(..., max_length=2)  # ISO 3166-1 alpha-2
    certifications: List[str] = Field(default_factory=list)
    raw_materials: List[dict] = Field(default_factory=list)

    @field_validator("product_gtin")
    @classmethod
    def validate_gtin14(cls, v: str) -> str:
        """Valida GTIN-14 con GS1 check digit algorithm"""
        if not v.isdigit():
            raise ValueError("GTIN deve contenere solo cifre")
        digits = [int(d) for d in v]
        total = sum(
            d * (3 if (len(digits) - 1 - i) % 2 == 0 else 1)
            for i, d in enumerate(digits[:-1])
        )
        expected_check = (10 - (total % 10)) % 10
        if digits[-1] != expected_check:
            raise ValueError(f"Check digit GTIN non valido. Atteso: {expected_check}")
        return v

    @field_validator("expiry_date")
    @classmethod
    def expiry_after_production(cls, v, info):
        if "production_date" in info.data and v <= info.data["production_date"]:
            raise ValueError("Data scadenza deve essere successiva alla data produzione")
        return v


class TraceEventRequest(BaseModel):
    """Schema per aggiunta evento di tracciamento"""
    lot_id: str
    event_type: str = Field(..., pattern=r"^(CREATED|SHIPPED|RECEIVED|TRANSFORMED|STORED|SOLD|RECALLED)$")
    actor_gln: str
    actor_name: str
    location_name: str
    location_gln: Optional[str] = None
    latitude: Optional[float] = None
    longitude: Optional[float] = None
    temperature_celsius: Optional[float] = None
    humidity_percent: Optional[float] = None
    quantity_kg: Optional[float] = None
    notes: Optional[str] = None
    additional_data: dict = Field(default_factory=dict)


class LotGenealogy(BaseModel):
    """Genealogia completa di un lotto"""
    lot_id: str
    product_name: str
    product_gtin: str
    producer_name: str
    production_date: str
    expiry_date: str
    status: str
    certifications: List[str]
    events: List[dict]
    blockchain_tx_hash: Optional[str] = None
    raw_materials: List[dict]


# ---- Endpoints ----

@app.post("/api/v1/lots", status_code=status.HTTP_201_CREATED)
async def register_lot(lot: LotRegistration, db=Depends(get_db)):
    """
    Registra un nuovo lotto alimentare.
    Scrive il record in PostgreSQL e l'hash on-chain su Hyperledger Fabric.
    """
    # Verifica unicita lotto
    existing = await db.fetchrow(
        "SELECT lot_id FROM food_lots WHERE lot_id = $1", lot.lot_id
    )
    if existing:
        raise HTTPException(
            status_code=status.HTTP_409_CONFLICT,
            detail=f"Lotto {lot.lot_id} già registrato"
        )

    # Calcola hash dei dati per ancoraggio blockchain
    lot_data = lot.model_dump(mode="json")
    lot_json_str = json.dumps(lot_data, sort_keys=True, default=str)
    data_hash = hashlib.sha256(lot_json_str.encode()).hexdigest()

    # Persisti su PostgreSQL
    await db.execute("""
        INSERT INTO food_lots (
            lot_id, product_gtin, producer_gln, product_name,
            production_date, expiry_date, quantity_kg, origin_country,
            certifications, raw_materials, lot_status, data_hash, created_at
        ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9::jsonb, $10::jsonb, 'ACTIVE', $11, NOW())
    """,
        lot.lot_id, lot.product_gtin, lot.producer_gln, lot.product_name,
        lot.production_date, lot.expiry_date, lot.quantity_kg, lot.origin_country,
        json.dumps(lot.certifications), json.dumps(lot.raw_materials), data_hash
    )

    # Scrivi hash su blockchain (asincrono)
    tx_hash = await write_to_blockchain(lot.lot_id, data_hash, "REGISTER_LOT")

    return {
        "lot_id": lot.lot_id,
        "status": "registered",
        "data_hash": data_hash,
        "blockchain_tx": tx_hash,
        "message": f"Lotto {lot.lot_id} registrato con successo"
    }


@app.post("/api/v1/lots/{lot_id}/events", status_code=status.HTTP_201_CREATED)
async def add_trace_event(lot_id: str, event: TraceEventRequest, db=Depends(get_db)):
    """Aggiunge un evento di tracciamento a un lotto esistente"""
    # Verifica lotto esiste ed e attivo
    lot = await db.fetchrow(
        "SELECT lot_id, lot_status FROM food_lots WHERE lot_id = $1", lot_id
    )
    if not lot:
        raise HTTPException(status_code=404, detail=f"Lotto {lot_id} non trovato")
    if lot["lot_status"] not in ("ACTIVE", "STORED"):
        raise HTTPException(
            status_code=400,
            detail=f"Lotto in stato {lot['lot_status']}: non accetta nuovi eventi"
        )

    event_id = str(uuid.uuid4())
    timestamp = datetime.now(timezone.utc).isoformat()

    # Hash dati evento per blockchain
    event_data = event.model_dump(mode="json")
    event_data["event_id"] = event_id
    event_data["timestamp"] = timestamp
    event_json = json.dumps(event_data, sort_keys=True, default=str)
    event_hash = hashlib.sha256(event_json.encode()).hexdigest()

    # Persisti evento
    await db.execute("""
        INSERT INTO trace_events (
            event_id, lot_id, event_type, actor_gln, actor_name,
            location_name, location_gln, latitude, longitude,
            temperature_celsius, humidity_percent, quantity_kg,
            notes, additional_data, data_hash, created_at
        ) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14::jsonb,$15,NOW())
    """,
        event_id, lot_id, event.event_type, event.actor_gln, event.actor_name,
        event.location_name, event.location_gln, event.latitude, event.longitude,
        event.temperature_celsius, event.humidity_percent, event.quantity_kg,
        event.notes, json.dumps(event.additional_data), event_hash
    )

    # Aggiorna status lotto
    status_map = {"SHIPPED": "IN_TRANSIT", "RECEIVED": "STORED", "SOLD": "SOLD"}
    if event.event_type in status_map:
        await db.execute(
            "UPDATE food_lots SET lot_status = $1 WHERE lot_id = $2",
            status_map[event.event_type], lot_id
        )

    tx_hash = await write_to_blockchain(lot_id, event_hash, event.event_type)

    return {"event_id": event_id, "blockchain_tx": tx_hash, "status": "recorded"}


@app.get("/api/v1/lots/{lot_id}/genealogy", response_model=LotGenealogy)
async def get_lot_genealogy(lot_id: str, db=Depends(get_db)):
    """Restituisce la genealogia completa di un lotto: dati base + tutti gli eventi"""
    lot = await db.fetchrow("""
        SELECT l.*, p.name as producer_name
        FROM food_lots l
        LEFT JOIN producers p ON l.producer_gln = p.gln
        WHERE l.lot_id = $1
    """, lot_id)

    if not lot:
        raise HTTPException(status_code=404, detail=f"Lotto {lot_id} non trovato")

    events = await db.fetch("""
        SELECT * FROM trace_events
        WHERE lot_id = $1
        ORDER BY created_at ASC
    """, lot_id)

    blockchain_tx = await get_blockchain_anchor(lot_id)

    return LotGenealogy(
        lot_id=lot["lot_id"],
        product_name=lot["product_name"],
        product_gtin=lot["product_gtin"],
        producer_name=lot.get("producer_name", lot["producer_gln"]),
        production_date=str(lot["production_date"]),
        expiry_date=str(lot["expiry_date"]),
        status=lot["lot_status"],
        certifications=json.loads(lot["certifications"] or "[]"),
        events=[dict(e) for e in events],
        blockchain_tx_hash=blockchain_tx,
        raw_materials=json.loads(lot["raw_materials"] or "[]")
    )


async def write_to_blockchain(lot_id: str, data_hash: str, event_type: str) -> str:
    """
    Scrive un hash su Hyperledger Fabric via REST API (Fabric Gateway API)
    In produzione: usa fabric-sdk-py o Fabric Gateway REST proxy
    """
    # Stub: in produzione integra con fabric-gateway
    tx_id = hashlib.sha256(f"{lot_id}{data_hash}{event_type}".encode()).hexdigest()
    return f"0x{tx_id}"


async def get_db():
    """Dependency: connessione PostgreSQL via asyncpg"""
    conn = await asyncpg.connect("postgresql://user:pass@localhost/traceability")
    try:
        yield conn
    finally:
        await conn.close()

# cold_chain_monitor.py
# Monitor IoT per cold chain con BLE scanning e MQTT publishing
# Compatible con Ruuvi Tag v2 (formato RAWv2)

import asyncio
import json
import struct
from datetime import datetime, timezone
from dataclasses import dataclass, asdict
from typing import Optional
import paho.mqtt.client as mqtt

# Configurazione limiti HACCP per categoria prodotto
HACCP_LIMITS = {
    "dairy":       {"min": 0.0, "max": 4.0,  "alert_threshold": 6.0},
    "fresh_meat":  {"min": -2.0, "max": 4.0, "alert_threshold": 5.0},
    "frozen":      {"min": -25.0, "max": -18.0, "alert_threshold": -15.0},
    "fish":        {"min": -1.0, "max": 2.0,  "alert_threshold": 4.0},
    "vegetables":  {"min": 2.0, "max": 8.0,   "alert_threshold": 10.0},
}

@dataclass
class ColdChainReading:
    """Lettura sensore cold chain"""
    sensor_mac: str
    lot_id: str
    timestamp: str
    temperature_c: float
    humidity_pct: float
    battery_pct: int
    latitude: Optional[float] = None
    longitude: Optional[float] = None
    product_category: str = "dairy"
    alert: bool = False
    alert_reason: str = ""

    def check_haccp_compliance(self) -> None:
        """Verifica compliance HACCP e setta flag alert"""
        limits = HACCP_LIMITS.get(self.product_category, HACCP_LIMITS["dairy"])
        if self.temperature_c > limits["alert_threshold"]:
            self.alert = True
            self.alert_reason = (
                f"TEMPERATURA CRITICA: {self.temperature_c:.1f}C "
                f"(limite: {limits['alert_threshold']}C)"
            )
        elif self.temperature_c < limits["min"]:
            self.alert = True
            self.alert_reason = (
                f"TEMPERATURA SOTTO MINIMO: {self.temperature_c:.1f}C "
                f"(minimo: {limits['min']}C)"
            )
        elif self.temperature_c > limits["max"]:
            # Fuori range ma non ancora critico
            self.alert_reason = (
                f"Temperatura fuori range HACCP: {self.temperature_c:.1f}C "
                f"(range: {limits['min']}-{limits['max']}C)"
            )


def parse_ruuvi_rawv2(manufacturer_data: bytes) -> dict:
    """
    Parsa il payload RAWv2 di Ruuvi Tag (formato 0x05)
    Documentazione: https://docs.ruuvi.com/communication/bluetooth-advertisements/data-format-5-rawv2
    """
    if len(manufacturer_data) < 24 or manufacturer_data[0] != 0x05:
        raise ValueError("Formato Ruuvi RAWv2 non valido")

    # Unpack: temperatura (int16, 0.005 C/unit), umidita (uint16, 0.0025 %/unit)
    temp_raw = struct.unpack_from(">h", manufacturer_data, 1)[0]
    hum_raw = struct.unpack_from(">H", manufacturer_data, 3)[0]
    batt_raw = struct.unpack_from(">H", manufacturer_data, 12)[0]

    temperature = temp_raw * 0.005
    humidity = hum_raw * 0.0025
    battery_mv = ((batt_raw >> 5) + 1600)  # mV
    battery_pct = max(0, min(100, int((battery_mv - 2200) / 12)))

    return {
        "temperature_c": round(temperature, 2),
        "humidity_pct": round(humidity, 1),
        "battery_pct": battery_pct,
    }


class ColdChainMQTTPublisher:
    """Pubblica letture cold chain su MQTT broker"""

    def __init__(self, broker_host: str, broker_port: int = 1883):
        self.client = mqtt.Client(client_id="cold-chain-monitor-01")
        self.client.connect(broker_host, broker_port, keepalive=60)
        self.client.loop_start()

    def publish_reading(self, reading: ColdChainReading) -> None:
        topic = f"coldchain/{reading.lot_id}/sensors/{reading.sensor_mac}"
        payload = json.dumps(asdict(reading), default=str)
        self.client.publish(topic, payload, qos=1, retain=False)

        if reading.alert:
            alert_topic = f"coldchain/alerts/{reading.lot_id}"
            self.client.publish(alert_topic, payload, qos=2)
            print(f"ALERT {reading.lot_id}: {reading.alert_reason}")


async def cold_chain_pipeline(publisher: ColdChainMQTTPublisher, lot_id: str):
    """
    Pipeline simulata - in produzione: integra con BLE scanner (bleak library)
    e gateway che forwarda dati da sensori fisici
    """
    import random
    import time

    sensor_mac = "AA:BB:CC:DD:EE:FF"
    product_category = "dairy"

    while True:
        # Simulazione lettura sensore (sostituire con bleak BLE scan)
        simulated_temp = round(random.gauss(3.5, 1.2), 2)  # Media 3.5C, std 1.2
        simulated_hum = round(random.gauss(85.0, 5.0), 1)

        reading = ColdChainReading(
            sensor_mac=sensor_mac,
            lot_id=lot_id,
            timestamp=datetime.now(timezone.utc).isoformat(),
            temperature_c=simulated_temp,
            humidity_pct=simulated_hum,
            battery_pct=85,
            product_category=product_category
        )
        reading.check_haccp_compliance()
        publisher.publish_reading(reading)

        print(f"{reading.timestamp} | Temp: {reading.temperature_c}C | "
              f"Hum: {reading.humidity_pct}% | Alert: {reading.alert}")

        await asyncio.sleep(30)  # Lettura ogni 30 secondi

# Avvio pipeline
# publisher = ColdChainMQTTPublisher("mqtt.traceability.local")
# asyncio.run(cold_chain_pipeline(publisher, "LOT-PR2025-001"))

# Esempio EPCIS 2.0 JSON-LD - Evento di spedizione lotto DOP
# Formato JSON standard GS1 EPCIS 2.0 (May 2025 update)

epcis_shipping_event = {
    "@context": [
        "https://ref.gs1.org/standards/epcis/2.0.0/epcis-context.jsonld",
        {
            "ext": "https://parmigianoreggiano.it/epcis/ext/"
        }
    ],
    "type": "EPCISDocument",
    "schemaVersion": "2.0",
    "creationDate": "2025-10-15T08:30:00.000Z",
    "epcisBody": {
        "eventList": [
            {
                "type": "ObjectEvent",
                "eventTime": "2025-10-15T08:00:00.000Z",
                "eventTimeZoneOffset": "+01:00",
                "action": "OBSERVE",
                "bizStep": "shipping",          # GS1 CBV vocabulary
                "disposition": "in_transit",
                "epcList": [
                    "urn:epc:id:sgtin:8012345.067890.001",
                    "urn:epc:id:sgtin:8012345.067890.002",
                    "urn:epc:id:sgtin:8012345.067890.003"
                ],
                "readPoint": {
                    "id": "urn:epc:id:sgln:8012345.00000.DOCK-01"  # GLN dock uscita
                },
                "bizLocation": {
                    "id": "urn:epc:id:sgln:8012345.00000.WAREHOUSE"
                },
                "bizTransactionList": [
                    {
                        "type": "po",          # Purchase Order
                        "bizTransaction": "urn:epcglobal:cbv:bt:9876543210:PO-2025-1234"
                    },
                    {
                        "type": "desadv",      # Dispatch Advice (DDT)
                        "bizTransaction": "urn:epcglobal:cbv:bt:9876543210:DDT-2025-5678"
                    }
                ],
                "sourceList": [
                    {
                        "type": "owning_party",
                        "source": "urn:epc:id:pgln:8012345.00000"  # Consorzio PR
                    }
                ],
                "destinationList": [
                    {
                        "type": "owning_party",
                        "destination": "urn:epc:id:pgln:4099999.00000"  # Retailer
                    }
                ],
                "sensorElementList": [
                    {
                        "sensorMetadata": {
                            "time": "2025-10-15T08:00:00.000Z",
                            "deviceID": "urn:epc:id:giai:8012345.0.SENSOR-TEMP-01",
                            "deviceMetadata": "https://sensors.parmigianoreggiano.it/models/T1"
                        },
                        "sensorReport": [
                            {
                                "type": "Temperature",
                                "value": 3.8,
                                "uom": "CEL",       # Celsius (UN/CEFACT unit code)
                                "minValue": 3.2,
                                "maxValue": 4.1
                            },
                            {
                                "type": "AbsoluteHumidity",
                                "value": 82.5,
                                "uom": "A93"        # Percent relative humidity
                            }
                        ]
                    }
                ],
                "ext:lotNumber": "PR2025A001",
                "ext:dop_certificate": "DOP-IT-PR-2025-001234"
            }
        ]
    }
}

# Invio a EPCIS 2.0 Repository (es. IBM Food Trust, OPTEL, TraceLink)
import httpx

async def publish_epcis_event(event: dict, epcis_endpoint: str, api_key: str):
    """Pubblica evento EPCIS 2.0 su repository conforme"""
    async with httpx.AsyncClient() as client:
        resp = await client.post(
            f"{epcis_endpoint}/events",
            json=event,
            headers={
                "Content-Type": "application/ld+json",
                "GS1-EPCIS-Version": "2.0",
                "Authorization": f"Bearer {api_key}"
            }
        )
        resp.raise_for_status()
        return resp.json()

-- Schema PostgreSQL per sistema di tracciabilita alimentare
-- Compatibile con EPCIS 2.0 e FSMA 204 CTE/KDE requirements

-- Estensione per UUID e JSONB
CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
CREATE EXTENSION IF NOT EXISTS pgcrypto;

-- Tabella produttori (GS1 GLN)
CREATE TABLE producers (
    gln            VARCHAR(13) PRIMARY KEY,    -- GS1 Global Location Number
    name           VARCHAR(200) NOT NULL,
    country        CHAR(2) NOT NULL,           -- ISO 3166-1 alpha-2
    region         VARCHAR(100),
    certifications JSONB DEFAULT '[]',
    contact_email  VARCHAR(200),
    created_at     TIMESTAMPTZ DEFAULT NOW()
);

-- Tabella lotti alimentari (core entity)
CREATE TABLE food_lots (
    lot_id         VARCHAR(50) PRIMARY KEY,
    product_gtin   CHAR(14) NOT NULL,
    producer_gln   VARCHAR(13) REFERENCES producers(gln),
    product_name   VARCHAR(200) NOT NULL,
    production_date DATE NOT NULL,
    expiry_date     DATE NOT NULL,
    quantity_kg     DECIMAL(12, 3),
    origin_country  CHAR(2),
    certifications  JSONB DEFAULT '[]',
    raw_materials   JSONB DEFAULT '[]',        -- Array di lot_id input + quantità
    lot_status      VARCHAR(20) DEFAULT 'ACTIVE'
                    CHECK (lot_status IN ('ACTIVE','IN_TRANSIT','STORED','SOLD','RECALLED','EXPIRED')),
    data_hash       CHAR(64),                  -- SHA-256 dei dati per ancoraggio blockchain
    blockchain_tx   VARCHAR(66),               -- Hash TX blockchain (0x + 64 hex)
    created_at      TIMESTAMPTZ DEFAULT NOW(),
    updated_at      TIMESTAMPTZ DEFAULT NOW(),

    CONSTRAINT valid_dates CHECK (expiry_date > production_date)
);

-- Indici per query frequenti
CREATE INDEX idx_food_lots_gtin ON food_lots(product_gtin);
CREATE INDEX idx_food_lots_producer ON food_lots(producer_gln);
CREATE INDEX idx_food_lots_status ON food_lots(lot_status);
CREATE INDEX idx_food_lots_production_date ON food_lots(production_date);

-- Tabella eventi di tracciamento (Critical Tracking Events - FSMA 204)
CREATE TABLE trace_events (
    event_id           UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
    lot_id             VARCHAR(50) NOT NULL REFERENCES food_lots(lot_id) ON DELETE RESTRICT,
    event_type         VARCHAR(30) NOT NULL
                       CHECK (event_type IN (
                           'CREATED','SHIPPED','RECEIVED','TRANSFORMED',
                           'STORED','SOLD','RECALLED','SAMPLED','INSPECTED'
                       )),
    -- Key Data Elements (KDE) FSMA 204
    actor_gln          VARCHAR(13),
    actor_name         VARCHAR(200) NOT NULL,
    location_name      VARCHAR(200) NOT NULL,
    location_gln       VARCHAR(13),
    latitude           DECIMAL(9, 6),
    longitude          DECIMAL(9, 6),
    -- Parametri ambientali (cold chain / HACCP)
    temperature_celsius DECIMAL(5, 2),
    humidity_percent    DECIMAL(5, 2),
    quantity_kg         DECIMAL(12, 3),
    -- Documenti associati (DDT, fatture, certificati)
    document_refs       JSONB DEFAULT '[]',
    -- Dati liberi addizionali
    additional_data     JSONB DEFAULT '{}',
    notes               TEXT,
    data_hash           CHAR(64),
    blockchain_tx       VARCHAR(66),
    created_at          TIMESTAMPTZ DEFAULT NOW()
);

CREATE INDEX idx_trace_events_lot_id ON trace_events(lot_id);
CREATE INDEX idx_trace_events_type ON trace_events(event_type);
CREATE INDEX idx_trace_events_created ON trace_events(created_at);
CREATE INDEX idx_trace_events_location ON trace_events(location_gln);

-- Tabella alert HACCP automatici
CREATE TABLE haccp_alerts (
    alert_id       UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
    lot_id         VARCHAR(50) REFERENCES food_lots(lot_id),
    sensor_id      VARCHAR(100),
    alert_type     VARCHAR(50) NOT NULL,  -- TEMP_HIGH, TEMP_LOW, HUMIDITY, etc.
    measured_value DECIMAL(8, 3),
    threshold_value DECIMAL(8, 3),
    alert_message  TEXT,
    resolved       BOOLEAN DEFAULT FALSE,
    resolved_at    TIMESTAMPTZ,
    created_at     TIMESTAMPTZ DEFAULT NOW()
);

-- View per genealogia lotto (query ottimizzata)
CREATE OR REPLACE VIEW lot_genealogy AS
SELECT
    fl.lot_id,
    fl.product_name,
    fl.product_gtin,
    p.name AS producer_name,
    p.country AS producer_country,
    fl.production_date,
    fl.expiry_date,
    fl.lot_status,
    fl.certifications,
    fl.raw_materials,
    fl.blockchain_tx,
    json_agg(
        json_build_object(
            'event_id',    te.event_id,
            'event_type',  te.event_type,
            'actor_name',  te.actor_name,
            'location',    te.location_name,
            'timestamp',   te.created_at,
            'temperature', te.temperature_celsius,
            'humidity',    te.humidity_percent,
            'blockchain',  te.blockchain_tx
        ) ORDER BY te.created_at
    ) AS events
FROM food_lots fl
LEFT JOIN producers p ON fl.producer_gln = p.gln
LEFT JOIN trace_events te ON fl.lot_id = te.lot_id
GROUP BY fl.lot_id, fl.product_name, fl.product_gtin,
         p.name, p.country, fl.production_date, fl.expiry_date,
         fl.lot_status, fl.certifications, fl.raw_materials, fl.blockchain_tx;