package controllers

import (
	"hr_receiver/config"
	"hr_receiver/models"
	"net/http"
	"strings"

	"github.com/gin-gonic/gin"
	"gorm.io/gorm"
)

type ProjectProductTemplateAdminController struct {
	DB *gorm.DB
}

type projectProductTemplateItem struct {
	ID              uint   `json:"id"`
	ProjectTypeCode string `json:"projectTypeCode"`
	ProjectTypeName string `json:"projectTypeName"`
	ProductCode     string `json:"productCode"`
	ProductName     string `json:"productName"`
	Quantity        *int   `json:"quantity"`
	QuantityRule    string `json:"quantityRule"`
	IsOptional      bool   `json:"isOptional"`
	Notes           string `json:"notes"`
	Sort            int    `json:"sort"`
}

func NewProjectProductTemplateAdminController() *ProjectProductTemplateAdminController {
	return &ProjectProductTemplateAdminController{DB: config.DB}
}

func (pc *ProjectProductTemplateAdminController) List(c *gin.Context) {
	var items []models.ProjectProductTemplate
	query := pc.DB.Model(&models.ProjectProductTemplate{}).Order("project_type_code ASC, sort ASC, id ASC")

	if projectTypeCode := strings.TrimSpace(c.Query("projectTypeCode")); projectTypeCode != "" {
		query = query.Where("project_type_code = ?", strings.ToLower(projectTypeCode))
	}

	if err := query.Find(&items).Error; err != nil {
		writeError(c, http.StatusInternalServerError, "failed to query project product templates")
		return
	}

	projectTypeCodes := make([]string, 0)
	projectTypeSet := make(map[string]struct{})
	productCodes := make([]string, 0)
	productSet := make(map[string]struct{})
	for _, item := range items {
		if _, ok := projectTypeSet[item.ProjectTypeCode]; !ok {
			projectTypeSet[item.ProjectTypeCode] = struct{}{}
			projectTypeCodes = append(projectTypeCodes, item.ProjectTypeCode)
		}
		if _, ok := productSet[item.ProductCode]; !ok {
			productSet[item.ProductCode] = struct{}{}
			productCodes = append(productCodes, item.ProductCode)
		}
	}

	projectTypeNameMap := make(map[string]string)
	if len(projectTypeCodes) > 0 {
		var projectTypes []models.ProjectType
		if err := pc.DB.Where("code IN ?", projectTypeCodes).Find(&projectTypes).Error; err != nil {
			writeError(c, http.StatusInternalServerError, "failed to query project types")
			return
		}
		for _, item := range projectTypes {
			projectTypeNameMap[item.Code] = item.Name
		}
	}

	productNameMap := make(map[string]string)
	if len(productCodes) > 0 {
		var productDefinitions []models.ProductDefinition
		if err := pc.DB.Where("code IN ?", productCodes).Find(&productDefinitions).Error; err != nil {
			writeError(c, http.StatusInternalServerError, "failed to query product definitions")
			return
		}
		for _, item := range productDefinitions {
			productNameMap[item.Code] = item.Name
		}
	}

	result := make([]projectProductTemplateItem, 0, len(items))
	for _, item := range items {
		result = append(result, projectProductTemplateItem{
			ID:              item.ID,
			ProjectTypeCode: item.ProjectTypeCode,
			ProjectTypeName: projectTypeNameMap[item.ProjectTypeCode],
			ProductCode:     item.ProductCode,
			ProductName:     productNameMap[item.ProductCode],
			Quantity:        item.Quantity,
			QuantityRule:    item.QuantityRule,
			IsOptional:      item.IsOptional,
			Notes:           item.Notes,
			Sort:            item.Sort,
		})
	}

	writeSuccess(c, http.StatusOK, "query success", result)
}