const REGLAS = [
    [/[\w.+-]+@[\w-]+(?:\.[\w-]+)+/g, "<EMAIL>"],
    [/\b[A-Z]{2}\d{2}(?:[ ]?[0-9A-Z]{4}){4,7}\b/g, "<IBAN>"],
    [/\b(?:\d[ -]?){15,18}\d\b/g, "<TARJETA>"],
    [/\b[XYZ]?\d{7,8}[ -]?[A-Z]\b/g, "<DNI>"],
    [/(?<![\w€])\+?\d[\d .-]{7,}\d(?![\w€])/g, "<TEL>"],
    [/\b\d{4,8}\b(?!\s?(?:€|eur|euros))/gi, "<CODIGO>"],
    [/\b(Hola|Estimad[oa]|Querid[oa]|Sr\.?|Sra\.?|Don|Doña|Dear|Hi)(,?\s+)([A-ZÁÉÍÓÚÑ][a-záéíóúñ]+(?:\s+[A-ZÁÉÍÓÚÑ][a-záéíóúñ]+){0,2})/g, "$1$2<NOMBRE>"],
  ];
  // …
  function anonimizar(texto) {
    const urls = [];
    let t = texto.replace(/\u00a0/g, " ").replace(RE_URL, (m) => {
      const c = limpiarUrl(m);
      if (c && !urls.includes(c)) urls.push(c);
      return "<URL>";
    });
    for (const [re, rep] of REGLAS) t = t.replace(re, rep);
    t = t.replace(/[ \t]+/g, " ").replace(/\n{3,}/g, "\n\n").trim();
    return { texto: t.slice(0, MAX), urls };
  }

export function analizarReporte(texto, urls = []) {
  const t = String(texto || "");
  const bajo = t.toLowerCase();
  const sinMarcas = t.replace(/<[A-Z]+>/g, " ");
  const palabras = bajo.replace(/<[a-z]+>/g, " ").match(new RegExp(`[${L}]+`, "g")) || [];
  const letras = (sinMarcas.match(/[A-Za-zÁÉÍÓÚÜÑáéíóúüñ]/g) || []).length;
  const visibles = sinMarcas.replace(/\s/g, "").length || 1;
  const n = palabras.length;

  // Texto sin sentido
  if (/(.)\1{7,}/.test(sinMarcas) || /(..)\1{5,}/.test(sinMarcas.toLowerCase())) return { calidad: "basura", motivo: "caracteres repetidos" };
  if (visibles >= 20 && letras / visibles < 0.45) return { calidad: "basura", motivo: "casi sin letras" };
  if (n >= 20 && new Set(palabras).size / n < 0.3) return { calidad: "basura", motivo: "palabras repetidas" };

  // Señales de fraude (cuántas veces aparecen, no solo si aparecen)
  const enlaces = (Array.isArray(urls) ? urls.length : 0) + (t.match(/<URL>/g) || []).length;
  let senales = (t.match(/<TEL>|<CODIGO>|<IBAN>|<TARJETA>/g) || []).length;
  for (const re of SENALES) senales += (bajo.match(re) || []).length;
  const funcion = palabras.filter((w) => FUNCION.has(w)).length;

  // Texto largo (un libro, una noticia…) con casi nada de fraude, aunque lleve un enlace
  if (n >= 45 && senales < n / 30) return { calidad: "basura", motivo: "texto largo con casi nada típico de un fraude" };
  if (n >= 6 && funcion === 0 && enlaces === 0) return { calidad: "revisar", motivo: "no parece texto real" };
  if (enlaces === 0 && senales === 0) {
    if (n > 40) return { calidad: "basura", motivo: "texto largo sin nada típico de un fraude" };
    return { calidad: "revisar", motivo: "sin enlaces ni señales de fraude" };
  }
  if (n >= 25 && senales < n / 20) return { calidad: "revisar", motivo: "pocas señales de fraude para lo largo que es" };
  return { calidad: "util", motivo: "" };
}

CREATE TABLE IF NOT EXISTS reportes (
  id               TEXT PRIMARY KEY,          -- identificador aleatorio
  creado           TEXT NOT NULL,             -- fecha ISO en UTC
  canal            TEXT NOT NULL,             -- sms, whatsapp, correo, redes, qr, otro
  opinion          TEXT NOT NULL,             -- fraude, dudoso, legitimo
  remitente        TEXT NOT NULL,             -- tipo de remitente, nunca el número
  marca            TEXT,                      -- a quién decía ser
  mes_recepcion    TEXT,                      -- AAAA-MM
  texto            TEXT NOT NULL,             -- mensaje ya anonimizado en el navegador
  urls             TEXT NOT NULL DEFAULT '[]',-- JSON con las URL sin parámetros
  longitud_original INTEGER,
  consentimiento_version TEXT NOT NULL,
  consentimiento_fecha   TEXT NOT NULL,
  codigo_borrado_hash    TEXT NOT NULL,       -- SHA-256 del código que se da a quien reporta
  revisado         INTEGER NOT NULL DEFAULT 0,-- 0 sin revisar, 1 revisado
  etiqueta_final   TEXT,                      -- etiqueta tras revisión: fraude, legitimo, spam
  origen           TEXT                       -- texto, qr o captura (de dónde salió el texto)

// Aplica el movimiento actual teniendo en cuenta el obstáculo
void aplicarMovimiento() {
  int v = velocidad;

  if (vaHaciaDelante(movimiento)) {
    if (distancia < DISTANCIA_FRENO) {
      parar();
      return;
    }
    if (distancia < DISTANCIA_AVISO) {
      v = max(VELOCIDAD_MIN, v / 2);
    }
  }

  int giro = v / 2;  // en las diagonales una rueda va más lenta

  switch (movimiento) {
    case ADELANTE:     mover( v,     v);     break;
    case ATRAS:        mover(-v,    -v);     break;
    case IZQUIERDA:    mover(-v,     v);     break;  // gira sobre sí mismo
    case DERECHA:      mover( v,    -v);     break;
    case ADELANTE_IZQ: mover( giro,  v);     break;
    case ADELANTE_DER: mover( v,     giro);  break;
    case ATRAS_IZQ:    mover(-giro, -v);     break;
    case ATRAS_DER:    mover(-v,    -giro);  break;
    default:           parar();              break;
  }
}

int medirDistancia() {
  digitalWrite(PIN_TRIG, LOW);
  delayMicroseconds(2);
  digitalWrite(PIN_TRIG, HIGH);
  delayMicroseconds(10);
  digitalWrite(PIN_TRIG, LOW);

  // 25 ms de espera máxima ≈ 4 m; si no hay eco, damos el camino por libre
  unsigned long duracion = pulseIn(PIN_ECHO, HIGH, 25000);
  if (duracion == 0) return 999;
  return duracion / 58;  // µs -> cm
}

// El M5Stack manda números:
//   0 parar · 1 adelante · 2 atrás · 3 izquierda · 4 derecha · 5 bocina
// También acepta las mismas letras que por Bluetooth (F, B, S...).
void alRecibirMQTT(char* topic, byte* payload, unsigned int largo) {
  if (largo == 0) return;
  char c = (char)payload[0];

  switch (c) {
    case '0': procesarComando('S'); break;
    case '1': procesarComando('F'); break;
    case '2': procesarComando('B'); break;
    case '3': procesarComando('L'); break;
    case '4': procesarComando('R'); break;
    case '5': bocina = !bocina;     break;
    default:  procesarComando(c);   break;
  }
  Serial.printf("MQTT: %c\n", c);
}

def classify(
    self,
    message: str,
    conversation_history: List[dict] = None
) -> IntentClassification:
    message_lower = message.lower().strip()

    # Check for smalltalk first (highest priority for short messages)
    if self._is_smalltalk(message_lower):
        return IntentClassification(
            intent_type=IntentType.SMALLTALK,
            confidence=0.9,
            triggered_patterns=[],
            recommended_mode=ResponseMode.CONVERSATIONAL
        )

    # Check for copy intent
    copy_score, copy_patterns = self._check_copy_intent(message_lower)

    # Check for legitimate study intent
    study_score, study_patterns = self._check_study_intent(message_lower)

    # Determine intent based on scores
    if copy_score > 0.6 and copy_score > study_score:
        return IntentClassification(
            intent_type=IntentType.COPY_ATTEMPT,
            confidence=copy_score,
            triggered_patterns=copy_patterns,
            recommended_mode=ResponseMode.GUIDED_MODE
        )

    if study_score > 0.5:
        return IntentClassification(
            intent_type=IntentType.LEGITIMATE_STUDY,
            confidence=study_score,
            triggered_patterns=study_patterns,
            recommended_mode=ResponseMode.FULL_RESPONSE
        )

    # Check for clarification (follow-up questions)
    if self._is_clarification(message_lower, conversation_history):
        return IntentClassification(
            intent_type=IntentType.CLARIFICATION,
            confidence=0.7,
            triggered_patterns=[],
            recommended_mode=ResponseMode.FULL_RESPONSE
        )

    # Default: unknown but allow full response
    return IntentClassification(
        intent_type=IntentType.UNKNOWN,
        confidence=0.5,
        triggered_patterns=[],
        recommended_mode=ResponseMode.FULL_RESPONSE
    )

    if not explicit_web_request:
        hits = retrieve(local_index, contextual_query, settings.top_k) if local_index else []
        top_score = hits[0][1] if hits else None

    stale_local_hit = (
        settings.use_freshness_check
        and bool(hits)
        and _has_stale_content(hits, settings.max_doc_age_days, settings.assume_no_date_is_stale)
    )

    if (
        explicit_web_request
        or
        not hits
        or should_use_web_fallback(top_score)
        or top_score < settings.min_score
        or (stale_local_hit and settings.freshness_mode == "Prefer web fallback")
    ):
        web_index = build_web_index(contextual_query)
        hits = retrieve(web_index, contextual_query, settings.top_k) if web_index else []
        top_score = hits[0][1] if hits else None

    if not hits or should_use_web_fallback(top_score) or top_score < settings.min_score:
        return ChatResult(
            assistant_text=insufficient_evidence_message(user_message),
            assistant_meta={"sources": [], "scores": [], "urls": []},
            last_hits=hits,
        )

# en rules_config.py
def should_use_web_fallback(top_score):
    """
    Returns True when local retrieval should be considered insufficient.
    """
    if top_score is None:
        return True
    return top_score < LOCAL_CONFIDENCE_THRESHOLD

public class ExchangeRateService {

    private final OkHttpClient client = new OkHttpClient();
    private final ObjectMapper mapper = new ObjectMapper();

    public double getEuroToUsdRate() throws IOException {

        // API externa de tipos de cambio. Base: EUR
        String url = "https://open.er-api.com/v6/latest/EUR";

        Request request = new Request.Builder()
                .url(url)
                .build();

        try (Response response = client.newCall(request).execute()) {

            if (!response.isSuccessful() || response.body() == null) {
                throw new IOException("Error HTTP al obtener tipo de cambio: " + response.code());
            }

            String json = response.body().string();

            JsonNode root = mapper.readTree(json);
            double rate = root.path("rates").path("USD").asDouble();

            if (rate <= 0) {
                throw new IOException("Tipo de cambio inválido: " + rate);
            }

            return rate;
        }
    }
}