package service

import (
	"psi/database"
	"psi/models"
	systemReq "psi/models/request"
	systemRes "psi/models/response"
	"psi/utils"
	"time"

	"gorm.io/gorm"
)

type SupplierService struct{}

// GetSupplierList 获取供应商列表
func (s *SupplierService) GetSupplierList(req systemReq.GetSupplierListRequest, db ...*gorm.DB) (*systemRes.SupplierListResponse, error) {
	databaseConn := database.OptionalDB(db...)

	if req.Page < 1 {
		req.Page = 1
	}
	if req.PageSize < 1 || req.PageSize > 100 {
		req.PageSize = 20
	}

	query := databaseConn.Model(&models.Supplier{}).Where("is_del = ?", 0)

	if req.Status != "" {
		query = query.Where("status = ?", req.Status)
	}
	if req.Keyword != "" {
		query = query.Where("code like ? OR name like ?", "%"+req.Keyword+"%", "%"+req.Keyword+"%")
	}

	var total int64
	if err := query.Count(&total).Error; err != nil {
		return nil, utils.NewError("查询总数失败")
	}

	var suppliers []models.Supplier
	offset := (req.Page - 1) * req.PageSize
	if err := query.Order("created_at DESC").Offset(offset).Limit(req.PageSize).Find(&suppliers).Error; err != nil {
		return nil, utils.NewError("查询供应商列表失败")
	}

	var supplierItems []systemRes.SupplierItem
	for _, supplier := range suppliers {
		supplierItems = append(supplierItems, systemRes.ConvertSupplierToItem(supplier))
	}

	return &systemRes.SupplierListResponse{
		List:     supplierItems,
		Total:    total,
		Page:     req.Page,
		PageSize: req.PageSize,
	}, nil
}

// GetSupplierDetail 获取供应商详情
func (s *SupplierService) GetSupplierDetail(id int64, db ...*gorm.DB) (*models.Supplier, error) {
	databaseConn := database.OptionalDB(db...)

	var supplier models.Supplier

	result := databaseConn.Where("id = ? AND is_del = ?", id, 0).First(&supplier)
	if result.Error != nil {
		return nil, utils.NewError("供应商不存在")
	}

	return &supplier, nil
}

// CreateSupplier 创建供应商
func (s *SupplierService) CreateSupplier(req systemReq.AddSupplierRequest, db ...*gorm.DB) (int64, error) {
	databaseConn := database.OptionalDB(db...)

	var count int64
	databaseConn.Model(&models.Supplier{}).Where("code = ? AND is_del = ?", req.Code, 0).Count(&count)
	if count > 0 {
		return 0, utils.NewError("供应商编码已存在")
	}

	now := time.Now().Unix()
	supplier := models.Supplier{
		Code:          req.Code,
		Name:          req.Name,
		ContactPerson: req.ContactPerson,
		ContactPhone:  req.ContactPhone,
		Address:       req.Address,
		Status:        req.Status,
		CreatedAt:     now,
		UpdatedAt:     now,
		IsDel:         0,
	}

	if supplier.Status == 0 {
		supplier.Status = 1
	}

	if err := databaseConn.Create(&supplier).Error; err != nil {
		return 0, utils.NewError("创建供应商失败: " + err.Error())
	}

	return supplier.ID, nil
}

// UpdateSupplier 更新供应商
func (s *SupplierService) UpdateSupplier(req systemReq.UpdateSupplierRequest, db ...*gorm.DB) error {
	databaseConn := database.OptionalDB(db...)

	var supplier models.Supplier
	result := databaseConn.Where("id = ? AND is_del = ?", req.ID, 0).First(&supplier)
	if result.Error != nil {
		return utils.NewError("供应商不存在")
	}

	if req.Code != "" && req.Code != supplier.Code {
		var count int64
		databaseConn.Model(&models.Supplier{}).Where("code = ? AND id != ? AND is_del = ?", req.Code, req.ID, 0).Count(&count)
		if count > 0 {
			return utils.NewError("供应商编码已存在")
		}
	}

	updateData := make(map[string]interface{})
	updateData["updated_at"] = time.Now().Unix()

	if req.Code != "" {
		updateData["code"] = req.Code
	}
	if req.Name != "" {
		updateData["name"] = req.Name
	}
	if req.ContactPerson != "" {
		updateData["contact_person"] = req.ContactPerson
	}
	if req.ContactPhone != "" {
		updateData["contact_phone"] = req.ContactPhone
	}
	if req.Address != "" {
		updateData["address"] = req.Address
	}
	if req.Status >= 0 {
		updateData["status"] = req.Status
	}

	if err := databaseConn.Model(&supplier).Updates(updateData).Error; err != nil {
		return utils.NewError("更新供应商失败: " + err.Error())
	}

	return nil
}

// DeleteSupplier 删除供应商（逻辑删除）
func (s *SupplierService) DeleteSupplier(req systemReq.DeleteSupplierRequest, db ...*gorm.DB) error {
	databaseConn := database.OptionalDB(db...)

	var supplier models.Supplier
	result := databaseConn.Where("id = ? AND is_del = ?", req.ID, 0).First(&supplier)
	if result.Error != nil {
		return utils.NewError("供应商不存在")
	}

	updateData := map[string]interface{}{
		"is_del":     1,
		"updated_at": time.Now().Unix(),
	}

	if err := databaseConn.Model(&supplier).Updates(updateData).Error; err != nil {
		return utils.NewError("删除供应商失败: " + err.Error())
	}

	return nil
}