package handlers

import (
	"net/http"

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

func NewToolGroup(
	prefix string,
	e *echo.Group,
	ToolService *tool.Service,
	userService *user.Service,
	middlewares ...echo.MiddlewareFunc) *echo.Group {

	ToolHandler := &ToolHandler{
		ToolService: ToolService,
		userService: userService,
	}
	Tool := e.Group(prefix, middlewares...)

	Tool.GET("/:space", ToolHandler.ListTools)
	Tool.GET("/:space/:tool", ToolHandler.GetTool)
	Tool.GET("/:space/:tool/params", ToolHandler.GetToolParams)
	Tool.PUT("/:space", ToolHandler.UpdateTool)
	Tool.POST("/:space", ToolHandler.CreateTool)
	//Tool.DELETE("/:space/:tool", ToolHandler.DeleteTool)

	return Tool
}

type ToolHandler struct {
	ToolService *tool.Service
	userService *user.Service
}

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

func (h *ToolHandler) GetTool(c *echo.Context) error {
	userID := c.Get(auth.ContextUserIDKey).(string)
	teamID := c.Param("space")
	ToolID := c.Param("tool")
	Tool, err := h.ToolService.GetTool(userID, teamID, ToolID)
	if err != nil {
		c.Logger().Error("error getting Tool", "error", err)
		return echo.NewHTTPError(http.StatusBadRequest, "error getting Tool")
	}
	return c.JSON(http.StatusOK, Tool)
}

func (h *ToolHandler) GetToolParams(c *echo.Context) error {
	userID := c.Get(auth.ContextUserIDKey).(string)
	teamID := c.Param("space")
	toolID := c.Param("tool")
	tool, err := h.ToolService.GetTool(userID, teamID, toolID)
	if err != nil {
		c.Logger().Error("error getting Tool", "error", err, "teamid", teamID, "toolID", toolID)
		return echo.NewHTTPError(http.StatusBadRequest, "error getting Tool")
	}
	toolImpl := h.ToolService.GetToolImpl(tool.Name)
	return c.JSON(http.StatusOK, toolImpl.Params())
}

func (h *ToolHandler) CreateTool(c *echo.Context) error {
	userID := c.Get(auth.ContextUserIDKey).(string)
	teamID := c.Param("space")
	var Tool domain.Tool
	err := c.Bind(&Tool)
	if err != nil {
		c.Logger().Error("error binding Tool", "error", err)
		return echo.NewHTTPError(http.StatusBadRequest, "error binding Tool")
	}
	Tool.TeamID = teamID
	updTool, err := h.ToolService.CreateTool(userID, &Tool)
	if err != nil {
		c.Logger().Error("error creating Tool", "error", err)
		return echo.NewHTTPError(http.StatusBadRequest, "error creating Tool")
	}
	return c.JSON(http.StatusOK, updTool)
}

func (h *ToolHandler) UpdateTool(c *echo.Context) error {
	userID := c.Get(auth.ContextUserIDKey).(string)
	teamID := c.Param("space")
	var Tool domain.Tool
	err := c.Bind(&Tool)
	if err != nil {
		c.Logger().Error("error binding Tool", "error", err)
		return echo.NewHTTPError(http.StatusBadRequest, "error binding Tool")
	}
	Tool.TeamID = teamID
	updTool, err := h.ToolService.UpdateTool(userID, &Tool)
	if err != nil {
		c.Logger().Error("error updating Tool", "error", err)
		return echo.NewHTTPError(http.StatusBadRequest, "error updating Tool")
	}
	return c.JSON(http.StatusOK, updTool)
}

// func (h *ToolHandler) DeleteTool(c *echo.Context) error {
// 	userID := c.Get(auth.ContextUserIDKey).(string)
// 	teamID := c.Param("space")
// 	ToolID := c.Param("tool")
// 	err := h.ToolService.DeleteTool(userID, teamID, ToolID)
// 	if err != nil {
// 		c.Logger().Error("error creating Tool", "error", err)
// 		return echo.NewHTTPError(http.StatusBadRequest, "error creating Tool")
// 	}
// 	return c.JSON(http.StatusOK, ToolID)
// }