CultivaShop × Firebase AI Logic

import { initializeApp } from "firebase/app";
import { getAI, getGenerativeModel, GoogleAIBackend } from "firebase/ai";
import { initializeAppCheck, ReCaptchaEnterpriseProvider } from "firebase/app-check";
import { getRemoteConfig, getValue, fetchAndActivate } from "firebase/remote-config";

// Configuración del proyecto CultivaShop en Firebase
const firebaseConfig = {
  apiKey: "AIzaSy...cultivashop_key",
  authDomain: "cultivashop-prod.firebaseapp.com",
  projectId: "cultivashop-prod",
  storageBucket: "cultivashop-prod.appspot.com",
  messagingSenderId: "847392018456",
  appId: "1:847392018456:web:a3f891bc...",
};

const app = initializeApp(firebaseConfig);

// 🛡️ App Check con reCAPTCHA Enterprise (OBLIGATORIO para producción)
initializeAppCheck(app, {
  provider: new ReCaptchaEnterpriseProvider("6Le...cultivashop_recaptcha_key"),
  isTokenAutoRefreshEnabled: true,
});

// Remote Config: modelo dinámico sin redeploy
const remoteConfig = getRemoteConfig(app);
remoteConfig.defaultConfig = {
  gemini_model: "gemini-2.5-flash",
};
await fetchAndActivate(remoteConfig);
const modelName = getValue(remoteConfig, "gemini_model").asString();

// Inicializar AI Logic con Gemini Developer API
const ai = getAI(app, { backend: new GoogleAIBackend() });

const generationConfig = {
  maxOutputTokens: 2048,
  temperature: 0.7,
  topP: 0.95,
  topK: 40,
};

export const model = getGenerativeModel(ai, {
  model: modelName,  // Desde Remote Config, sin hardcodear
  generationConfig,
});

import { useState, useRef } from "react";
import { model } from "../lib/firebase";

const SYSTEM_PROMPT = `Eres el asistente experto de CultivaShop, tienda de cultivo indoor.
Ayudas a cultivadores con:  técnicas hidropónicas, nutrientes, control de plagas,
fases de cultivo, iluminación LED y vertical farming.
Responde siempre en español, de forma amigable y precisa.`;

export function useCultivaChat() {
  const [messages, setMessages] = useState([]);
  const [isStreaming, setIsStreaming] = useState(false);
  const chatRef = useRef(null);

  // Iniciar sesión de chat con system prompt de CultivaShop
  const initChat = () => {
    chatRef.current = model.startChat({
      history: [{
        role: "user",
        parts: [{ text: SYSTEM_PROMPT }],
      }, {
        role: "model",
        parts: [{ text: "¡Hola! Soy el asistente de CultivaShop. ¿En qué te ayudo hoy?" }],
      }],
    });
  };

  // Enviar mensaje con streaming (efecto de escritura en tiempo real)
  const sendMessage = async (userText) => {
    if (!chatRef.current) initChat();
    setIsStreaming(true);

    // Añadir mensaje del usuario al historial UI
    setMessages(prev => [...prev, { role: "user", text: userText }]);

    let aiText = "";
    setMessages(prev => [...prev, { role: "ai", text: "", streaming: true }]);

    // Streaming: cada chunk actualiza la UI en tiempo real
    const result = await chatRef.current.sendMessageStream(userText);
    for await (const chunk of result.stream) {
      aiText += chunk.text();
      setMessages(prev => {
        const updated = [...prev];
        updated[updated.length - 1] = { role: "ai", text: aiText, streaming: true };
        return updated;
      });
    }
    setIsStreaming(false);
  };

  return { messages, isStreaming, sendMessage };
}

import { model } from "../lib/firebase";

// Convierte File a parte inlineData para Gemini
async function fileToInlineData(file) {
  return new Promise((resolve) => {
    const reader = new FileReader();
    reader.onloadend = () => resolve({
      inlineData: {
        data: reader.result.split(",")[1],
        mimeType: file.type,  // image/jpeg, image/png...
      }
    });
    reader.readAsDataURL(file);
  });
}

export async function diagnosePlant(imageFile) {
  const imagePart = await fileToInlineData(imageFile);

  const prompt = `Eres un experto en fitosanidad y cultivo indoor.
Analiza esta foto de planta y proporciona:
1. Síntomas observados y probable diagnóstico
2. Causa raíz (deficiencia, plaga, enfermedad, riego...)
3. Tratamiento recomendado con productos específicos
4. Medidas preventivas para evitar recaídas
Responde en español, de forma práctica y concreta.`;

  const result = await model.generateContent([prompt, imagePart]);
  return result.response.text();
}

// Nota: para archivos >20 MB usar Cloud Storage for Firebase en lugar de inline data

import { getGenerativeModel, Schema } from "firebase/ai";
import { ai } from "../lib/firebase";

// Modelo configurado para salida JSON estructurada
const nutrientModel = getGenerativeModel(ai, {
  model: "gemini-2.5-flash",
  generationConfig: {
    responseMimeType: "application/json",
    responseSchema: Schema.object({
      properties: {
        planta:       Schema.string(),
        fase:         Schema.string(),
        semana:       Schema.integer(),
        ec_objetivo: Schema.number(),
        ph_objetivo: Schema.number(),
        npk: Schema.object({
          properties: {
            N: Schema.number(),
            P: Schema.number(),
            K: Schema.number(),
          }
        }),
        productos_recomendados: Schema.array({
          items: Schema.object({
            properties: {
              nombre:   Schema.string(),
              dosis_ml_L: Schema.number(),
              frecuencia: Schema.string(),
            }
          })
        }),
        advertencias: Schema.array({ items: Schema.string() }),
      }
    }),
  }
});

export async function getNutrientPlan({ planta, fase, semana, sistema }) {
  const prompt = `Genera un plan de nutrición para:
- Planta: ${planta} | Fase: ${fase} | Semana: ${semana}
- Sistema: ${sistema} (hidropónico/tierra/coco)
Devuelve exclusivamente el JSON con el esquema especificado.`;

  const result = await nutrientModel.generateContent(prompt);
  return JSON.parse(result.response.text()); // → objeto tipado, sin parse errors
}