package services

import (
	"encoding/json"
	"fmt"
	"strings"

	"github.com/sujit-baniya/fiber-boilerplate/pkg/models"
)

// Las tools con las que el dueño arma vigilancias conversando. Solo canal
// interno: cada vigilancia es una llamada saliente recurrente y consultas a la
// IA, o sea plan del dueño gastado por quien la pida.

func umindVigilanciaTools(agenteID uint) []agentTool {
	herramientas, err := models.GetUmindHerramientasActivas(agenteID)
	if err != nil || len(herramientas) == 0 {
		return nil // sin herramientas no hay nada que vigilar
	}
	nombres := make([]string, len(herramientas))
	for i, h := range herramientas {
		nombres[i] = h.Nombre
	}
	return []agentTool{
		{Type: "function", Function: agentToolFunc{
			Name: "crear_vigilancia",
			Description: "Programa una vigilancia sobre una API: consulta cada cierto tiempo y avisa cuando se cumple una condición. " +
				"Herramientas disponibles para vigilar: " + strings.Join(nombres, ", "),
			Parameters: agentToolParam{
				Type: "object",
				Properties: map[string]agentToolParam{
					"nombre":       {Type: "string", Description: "Cómo llamarla, en pocas palabras"},
					"herramienta":  {Type: "string", Description: "Nombre de la herramienta a consultar"},
					"condicion":    {Type: "string", Description: "Qué tiene que pasar para avisar, en lenguaje natural"},
					"cada_minutos": {Type: "number", Description: "Cada cuántos minutos revisar (mínimo 5, por defecto 30)"},
				},
				Required: []string{"nombre", "herramienta", "condicion"},
			},
		}},
		{Type: "function", Function: agentToolFunc{
			Name:        "listar_vigilancias",
			Description: "Lista las vigilancias activas sobre APIs.",
			Parameters:  agentToolParam{Type: "object", Properties: map[string]agentToolParam{}, Required: []string{}},
		}},
		{Type: "function", Function: agentToolFunc{
			Name:        "cancelar_vigilancia",
			Description: "Apaga una vigilancia. Usá listar_vigilancias para saber el id.",
			Parameters: agentToolParam{
				Type:       "object",
				Properties: map[string]agentToolParam{"id": {Type: "number", Description: "El id de la vigilancia"}},
				Required:   []string{"id"},
			},
		}},
	}
}

func executeUmindVigilanciaTool(agenteID uint, sessionID, name string, args map[string]interface{}) string {
	switch name {
	case "crear_vigilancia":
		nombre, _ := args["nombre"].(string)
		herramienta, _ := args["herramienta"].(string)
		condicion, _ := args["condicion"].(string)
		if strings.TrimSpace(nombre) == "" || strings.TrimSpace(condicion) == "" {
			return `{"error": "falta el nombre o la condición"}`
		}
		// La herramienta tiene que existir y ser de este agente: es lo que
		// hace que la vigilancia no pueda apuntar a una URL arbitraria.
		if _, err := models.GetUmindHerramientaByNombre(agenteID, herramienta); err != nil {
			return fmt.Sprintf(`{"error": "no existe una herramienta llamada %q en este agente"}`, herramienta)
		}
		cada := 30
		if n, ok := args["cada_minutos"].(float64); ok && int(n) >= models.UmindVigilanciaIntervaloMin {
			cada = int(n)
		}
		agente, err := models.GetUmindAgenteByID(agenteID)
		if err != nil {
			return `{"error": "no se pudo crear la vigilancia"}`
		}
		v := &models.UmindVigilancia{
			AgenteID: agenteID, TenantID: agente.TenantID, Nombre: nombre,
			Herramienta: herramienta, Condicion: condicion,
			IntervaloMin: cada, Destino: sessionID, Activa: true,
		}
		if err := models.CreateUmindVigilancia(v); err != nil {
			return fmt.Sprintf(`{"error": "no se pudo crear: ya tenés el máximo de %d vigilancias activas"}`, models.UmindVigilanciaMax)
		}
		b, _ := json.Marshal(map[string]interface{}{"ok": true, "id": v.ID, "cada_minutos": cada})
		return string(b)

	case "listar_vigilancias":
		items, err := models.GetUmindVigilanciasByAgente(agenteID)
		if err != nil {
			return `{"error": "no se pudieron listar"}`
		}
		lista := []map[string]interface{}{}
		for _, v := range items {
			if !v.Activa {
				continue
			}
			lista = append(lista, map[string]interface{}{
				"id": v.ID, "nombre": v.Nombre, "condicion": v.Condicion,
				"cada_minutos": v.IntervaloMin, "en_condicion": v.EnCondicion,
			})
		}
		b, _ := json.Marshal(map[string]interface{}{"vigilancias": lista})
		return string(b)

	case "cancelar_vigilancia":
		id, ok := args["id"].(float64)
		if !ok || id <= 0 {
			return `{"error": "falta el id"}`
		}
		v, err := models.GetUmindVigilanciaByID(uint(id))
		if err != nil || v.AgenteID != agenteID {
			return `{"error": "esa vigilancia no existe"}`
		}
		if err := models.DeleteUmindVigilancia(uint(id)); err != nil {
			return `{"error": "no se pudo cancelar"}`
		}
		return `{"ok": true}`
	}
	return `{"error": "herramienta desconocida"}`
}