<?php
if (count(get_included_files()) === 1) { http_response_code(403); exit('Forbidden'); }

require_once __DIR__ . '/gemini.php';

/**
 * GeminiAnalyzer — análisis profundo con Gemini.
 *
 * Separado del chat de atención para no mezclar responsabilidades.
 * Usa modelos más capaces (Pro para análisis complejos, Flash para los rápidos)
 * y técnicas avanzadas (grounding, multimodal, JSON mode).
 *
 * Uso principal:
 *   GeminiAnalyzer::diagnosticarPresencia('Barbería El Tigre', 'Managua', 'barberia')
 *   GeminiAnalyzer::extraerServicios($imageBase64, 'image/jpeg')
 *   GeminiAnalyzer::analizarImagen($base64, 'image/jpeg', 'Describí el estado de este local')
 */
class GeminiAnalyzer {

    /**
     * Diagnóstico de presencia digital del negocio usando Google Search grounding.
     * Vale busca el negocio en Google y analiza lo que encuentra.
     *
     * No requiere Places API — Gemini busca solo.
     *
     * @return array{
     *   encontrado: bool,
     *   resumen: string,
     *   hallazgos: array<array{tipo:string, severidad:int, fuente:string, detalle:string}>,
     *   recomendaciones: array<array{titulo:string, accion:string, prioridad:int}>,
     *   fuentes: array,
     *   error: ?string
     * }
     */
    public static function diagnosticarPresencia(
        string $nombre,
        string $ciudad = '',
        string $rubro  = ''
    ): array {
        $ubicacion = $ciudad ? " en $ciudad" : '';
        $rubroCtx  = $rubro  ? " ($rubro)"   : '';

        $systemPrompt = <<<PROMPT
Sos Vale, una consultora de crecimiento para negocios locales.
Tu tarea: buscar y analizar la presencia digital del negocio "{$nombre}"{$ubicacion}{$rubroCtx}.

Buscá en Google el negocio, su ficha de Google Business/Maps, sus redes sociales y su sitio web si tiene.
Analizá lo que encontrés con ojo crítico.

Devolvé SOLO un JSON válido con esta estructura exacta, sin texto adicional:
{
  "encontrado": true|false,
  "resumen": "2-3 líneas sobre el estado general de su presencia",
  "hallazgos": [
    {
      "tipo": "ficha_incompleta|foto_debil|resena_sin_responder|horario_faltante|descripcion_pobre|sitio_inexistente|sitio_desactualizado|rrss_inactivas|rating_bajo",
      "severidad": 1|2|3,
      "fuente": "google|instagram|sitio|resenas|facebook",
      "detalle": "descripción concreta de lo que encontraste"
    }
  ],
  "recomendaciones": [
    {
      "titulo": "Acción corta y directa",
      "accion": "Qué exactamente se debe hacer",
      "prioridad": 1|2|3
    }
  ]
}

Reglas:
- severidad: 1=bajo impacto, 2=impacto medio, 3=crítico
- prioridad: 1=puede esperar, 2=hacerlo pronto, 3=hacer ya
- Máximo 5 hallazgos y 3 recomendaciones
- Si no encontrás el negocio, devolvé encontrado: false y dejá los arrays vacíos
- Solo datos reales que encontraste. Nunca inventar.
PROMPT;

        $contents = [['role' => 'user', 'parts' => [
            ['text' => "Analizá la presencia digital de: $nombre$ubicacion$rubroCtx"]
        ]]];

        try {
            $result = GeminiService::generateWithSearch($systemPrompt, $contents);
            $parsed = self::parseJson($result['text']);

            if ($parsed === null) {
                return self::errorResult("Respuesta no parseable: " . substr($result['text'], 0, 200));
            }

            return array_merge([
                'encontrado'      => false,
                'resumen'         => '',
                'hallazgos'       => [],
                'recomendaciones' => [],
                'error'           => null,
            ], $parsed, [
                'fuentes' => $result['groundingSources'] ?? [],
            ]);

        } catch (Throwable $e) {
            error_log("[GeminiAnalyzer::diagnosticarPresencia] " . $e->getMessage());
            return self::errorResult($e->getMessage());
        }
    }

    /**
     * Analiza una imagen y responde a una instrucción específica.
     * Genérico — úsalo para cualquier análisis visual.
     *
     * @param string $imageBase64  Imagen en base64
     * @param string $mimeType     'image/jpeg' | 'image/png' | 'image/webp'
     * @param string $instruccion  Qué debe analizar/responder Vale sobre la imagen
     * @param bool   $usePro       Usar modelo Pro para análisis más profundo
     * @return array{texto:string, datos:?array, error:?string}
     */
    public static function analizarImagen(
        string $imageBase64,
        string $mimeType,
        string $instruccion,
        bool   $usePro = false
    ): array {
        $systemPrompt = "Sos Vale, una asistente de IA para negocios locales. Analizá la imagen con criterio práctico y respondé en español, de forma concisa y útil.";

        $contents = [['role' => 'user', 'parts' => [
            ['text' => $instruccion],
            GeminiService::imagePart($imageBase64, $mimeType),
        ]]];

        try {
            $result = $usePro
                ? GeminiService::generatePro($systemPrompt, $contents)
                : GeminiService::generate($systemPrompt, $contents);

            return ['texto' => $result['text'], 'datos' => null, 'error' => null];

        } catch (Throwable $e) {
            error_log("[GeminiAnalyzer::analizarImagen] " . $e->getMessage());
            return ['texto' => '', 'datos' => null, 'error' => $e->getMessage()];
        }
    }

    /**
     * Extrae servicios desde una foto de menú, lista de precios o pizarra.
     * Devuelve el mismo formato que sugerir_servicios para insertar directamente.
     *
     * @return array<array{nombre:string, duracion_min:?int, precio_sugerido:?float}>
     */
    public static function extraerServicios(
        string $imageBase64,
        string $mimeType = 'image/jpeg',
        string $moneda   = 'USD'
    ): array {
        $systemPrompt = "Extraé servicios de la imagen. Devolvé ONLY JSON válido, sin markdown, sin texto extra.";

        $instruccion = "Analizá esta imagen. Si contiene una lista de servicios, menú, precio o pizarra con servicios, extraelos en este formato JSON exacto:
[{\"nombre\":\"Nombre del servicio\",\"duracion_min\":null,\"precio_sugerido\":null}]

Reglas:
- precio_sugerido: número en $moneda si está visible, o null
- duracion_min: minutos si está visible, o null
- Máximo 10 servicios
- Si la imagen no tiene servicios, devolvé []";

        $contents = [['role' => 'user', 'parts' => [
            ['text' => $instruccion],
            GeminiService::imagePart($imageBase64, $mimeType),
        ]]];

        try {
            $result = GeminiService::generate($systemPrompt, $contents, null, null, [
                'responseFormat' => 'json',
                'temperature'    => 0.1,
            ]);

            $parsed = self::parseJson($result['text']);
            if (!is_array($parsed)) return [];

            $servicios = [];
            foreach (array_slice($parsed, 0, 10) as $s) {
                if (empty($s['nombre'])) continue;
                $servicios[] = [
                    'nombre'         => mb_substr(trim($s['nombre']), 0, 120),
                    'duracion_min'   => is_numeric($s['duracion_min'] ?? null) ? (int)$s['duracion_min'] : null,
                    'precio_sugerido'=> is_numeric($s['precio_sugerido'] ?? null) ? (float)$s['precio_sugerido'] : null,
                ];
            }
            return $servicios;

        } catch (Throwable $e) {
            error_log("[GeminiAnalyzer::extraerServicios] " . $e->getMessage());
            return [];
        }
    }

    /**
     * Analiza un mensaje de WhatsApp que incluye una imagen.
     * Construye el contenido multimodal para pasarlo al agente de atención.
     *
     * @return array Contenido en formato Gemini listo para incluir en $contents
     */
    public static function buildWhatsAppImageContent(string $text, string $mediaUrl): ?array {
        try {
            $img = GeminiService::downloadImageAsBase64($mediaUrl);
            return [
                'role'  => 'user',
                'parts' => array_filter([
                    $text ? ['text' => $text] : null,
                    GeminiService::imagePart($img['base64'], $img['mimeType']),
                ]),
            ];
        } catch (Throwable $e) {
            error_log("[GeminiAnalyzer::buildWhatsAppImageContent] " . $e->getMessage());
            return null; // Falla silenciosamente, el mensaje de texto llega igual
        }
    }

    /**
     * Genera una descripción atractiva del negocio para el directorio y página pública.
     * Gemini escribe en ES y EN basándose en el perfil del negocio.
     *
     * @return array{es:string, en:string}
     */
    public static function generarDescripcionNegocio(
        string $nombre,
        string $rubro,
        string $especialidad = '',
        string $ciudad       = '',
        array  $servicios    = []
    ): array {
        $svcCtx = $servicios ? implode(', ', array_column($servicios, 'name')) : '';
        $loc    = $ciudad ? " en $ciudad" : '';
        $esp    = $especialidad ? " ($especialidad)" : '';
        $svcs   = $svcCtx ? " Servicios: $svcCtx." : '';

        $system = "Escribí descripciones breves (máximo 2 frases) para el directorio de un negocio local. Solo el texto, sin comillas ni aclaraciones.";

        try {
            $resultEs = GeminiService::generate(
                $system,
                [['role' => 'user', 'parts' => [['text' => "Español — Negocio: $nombre, rubro $rubro$esp$loc.$svcs"]]]],
                null, GeminiService::MODEL_FLASH, ['temperature' => 0.5, 'maxOutputTokens' => 120]
            );

            $resultEn = GeminiService::generate(
                $system,
                [['role' => 'user', 'parts' => [['text' => "English — Business: $nombre, type $rubro$esp$loc.$svcs"]]]],
                null, GeminiService::MODEL_FLASH, ['temperature' => 0.5, 'maxOutputTokens' => 120]
            );

            return [
                'es' => mb_substr(trim($resultEs['text']), 0, 400),
                'en' => mb_substr(trim($resultEn['text']), 0, 400),
            ];

        } catch (Throwable $e) {
            error_log("[GeminiAnalyzer::generarDescripcionNegocio] " . $e->getMessage());
            return ['es' => '', 'en' => ''];
        }
    }

    // ── Helpers ───────────────────────────────────────────────────────────────

    private static function parseJson(string $raw): ?array {
        // Limpiar posible markdown que Gemini incluya
        $clean = preg_replace('/^```(?:json)?\s*|\s*```$/m', '', trim($raw));
        try {
            $data = json_decode($clean, true, 512, JSON_THROW_ON_ERROR);
            return is_array($data) ? $data : null;
        } catch (Throwable $_e) {
            return null;
        }
    }

    private static function errorResult(string $message): array {
        return [
            'encontrado'      => false,
            'resumen'         => '',
            'hallazgos'       => [],
            'recomendaciones' => [],
            'fuentes'         => [],
            'error'           => $message,
        ];
    }
}
