package controllers

import (
	"encoding/json"
	"fmt"
	"net/http"

	"congo.gg/pkg/application"
	"congo.gg/dev/internal"
	"congo.gg/dev/models"
)

func Agent() (string, *AgentController) {
	return "agent", &AgentController{}
}

type AgentController struct {
	application.BaseController
}

func (c *AgentController) Setup(app *application.App) {
	c.BaseController.Setup(app)

	http.Handle("POST /agent/chat", app.Method(c, "Chat", RequireAuth()))
	http.Handle("GET /agent/conversations", app.Method(c, "ListConversations", RequireAuth()))
	http.Handle("GET /agent/conversations/{id}", app.Method(c, "LoadConversation", RequireAuth()))
	http.Handle("POST /agent/conversations/new", app.Method(c, "NewConversation", RequireAuth()))
}

func (c AgentController) Handle(r *http.Request) application.Controller {
	c.Request = r
	return &c
}

// Template methods

func (c *AgentController) Conversations() []*models.Conversation {
	convs, _ := models.Conversations.Search("ORDER BY UpdatedAt DESC LIMIT 20")
	return convs
}

func (c *AgentController) HasAgent() bool {
	return internal.IsAgentAvailable()
}

// Handlers

func (c *AgentController) Chat(w http.ResponseWriter, r *http.Request) {
	message := r.FormValue("message")
	convID := r.FormValue("conversation_id")

	if message == "" {
		c.RenderError(w, r, fmt.Errorf("message is required"))
		return
	}

	if !internal.IsAgentAvailable() {
		c.RenderError(w, r, fmt.Errorf("Claude Code not authenticated — run 'claude' in the IDE terminal to sign in"))
		return
	}

	// Load or create conversation
	var conv *models.Conversation
	if convID != "" {
		conv, _ = models.Conversations.Get(convID)
	}
	if conv == nil {
		conv = &models.Conversation{
			Title: truncate(message, 50),
		}
		id, _ := models.Conversations.Insert(conv)
		conv, _ = models.Conversations.Get(id)
	}

	// Run claude CLI
	response, err := internal.RunAgentChat(message)
	if err != nil {
		c.RenderError(w, r, fmt.Errorf("agent error: %v", err))
		return
	}

	// Save conversation history
	type chatMsg struct {
		Role    string `json:"role"`
		Content string `json:"content"`
	}
	var history []chatMsg
	if conv.Messages != "" {
		json.Unmarshal([]byte(conv.Messages), &history)
	}
	history = append(history, chatMsg{Role: "user", Content: message})
	history = append(history, chatMsg{Role: "assistant", Content: response})
	historyJSON, _ := json.Marshal(history)
	conv.Messages = string(historyJSON)
	models.Conversations.Update(conv)

	// Render response
	type chatResponse struct {
		Response       string
		ConversationID string
	}
	c.Render(w, r, "agent-message.html", chatResponse{
		Response:       response,
		ConversationID: conv.ID,
	})
}

func (c *AgentController) ListConversations(w http.ResponseWriter, r *http.Request) {
	convs, _ := models.Conversations.Search("ORDER BY UpdatedAt DESC LIMIT 20")
	c.Render(w, r, "agent-conversations.html", convs)
}

func (c *AgentController) LoadConversation(w http.ResponseWriter, r *http.Request) {
	conv, err := models.Conversations.Get(r.PathValue("id"))
	if err != nil {
		c.RenderError(w, r, err)
		return
	}

	type chatMsg struct {
		Role    string `json:"role"`
		Content string `json:"content"`
	}
	var messages []chatMsg
	if conv.Messages != "" {
		json.Unmarshal([]byte(conv.Messages), &messages)
	}

	type convData struct {
		Conversation *models.Conversation
		Messages     []chatMsg
	}
	c.Render(w, r, "agent-history.html", convData{conv, messages})
}

func (c *AgentController) NewConversation(w http.ResponseWriter, r *http.Request) {
	c.Redirect(w, r, "/")
}

func truncate(s string, maxLen int) string {
	if len(s) <= maxLen {
		return s
	}
	return s[:maxLen-3] + "..."
}