package service

import (
	"errors"

	"git.huangwc.com/pig/pig-farm-controller/internal/app/dto"
	"git.huangwc.com/pig/pig-farm-controller/internal/infra/logs"
	"git.huangwc.com/pig/pig-farm-controller/internal/infra/models"
	"git.huangwc.com/pig/pig-farm-controller/internal/infra/repository"

	"gorm.io/gorm"
)

var (
	ErrPigBatchNotFound = errors.New("指定的猪批次不存在")
	ErrPigBatchActive   = errors.New("活跃的猪批次不能被删除") // 新增错误：活跃的猪批次不能被删除
)

// PigBatchService 提供了猪批次管理的业务逻辑
type PigBatchService interface {
	CreatePigBatch(dto *dto.PigBatchCreateDTO) (*dto.PigBatchResponseDTO, error)
	GetPigBatch(id uint) (*dto.PigBatchResponseDTO, error)
	UpdatePigBatch(id uint, dto *dto.PigBatchUpdateDTO) (*dto.PigBatchResponseDTO, error)
	DeletePigBatch(id uint) error
	ListPigBatches(isActive *bool) ([]*dto.PigBatchResponseDTO, error)
}

type pigBatchService struct {
	logger *logs.Logger
	repo   repository.PigBatchRepository
}

// NewPigBatchService 创建一个新的 PigBatchService 实例
func NewPigBatchService(repo repository.PigBatchRepository, logger *logs.Logger) PigBatchService {
	return &pigBatchService{
		logger: logger,
		repo:   repo,
	}
}

// toPigBatchResponseDTO 将 models.PigBatch 转换为 dto.PigBatchResponseDTO
func (s *pigBatchService) toPigBatchResponseDTO(batch *models.PigBatch) *dto.PigBatchResponseDTO {
	if batch == nil {
		return nil
	}
	return &dto.PigBatchResponseDTO{
		ID:           batch.ID,
		BatchNumber:  batch.BatchNumber,
		OriginType:   batch.OriginType,
		StartDate:    batch.StartDate,
		EndDate:      batch.EndDate,
		InitialCount: batch.InitialCount,
		Status:       batch.Status,
		IsActive:     batch.IsActive(), // 使用模型自带的 IsActive 方法
		CreateTime:   batch.CreatedAt,
		UpdateTime:   batch.UpdatedAt,
	}
}

// CreatePigBatch 处理创建猪批次的业务逻辑
func (s *pigBatchService) CreatePigBatch(dto *dto.PigBatchCreateDTO) (*dto.PigBatchResponseDTO, error) {
	batch := &models.PigBatch{
		BatchNumber:  dto.BatchNumber,
		OriginType:   dto.OriginType,
		StartDate:    dto.StartDate,
		InitialCount: dto.InitialCount,
		Status:       dto.Status,
	}

	createdBatch, err := s.repo.CreatePigBatch(batch)
	if err != nil {
		s.logger.Errorf("创建猪批次失败: %v", err)
		return nil, err
	}

	return s.toPigBatchResponseDTO(createdBatch), nil
}

// GetPigBatch 处理获取单个猪批次的业务逻辑
func (s *pigBatchService) GetPigBatch(id uint) (*dto.PigBatchResponseDTO, error) {
	batch, err := s.repo.GetPigBatchByID(id)
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, ErrPigBatchNotFound
		}
		s.logger.Errorf("获取猪批次失败，ID: %d, 错误: %v", id, err)
		return nil, err
	}

	return s.toPigBatchResponseDTO(batch), nil
}

// UpdatePigBatch 处理更新猪批次的业务逻辑
func (s *pigBatchService) UpdatePigBatch(id uint, dto *dto.PigBatchUpdateDTO) (*dto.PigBatchResponseDTO, error) {
	existingBatch, err := s.repo.GetPigBatchByID(id)
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, ErrPigBatchNotFound
		}
		s.logger.Errorf("更新猪批次失败，获取原批次信息错误，ID: %d, 错误: %v", id, err)
		return nil, err
	}

	// 根据 DTO 中的非空字段更新模型
	if dto.BatchNumber != nil {
		existingBatch.BatchNumber = *dto.BatchNumber
	}
	if dto.OriginType != nil {
		existingBatch.OriginType = *dto.OriginType
	}
	if dto.StartDate != nil {
		existingBatch.StartDate = *dto.StartDate
	}
	if dto.EndDate != nil {
		existingBatch.EndDate = *dto.EndDate
	}
	if dto.InitialCount != nil {
		existingBatch.InitialCount = *dto.InitialCount
	}
	if dto.Status != nil {
		existingBatch.Status = *dto.Status
	}

	updatedBatch, err := s.repo.UpdatePigBatch(existingBatch)
	if err != nil {
		s.logger.Errorf("更新猪批次失败，ID: %d, 错误: %v", id, err)
		return nil, err
	}

	return s.toPigBatchResponseDTO(updatedBatch), nil
}

// DeletePigBatch 处理删除猪批次的业务逻辑
func (s *pigBatchService) DeletePigBatch(id uint) error {
	// 1. 获取猪批次信息
	batch, err := s.repo.GetPigBatchByID(id)
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return ErrPigBatchNotFound
		}
		s.logger.Errorf("删除猪批次失败，获取批次信息错误，ID: %d, 错误: %v", id, err)
		return err
	}

	// 2. 检查猪批次是否活跃
	if batch.IsActive() {
		return ErrPigBatchActive // 如果活跃，则不允许删除
	}

	// 3. 执行删除操作
	err = s.repo.DeletePigBatch(id)
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) || errors.New("未找到要删除的猪批次").Error() == err.Error() {
			return ErrPigBatchNotFound
		}
		s.logger.Errorf("删除猪批次失败，ID: %d, 错误: %v", id, err)
		return err
	}
	return nil
}

// ListPigBatches 处理批量查询猪批次的业务逻辑
func (s *pigBatchService) ListPigBatches(isActive *bool) ([]*dto.PigBatchResponseDTO, error) {
	batches, err := s.repo.ListPigBatches(isActive)
	if err != nil {
		s.logger.Errorf("批量查询猪批次失败，错误: %v", err)
		return nil, err
	}

	var responseDTOs []*dto.PigBatchResponseDTO
	for _, batch := range batches {
		responseDTOs = append(responseDTOs, s.toPigBatchResponseDTO(batch))
	}

	return responseDTOs, nil
}