package services

import (
	"net/http"
	"strconv"
	"time"
	"wm-backend/global"
	"wm-backend/internal/models"
	"wm-backend/internal/models/requests"
	"wm-backend/internal/models/responses"
	"wm-backend/internal/repositories"
	"wm-backend/pkg/helper"
	"wm-backend/response"

	"github.com/gin-gonic/gin"
	"github.com/rs/zerolog/log"
)

// ComponentCodeCreate creates a new component code.
// It validates the request body and creates the component code in the database.
//
// @Summary      Create a new component code
// @Description  Create a new component code with the provided details
// @Tags         component-code
// @Accept       json
// @Produce      json
// @Param        body  body  requests.CreateComponentCodeRequest  true  "Component code request body"
// @Success      201   {object}  response.SuccessResponse{data=responses.CreateComponentCodeResponse}
// @Failure      400   {object}  response.ErrorResponse
// @Failure      500   {object}  response.ErrorResponse
// @Router       /api/v1/component-codes [post]
func ComponentCodeCreate(c *gin.Context) error {
	requestBody := requests.CreateComponentCodeRequest{}
	if helper.IsShouldBindJSON(c, &requestBody) {
		return nil
	}
	componentCodeModel := &models.ComponentCode{
		ComponentID: requestBody.ComponentID,
		Code:        requestBody.Code,
		CodeType:    requestBody.CodeType,
		IsPrimary:   requestBody.IsPrimary,
		Metadata:    requestBody.Metadata,
		CreatedAt:   time.Now(),
	}
	componentCode, err := repositories.CreateComponentCode(c.Request.Context(), global.Queries, *componentCodeModel)
	if err != nil {
		response.InternalServerError(c, http.StatusInternalServerError, "Failed to create component code")
		return nil
	}
	response.Created(c, "Component code created successfully", &responses.CreateComponentCodeResponse{
		ID: componentCode.ID,
	})
	return nil
}

// ComponentCodeGetByID retrieves a single component code by its ID.
//
// @Summary      Get component code by ID
// @Description  Retrieve a single component code using its unique identifier
// @Tags         component-code
// @Accept       json
// @Produce      json
// @Param        id   path      int  true  "Component code ID"
// @Success      200  {object}  response.SuccessResponse{data=models.ComponentCode}
// @Failure      400  {object}  response.ErrorResponse
// @Failure      404  {object}  response.ErrorResponse
// @Failure      500  {object}  response.ErrorResponse
// @Router       /api/v1/component-codes/{id} [get]
func ComponentCodeGetByID(c *gin.Context) error {
	id, err := strconv.ParseInt(c.Param("id"), 10, 64)
	if err != nil {
		response.BadRequestError(c, http.StatusBadRequest, "Invalid ID")
		return nil
	}
	componentCode, err := repositories.GetComponentCodeByID(c.Request.Context(), global.Queries, id)
	if err != nil {
		response.NotFoundError(c, http.StatusNotFound, "Component code not found")
		return nil
	}
	response.Ok(c, "Success", componentCode)
	return nil
}

// ComponentCodeList retrieves all component codes.
//
// @Summary      List all component codes
// @Description  Retrieve a list of all component codes ordered by creation date
// @Tags         component-code
// @Accept       json
// @Produce      json
// @Success      200  {object}  response.SuccessResponse{data=[]models.ComponentCode}
// @Failure      500  {object}  response.ErrorResponse
// @Router       /api/v1/component-codes [get]
func ComponentCodeList(c *gin.Context) error {
	componentCodes, err := repositories.ListComponentCodes(c.Request.Context(), global.Queries)
	if err != nil {
		response.InternalServerError(c, http.StatusInternalServerError, "Failed to list component codes")
		return nil
	}
	response.Ok(c, "Success", componentCodes)
	return nil
}

// ComponentCodeUpdate updates an existing component code by its ID.
// It validates the request body, fetches the existing record,
// merges non-empty fields from the request, and updates the component code in the database.
//
// @Summary      Update component code
// @Description  Update an existing component code by its ID. Only non-empty fields will be updated.
// @Tags         component-code
// @Accept       json
// @Produce      json
// @Param        id    path      int                                true  "Component code ID"
// @Param        body  body      requests.UpdateComponentCodeRequest  true  "Component code request body"
// @Success      200   {object}  response.SuccessResponse{data=responses.UpdateComponentCodeResponse}
// @Failure      400   {object}  response.ErrorResponse
// @Failure      404   {object}  response.ErrorResponse
// @Failure      500   {object}  response.ErrorResponse
// @Router       /api/v1/component-codes/{id} [put]
func ComponentCodeUpdate(c *gin.Context) error {
	id, err := strconv.ParseInt(c.Param("id"), 10, 64)
	if err != nil {
		response.BadRequestError(c, http.StatusBadRequest, "Invalid ID")
		return nil
	}
	requestBody := requests.UpdateComponentCodeRequest{}
	if helper.IsShouldBindJSON(c, &requestBody) {
		return nil
	}
	existing, err := repositories.GetComponentCodeByID(c.Request.Context(), global.Queries, id)
	if err != nil {
		response.NotFoundError(c, http.StatusNotFound, "Component code not found")
		return nil
	}
	if requestBody.ComponentID != 0 {
		existing.ComponentID = requestBody.ComponentID
	}
	if requestBody.Code != "" {
		existing.Code = requestBody.Code
	}
	if requestBody.CodeType != "" {
		existing.CodeType = requestBody.CodeType
	}
	if requestBody.IsPrimary != nil {
		existing.IsPrimary = *requestBody.IsPrimary
	}
	if len(requestBody.Metadata) > 0 {
		existing.Metadata = requestBody.Metadata
	}
	componentCode, err := repositories.UpdateComponentCode(c.Request.Context(), global.Queries, existing)
	if err != nil {
		response.InternalServerError(c, http.StatusInternalServerError, "Failed to update component code")
		return nil
	}
	response.Ok(c, "Component code updated successfully", &responses.UpdateComponentCodeResponse{
		ID:          componentCode.ID,
		ComponentID: componentCode.ComponentID,
		Code:        componentCode.Code,
		CodeType:    componentCode.CodeType,
		IsPrimary:   componentCode.IsPrimary,
	})
	return nil
}

// ComponentCodeDelete deletes a component code by its ID.
//
// @Summary      Delete component code
// @Description  Delete a component code by its unique identifier
// @Tags         component-code
// @Accept       json
// @Produce      json
// @Param        id   path      int  true  "Component code ID"
// @Success      200  {object}  response.SuccessResponse
// @Failure      400  {object}  response.ErrorResponse
// @Failure      500  {object}  response.ErrorResponse
// @Router       /api/v1/component-codes/{id} [delete]
func ComponentCodeDelete(c *gin.Context) error {
	id, err := strconv.ParseInt(c.Param("id"), 10, 64)
	if err != nil {
		response.BadRequestError(c, http.StatusBadRequest, "Invalid ID")
		return nil
	}
	rowsAffected, err := repositories.DeleteComponentCode(c.Request.Context(), global.Queries, id)
	if err != nil {
		log.Error().Err(err).Msgf("Failed to delete component code with ID: %d", id)
		response.InternalServerError(c, http.StatusInternalServerError, "Failed to delete component code")
		return nil
	}
	if rowsAffected == 0 {
		response.NotFoundError(c, http.StatusNotFound, "Component code not found")
		return nil
	}
	response.Ok(c, "Delete Success", nil)
	return nil
}