package handlers

import (
	"net/http"

	"github.com/labstack/echo/v5"
	"trankilou.fr/lassistanoque/backend/internal/domain"
	"trankilou.fr/lassistanoque/backend/internal/service/agent"
	"trankilou.fr/lassistanoque/backend/internal/service/auth"
	"trankilou.fr/lassistanoque/backend/internal/service/user"
)

func NewAgentGroup(
	prefix string,
	e *echo.Group,
	agentService *agent.Service,
	userService *user.Service,
	middlewares ...echo.MiddlewareFunc) *echo.Group {

	agentHandler := &AgentHandler{
		agentService: agentService,
		userService:  userService,
	}
	agent := e.Group(prefix, middlewares...)

	agent.GET("/:space", agentHandler.ListAgents)
	agent.GET("/:space/:agent", agentHandler.GetAgent)
	agent.PUT("/:space", agentHandler.UpdateAgent)
	agent.POST("/:space", agentHandler.CreateAgent)
	agent.DELETE("/:space/:agent", agentHandler.DeleteAgent)

	return agent
}

type AgentHandler struct {
	agentService *agent.Service
	userService  *user.Service
}

func (h *AgentHandler) ListAgents(c *echo.Context) error {
	userID := c.Get(auth.ContextUserIDKey).(string)
	teamID := c.Param("space")
	agents, err := h.agentService.ListAgents(userID, teamID)
	if err != nil {
		c.Logger().Error("error listing agents", "error", err)
		return echo.NewHTTPError(http.StatusBadRequest, "error listing agents")
	}
	return c.JSON(http.StatusOK, agents)
}

func (h *AgentHandler) GetAgent(c *echo.Context) error {
	userID := c.Get(auth.ContextUserIDKey).(string)
	teamID := c.Param("space")
	agentID := c.Param("agent")
	agent, err := h.agentService.GetAgent(userID, teamID, agentID)
	if err != nil {
		c.Logger().Error("error getting agent", "error", err)
		return echo.NewHTTPError(http.StatusBadRequest, "error getting agent")
	}
	return c.JSON(http.StatusOK, agent)
}

func (h *AgentHandler) CreateAgent(c *echo.Context) error {
	userID := c.Get(auth.ContextUserIDKey).(string)
	teamID := c.Param("space")
	var agent domain.Agent
	err := c.Bind(&agent)
	if err != nil {
		c.Logger().Error("error binding agent", "error", err)
		return echo.NewHTTPError(http.StatusBadRequest, "error binding agent")
	}
	agent.TeamID = teamID
	updagent, err := h.agentService.CreateAgent(userID, &agent)
	if err != nil {
		c.Logger().Error("error creating agent", "error", err)
		return echo.NewHTTPError(http.StatusBadRequest, "error creating agent")
	}
	return c.JSON(http.StatusOK, updagent)
}

func (h *AgentHandler) UpdateAgent(c *echo.Context) error {
	userID := c.Get(auth.ContextUserIDKey).(string)
	teamID := c.Param("space")
	var agent domain.Agent
	err := c.Bind(&agent)
	if err != nil {
		c.Logger().Error("error binding agent", "error", err)
		return echo.NewHTTPError(http.StatusBadRequest, "error binding agent")
	}
	agent.TeamID = teamID
	updagent, err := h.agentService.UpdateAgent(userID, &agent)
	if err != nil {
		c.Logger().Error("error updating agent", "error", err)
		return echo.NewHTTPError(http.StatusBadRequest, "error updating agent")
	}
	return c.JSON(http.StatusOK, updagent)
}

func (h *AgentHandler) DeleteAgent(c *echo.Context) error {
	userID := c.Get(auth.ContextUserIDKey).(string)
	teamID := c.Param("space")
	agentID := c.Param("agent")
	err := h.agentService.DeleteAgent(userID, teamID, agentID)
	if err != nil {
		c.Logger().Error("error creating agent", "error", err)
		return echo.NewHTTPError(http.StatusBadRequest, "error creating agent")
	}
	return c.JSON(http.StatusOK, agentID)
}

type DefaulAgentRequest struct {
	AgentID string `json:"AgentId"`
}
type DefaulAgentResponse struct {
	NewDefaultAgentID *string `json:"newDefaultAgentId"`
	OldDefaultAgentID *string `json:"oldDefaultAgentId"`
}