<?php

namespace App\Http\Controllers;

use App\Http\Controllers\MainController;
use Illuminate\Support\Facades\Response;
use Illuminate\Support\Facades\Request;
use Illuminate\Support\Facades\Session;
use App\Http\Controllers\GeminiController;
use App\Http\Controllers\PerplexityController;
use App\Custom\Misc;
use Exception;
use stdClass;

class AIController extends Controller {

    public static function generarJsonEdicto(){        
        $system = Request::input('system');
        $user = Request::input('user');
        $assistant = Request::input('assistant');
        $modelo = Request::input('model');                
        $providerKey = Request::input('provider_key');
        $provider = Request::input('provider');        
        $provider = strtoupper(trim($provider ?? ''));
        $provider = strtoupper($provider);      

        $faltaParametro = [];
        if (empty($system)) $faltaParametro[] = 'system';
        if (empty($user)) $faltaParametro[] = 'user';
        if (empty($assistant)) $faltaParametro[] = 'assistant';
        if (empty($modelo)) $faltaParametro[] = 'model';
        
        if (!empty($faltaParametro)) {
            return self::formatoRespuesta('Missing required parameter: The following fields are required: ' . implode(', ', $faltaParametro), 3006, $modelo, $provider);           
        }

        if (empty($provider) || is_null($provider) ) {            
            return self::formatoRespuesta('Missing required parameter: provider. Please provide a valid value', 3001, $modelo, $provider);           
        }
        
        $respuestaAI = self::generarRespuestaAI($system, $user, $assistant, $modelo, $providerKey, $provider);

        return $respuestaAI;
    }

    public static function generarRespuestaAI($system,$user,$assistant,$modelo,$providerKey,$provider){
        if ($provider == 'GEMINI') {                        

            if (empty($providerKey)) {
                return self::formatoRespuesta('API key missing. Please provide a valid API key',1001,$modelo, $provider);                
            }

            $respuesta = GeminiController::gemminiAiEndpoint($system,$user,$assistant,$providerKey, $modelo);
            $data = $respuesta->getData();

            return self::formatoRespuesta($data, 200,$modelo, $provider);
            
        }elseif ($provider == 'GPT') {
            if ($providerKey == NULL) {
                $providerKey = ENV('apiKey_chatgpt');
            }else {
                $providerKey = $providerKey;
            }

            //$model = 'gpt-4o-mini';

            $dataString = OpenAiController::formateoCompletions($modelo,$system,$assistant,$user,1000);
            $respuesta = OpenAiController::completionsEndpoint($dataString, $providerKey); 
            
            if (isset($respuesta['error'])) {
                $json = $respuesta['error']['message'];
                
                return self::formatoRespuesta($json, 1001,$modelo, $provider);
            }else {
                $json = $respuesta['choices'][0]['message']['content'];
                $array = json_decode($json, true);
                
                return self::formatoRespuesta($array, 1001,$modelo, $provider);               
            }            
        }
        
    }
    
    public static function formatoRespuesta($data, $codigo,$model, $provider) {
        return response()->json([
            'httpStatus' => 200,
            'fideCode' => $codigo,
            'povider'=> $provider,
            'model'=> $model,
            'data' => $data            
        ]);        
    }

    public static function analisisImagen(){
        $system = Request::input('system');
        $assistant = Request::input('assistant');
        $modelo = Request::input('model');                
        $file = Request::file('imagen');
        $provider = 'GPT';
        $apiKey = env('apiKey_chatgpt');

        $faltaParametro = [];
        if (empty($system)) $faltaParametro[] = 'system';
        if (empty($assistant)) $faltaParametro[] = 'assistant';
        if (empty($modelo)) $faltaParametro[] = 'model';
        
        if (!empty($faltaParametro)) {
            return self::formatoRespuesta('Missing required parameter: The following fields are required: ' . implode(', ', $faltaParametro), 3006, $modelo, $provider);           
        }
        
        if (!$file || !$file->isValid()) {            
            return self::formatoRespuesta('Missing required parameter file or  is not valid ', 3007, $modelo, $provider);           

        }

        $imagePath = $file->getRealPath();
        $imageData = base64_encode(file_get_contents($imagePath));
        $mimeType = $file->getMimeType();

        $imageDataUrl = "data:$mimeType;base64,$imageData";

       $data = [
            "model" => $modelo,
            "messages" => [
                [
                    "role" => "system",
                    "content" => $system 
                ],
                [
                    "role" => "user",
                    "content" => [                        
                        ["type" => "image_url", "image_url" => ["url" => $imageDataUrl]]
                    ]
                ],
                [
                    "role" => "assistant",
                    "content" => $assistant 
                ]
            ],
            "max_tokens" => 1000
        ];


        $ch = curl_init('https://api.openai.com/v1/chat/completions');
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_HTTPHEADER, [
            'Authorization: Bearer ' . $apiKey,
            'Content-Type: application/json'
        ]);
        curl_setopt($ch, CURLOPT_POST, true);
        curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));

        $response = curl_exec($ch);

        if (curl_errno($ch)) {
            return response()->json(['error' => 'Curl error: ' . curl_error($ch)], 500);
        }

        curl_close($ch);
        
        //$decoded = json_decode($response, true);
        //$data = json_ecode($decoded['choices'][0]['message']['content']);
        $decoded = json_decode($response, true);

        // Extraer el contenido de la respuesta
        $content = $decoded['choices'][0]['message']['content'] ?? 'Sin respuesta';

        return self::formatoRespuesta($content, 1001, $modelo, $provider);                        
    }
    
    public static function aiInterno() {
        $system = Request::input('system');
        $user = Request::input('user');
        $assistant = Request::input('assistant');
        $modelo = Request::input('model');  

        $faltaParametro = [];
        if (empty($system)) $faltaParametro[] = 'system';
        if (empty($user)) $faltaParametro[] = 'user';
        if (empty($assistant)) $faltaParametro[] = 'assistant';
        if (empty($modelo)) $faltaParametro[] = 'model';
        
        if (!empty($faltaParametro)) {
            return self::formatoRespuesta('Missing required parameter: The following fields are required: ' . implode(', ', $faltaParametro), 3006, $modelo, 'INTERNO');
        }

        $dataChat = [
            "model" => $modelo,
            "messages" => [
                ["role" => "system", "content" => $system],
                ["role" => "user", "content" => $user],
                ["role" => "assistant", "content" => $assistant]
            ],
            "stream" => false
        ];       

        $dataGenerate = [
            "model" => $modelo,
            "prompt" => $user,
            "stream" => false
        ];

        $baseUrl = 'http://192.168.121.112:11434';

        // 1. Probar con /api/chat
        $response = self::enviarCurl("$baseUrl/api/chat", $dataChat);
        
        if ($response['ok']) {
            $decoded = json_decode($response['body'], true);
            if (isset($decoded['message']['content'])) {
                return self::formatoRespuesta($decoded['message']['content'], 1001, $modelo, 'INTERNO');
            }
        }

        // 2. Fallback con /api/generate
        $response = self::enviarCurl("$baseUrl/api/generate", $dataGenerate);
        if ($response['ok']) {
            $decoded = json_decode($response['body'], true);
            if (isset($decoded['response'])) {
                return self::formatoRespuesta($decoded['response'], 1001, $modelo, 'INTERNO');
            }
        }

        // 3. Ambos fallaron
        return self::formatoRespuesta('Error en la llamada: ' . $response['body'], 3005, $modelo, 'INTERNO');
    }

    private static function enviarCurl($url, $data) {
        try {
            $ch = curl_init($url);
            curl_setopt($ch, CURLOPT_POST, true);
            curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
            curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type: application/json']);
            curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
            curl_setopt($ch, CURLOPT_TIMEOUT, 10);

            $response = curl_exec($ch);
            $error = curl_error($ch);
            curl_close($ch);

            if ($error) {
                return ['ok' => false, 'body' => 'CURL Error: ' . $error];
            }

            return ['ok' => true, 'body' => $response];
        } catch (Exception $e) {
            return ['ok' => false, 'body' => 'Exception: ' . $e->getMessage()];
        }
    }

    public static function perplexityAi() {
        $system = Request::input('system');
        $user = Request::input('user');
        $modelo = Request::input('model');
        
         $faltaParametro = [];
        if (empty($system)) $faltaParametro[] = 'system';
        if (empty($user)) $faltaParametro[] = 'user';
        if (empty($modelo)) $faltaParametro[] = 'model';
        
        if (!empty($faltaParametro)) {
            return self::formatoRespuesta('Missing required parameter: The following fields are required: ' . implode(', ', $faltaParametro), 3006, $modelo, 'INTERNO');
        }
        
        $apiKey = env('PERPLEXITY_APIKEY'); 
        $url = env('PERPLEXITY_API_URL');

        $data = [
            "model" => $modelo,
            "messages" => [
                [
                    "role" => "system",
                    "content" => $system
                ],
                [
                    "role" => "user",
                    "content" => $user
                ]
            ]
        ];    
        
        $respuestaPerp = PerplexityController::perplexityCurl($data, $apiKey, $url);
        
        return self::formatoRespuesta($respuestaPerp, 1001, $modelo, 'PERPLEXITY');
    }
}