package controller

import (
	"encoding/base64"
	"io"
	"net/http"

	"github.com/Caknoooo/go-gin-clean-starter/modules/client/dto"
	"github.com/Caknoooo/go-gin-clean-starter/modules/client/query"
	"github.com/Caknoooo/go-gin-clean-starter/modules/client/service"
	"github.com/Caknoooo/go-gin-clean-starter/pkg/constants"
	"github.com/Caknoooo/go-gin-clean-starter/pkg/utils"
	"github.com/gin-gonic/gin"
	"github.com/samber/do"

	// "github.com/sirupsen/logrus"
	"gorm.io/gorm"
)

type (
	ClientController interface {
		Create(ctx *gin.Context)
		Update(ctx *gin.Context)
		Delete(ctx *gin.Context)
		GetById(ctx *gin.Context)
		GetAll(ctx *gin.Context)
		AssignMenusToClient(ctx *gin.Context)
		RemoveMenusFromClient(ctx *gin.Context)
	}

	clientController struct {
		clientService service.ClientService
		db            *gorm.DB
	}
)

func NewClientController(i *do.Injector, clientService service.ClientService) ClientController {
	db := do.MustInvokeNamed[*gorm.DB](i, constants.DB)
	return &clientController{
		clientService: clientService,
		db:            db,
	}
}

// Create godoc
// @Summary      Create a new client
// @Description  Create a new client with the provided information
// @Tags         Clients
// @Accept       multipart/form-data
// @Produce      json
// @Param        name        formData  string  true   "Client name"
// @Param        code        formData  string  true   "Client code"
// @Param        logo        formData  file    false  "Client logo (optional)"
// @Success      200  {object}  utils.Response
// @Failure      400  {object}  utils.Response
// @Failure      500  {object}  utils.Response
// @Router       /clients [post]
func (c *clientController) Create(ctx *gin.Context) {
	var req dto.ClientCreateRequest
	if err := ctx.ShouldBind(&req); err != nil {
		res := utils.BuildResponseFailed(dto.MESSAGE_FAILED_GET_DATA_FROM_BODY, err.Error(), nil)
		ctx.JSON(http.StatusBadRequest, res)
		return
	}

	// Ambil file logo (opsional)
	file, _, err := ctx.Request.FormFile("logo")
	if err == nil && file != nil {
		fileBytes, _ := io.ReadAll(file)
		base64Str := base64.StdEncoding.EncodeToString(fileBytes)
		req.Logo = base64Str
	}

	created, err := c.clientService.Create(ctx, req)
	if err != nil {
		res := utils.BuildResponseFailed(dto.MESSAGE_FAILED_CREATE_CLIENT, err.Error(), nil)
		ctx.JSON(http.StatusInternalServerError, res)
		return
	}

	res := utils.BuildResponseSuccess(dto.MESSAGE_SUCCESS_CREATE_CLIENT, created)
	ctx.JSON(http.StatusOK, res)
}

// Update godoc
// @Summary      Update client
// @Description  Update client information by ID
// @Tags         Clients
// @Accept       multipart/form-data
// @Produce      json
// @Param        id          path      string  true   "Client ID"
// @Param        name        formData  string  false  "Client name"
// @Param        code        formData  string  false  "Client code"
// @Param        logo        formData  file    false  "Client logo (optional)"
// @Success      200  {object}  utils.Response
// @Failure      400  {object}  utils.Response
// @Failure      500  {object}  utils.Response
// @Router       /clients/{id} [put]
func (c *clientController) Update(ctx *gin.Context) {
	id := ctx.Param("id")
	var req dto.ClientUpdateRequest
	if err := ctx.ShouldBind(&req); err != nil {
		res := utils.BuildResponseFailed(dto.MESSAGE_FAILED_GET_DATA_FROM_BODY, err.Error(), nil)
		ctx.JSON(http.StatusBadRequest, res)
		return
	}

	// Ambil file logo (opsional, untuk update)
	file, _, err := ctx.Request.FormFile("logo")
	if err == nil && file != nil {
		fileBytes, _ := io.ReadAll(file)
		base64Str := base64.StdEncoding.EncodeToString(fileBytes)
		req.Logo = &base64Str
	}

	client, err := c.clientService.Update(ctx, req, id)
	if err != nil {
		res := utils.BuildResponseFailed(dto.MESSAGE_FAILED_UPDATE_CLIENT, err.Error(), nil)
		ctx.JSON(http.StatusInternalServerError, res)
		return
	}

	res := utils.BuildResponseSuccess(dto.MESSAGE_SUCCESS_UPDATE_CLIENT, client)
	ctx.JSON(http.StatusOK, res)
}

// Delete godoc
// @Summary      Delete client
// @Description  Delete a client by ID
// @Tags         Clients
// @Accept       json
// @Produce      json
// @Param        id   path      string  true  "Client ID"
// @Success      200  {object}  utils.Response
// @Failure      400  {object}  utils.Response
// @Failure      500  {object}  utils.Response
// @Router       /clients/{id} [delete]
func (c *clientController) Delete(ctx *gin.Context) {
	id := ctx.Param("id")
	if err := c.clientService.Delete(ctx, id); err != nil {
		res := utils.BuildResponseFailed(dto.MESSAGE_FAILED_DELETE_CLIENT, err.Error(), nil)
		ctx.JSON(http.StatusInternalServerError, res)
		return
	}
	res := utils.BuildResponseSuccess(dto.MESSAGE_SUCCESS_DELETE_CLIENT, nil)
	ctx.JSON(http.StatusOK, res)
}

// GetById godoc
// @Summary      Get client by ID
// @Description  Get detailed information of a specific client by their ID
// @Tags         Clients
// @Accept       json
// @Produce      json
// @Param        id   path      string  true  "Client ID"
// @Success      200  {object}  utils.Response
// @Failure      400  {object}  utils.Response
// @Failure      404  {object}  utils.Response
// @Router       /clients/{id} [get]
func (c *clientController) GetById(ctx *gin.Context) {
	id := ctx.Param("id")
	client, err := c.clientService.GetById(ctx, id)
	if err != nil {
		res := utils.BuildResponseFailed(dto.MESSAGE_FAILED_GET_CLIENT, err.Error(), nil)
		ctx.JSON(http.StatusNotFound, res)
		return
	}
	res := utils.BuildResponseSuccess(dto.MESSAGE_SUCCESS_GET_CLIENT, client)
	ctx.JSON(http.StatusOK, res)
}

// GetAll godoc
// @Summary      Get list of clients
// @Description  Get paginated list of clients with filtering and sorting capabilities
// @Tags         Clients
// @Accept       json
// @Produce      json
// @Param        name      query     string  false  "Filter by name (partial match)"
// @Param        code      query     string  false  "Filter by code (partial match)"
// @Param        per_page  query     int     false  "Page size (default: 10)"
// @Param        page      query     int     false  "Page number (default: 1)"
// @Success      200  {object}  utils.ResponseWithPagination
// @Failure      400  {object}  utils.Response
// @Router       /clients [get]
func (c *clientController) GetAll(ctx *gin.Context) {
	// Ambil filter dari query param
	var filter query.ClientFilter
	if err := ctx.ShouldBindQuery(&filter); err != nil {
		res := utils.BuildResponseFailed(dto.MESSAGE_FAILED_GET_CLIENT, err.Error(), nil)
		ctx.JSON(http.StatusBadRequest, res)
		return
	}

	getAll := ctx.Query("get_all")
	if getAll != "" {
		clients, _, err := c.clientService.GetAll(ctx, filter)
		if err != nil {
			res := utils.BuildResponseFailed(dto.MESSAGE_FAILED_GET_CLIENT, err.Error(), nil)
			ctx.JSON(http.StatusBadRequest, res)
			return
		}
		response := utils.BuildResponseSuccess(dto.MESSAGE_SUCCESS_GET_CLIENT, clients)
		ctx.JSON(http.StatusOK, response)
		return
	}

	// Ambil limit & offset dari query param (default: limit=10, offset=0)
	perPage := utils.ParseInt(ctx.DefaultQuery("per_page", "10"))
	page := utils.ParseInt(ctx.DefaultQuery("page", "1"))
	filter.PerPage = perPage
	filter.Page = (page - 1) * perPage

	clients, total, err := c.clientService.GetAll(ctx, filter)
	if err != nil {
		res := utils.BuildResponseFailed(dto.MESSAGE_FAILED_GET_CLIENT, err.Error(), nil)
		ctx.JSON(http.StatusBadRequest, res)
		return
	}

	paginationResponse := utils.BuildPaginationResponse(perPage, page, total)
	response := utils.BuildResponseSuccessWithPagination(http.StatusOK, dto.MESSAGE_SUCCESS_GET_CLIENT, clients, paginationResponse)
	ctx.JSON(http.StatusOK, response)
}

// AssignMenusToClient godoc
// @Summary      Assign menus to client
// @Description  Assign one or more menus to a client
// @Tags         Clients
// @Accept       json
// @Produce      json
// @Param        id      path      string  true  "Client ID"
// @Param        request body dto.AssignMenusToClientRequest true "Menu assignment data"
// @Success      200  {object}  utils.Response
// @Failure      400  {object}  utils.Response
// @Router       /clients/{id}/assign-menus [post]
func (c *clientController) AssignMenusToClient(ctx *gin.Context) {
	clientId := ctx.Param("id")
	var req dto.AssignMenusToClientRequest
	if err := ctx.ShouldBind(&req); err != nil {
		res := utils.BuildResponseFailed(dto.MESSAGE_FAILED_GET_DATA_FROM_BODY, err.Error(), nil)
		ctx.AbortWithStatusJSON(http.StatusBadRequest, res)
		return
	}

	if err := c.clientService.AssignMenusToClient(ctx.Request.Context(), clientId, req.MenuIds); err != nil {
		res := utils.BuildResponseFailed(dto.MESSAGE_FAILED_ASSIGN_MENUS_TO_CLIENT, err.Error(), nil)
		ctx.JSON(http.StatusBadRequest, res)
		return
	}

	resp := utils.BuildResponseSuccess(dto.MESSAGE_SUCCESS_ASSIGN_MENUS_TO_CLIENT, nil)
	ctx.JSON(http.StatusOK, resp)
}

// RemoveMenusFromClient godoc
// @Summary      Remove menus from client
// @Description  Remove one or more menus from a client
// @Tags         Clients
// @Accept       json
// @Produce      json
// @Param        id      path      string  true  "Client ID"
// @Param        request body dto.RemoveMenusFromClientRequest true "Menu removal data"
// @Success      200  {object}  utils.Response
// @Failure      400  {object}  utils.Response
// @Router       /clients/{id}/remove-menus [post]
func (c *clientController) RemoveMenusFromClient(ctx *gin.Context) {
	clientId := ctx.Param("id")
	var req dto.RemoveMenusFromClientRequest
	if err := ctx.ShouldBind(&req); err != nil {
		res := utils.BuildResponseFailed(dto.MESSAGE_FAILED_GET_DATA_FROM_BODY, err.Error(), nil)
		ctx.AbortWithStatusJSON(http.StatusBadRequest, res)
		return
	}

	if err := c.clientService.RemoveMenusFromClient(ctx.Request.Context(), clientId, req.MenuIds); err != nil {
		res := utils.BuildResponseFailed(dto.MESSAGE_FAILED_REMOVE_MENUS_FROM_CLIENT, err.Error(), nil)
		ctx.JSON(http.StatusBadRequest, res)
		return
	}

	resp := utils.BuildResponseSuccess(dto.MESSAGE_SUCCESS_REMOVE_MENUS_FROM_CLIENT, nil)
	ctx.JSON(http.StatusOK, resp)
}