sundynix-pets/pets-be/internal/service/pet.go

package service

import (
	"encoding/json"
	"log"
	"strings"
	"time"

	"gorm.io/datatypes"
	"gorm.io/gorm"

	"github.com/sundynix/pets-be/internal/model"
)

// PetInput 建/改宠物入参
type PetInput struct {
	Name         string
	Emoji        string
	Type         string
	Gender       string
	Birthday     *time.Time
	ArrivedAt    *time.Time
	Weight       string
	Stage        string
	Age          string
	Color        string
	Breed        string
	AvatarFileID string
	Goals        datatypes.JSON
}

func normalizeWeight(w string) string {
	w = strings.TrimSpace(w)
	if w == "" {
		return ""
	}
	if strings.Contains(w, "kg") {
		return w
	}
	return w + "kg"
}

// ListPets 用户的全部宠物
func (s *Service) ListPets(userID string) ([]model.Pet, error) {
	var pets []model.Pet
	err := s.db.Where("user_id = ?", userID).Order("id asc").Find(&pets).Error
	ids := make([]string, 0, len(pets))
	for i := range pets {
		ids = append(ids, pets[i].AvatarFileID)
	}
	urls := s.fileURLs(ids)
	for i := range pets {
		pets[i].AvatarURL = urls[pets[i].AvatarFileID]
	}
	return pets, err
}

// GetPet 取单只宠物（校验归属）
func (s *Service) GetPet(userID, petID string) (*model.Pet, error) {
	p, err := s.ownedPet(userID, petID)
	if err == nil && p != nil {
		p.AvatarURL = s.fileURL(p.AvatarFileID)
	}
	return p, err
}

// CreatePet 新增宠物并生成默认数据
func (s *Service) CreatePet(userID string, in PetInput) (*model.Pet, error) {
	pet := model.Pet{
		UserID:       userID,
		Name:         in.Name,
		Emoji:        in.Emoji,
		Type:         in.Type,
		Gender:       in.Gender,
		Birthday:     in.Birthday,
		ArrivedAt:    in.ArrivedAt,
		Weight:       normalizeWeight(in.Weight),
		Stage:        in.Stage,
		Age:          in.Age,
		Color:        in.Color,
		Breed:        in.Breed,
		AvatarFileID: in.AvatarFileID,
		HealthStatus: "正常",
		Goals:        in.Goals,
	}
	if err := s.db.Transaction(func(tx *gorm.DB) error {
		if err := tx.Create(&pet).Error; err != nil {
			return err
		}
		return s.seedPetDefaults(tx, &pet)
	}); err != nil {
		return nil, err
	}
	return &pet, nil
}

// UpdatePet 更新宠物字段
func (s *Service) UpdatePet(userID, petID string, fields map[string]any) (*model.Pet, error) {
	if _, err := s.ownedPet(userID, petID); err != nil {
		return nil, err
	}
	if w, ok := fields["weight"].(string); ok {
		fields["weight"] = normalizeWeight(w)
	}
	if err := s.db.Model(&model.Pet{}).Where("id = ?", petID).Updates(fields).Error; err != nil {
		return nil, err
	}
	return s.ownedPet(userID, petID)
}

// DeletePet 删除宠物并级联清除其记录/任务/计划/提醒/每日建议（不留孤儿数据）
func (s *Service) DeletePet(userID, petID string) error {
	if _, err := s.ownedPet(userID, petID); err != nil {
		return err
	}
	return s.db.Transaction(func(tx *gorm.DB) error {
		// 先删计划明细（按 plan_id），再删计划
		var planIDs []string
		tx.Model(&model.Plan{}).Where("pet_id = ?", petID).Pluck("id", &planIDs)
		if len(planIDs) > 0 {
			if err := tx.Where("plan_id IN ?", planIDs).Delete(&model.PlanTask{}).Error; err != nil {
				return err
			}
		}
		for _, m := range []any{
			&model.HealthRecord{}, &model.DailyTask{}, &model.Reminder{},
			&model.Plan{}, &model.DailyAdvice{},
		} {
			if err := tx.Where("pet_id = ?", petID).Delete(m).Error; err != nil {
				return err
			}
		}
		return tx.Where("id = ? AND user_id = ?", petID, userID).Delete(&model.Pet{}).Error
	})
}

// Onboarding 建首宠 + 标记用户已引导
func (s *Service) Onboarding(userID string, in PetInput) (*model.Pet, error) {
	pet, err := s.CreatePet(userID, in)
	if err != nil {
		return nil, err
	}
	if err := s.db.Model(&model.User{}).Where("id = ?", userID).Update("onboarded", true).Error; err != nil {
		return nil, err
	}
	return pet, nil
}

// seedPetDefaults 为新宠按「物种 × 阶段」养护模板生成今日任务、提醒、30 天计划
// seedPetDefaults 建档时只做一件事：建「必须有」的到期提醒（疫苗、驱虫）。
//
// 原来它会自动把整套模板铺开成今日任务 + 30 天计划。改成不自动铺了——
// 用户在建档最后一步自己挑方案，或者选「先空着我自己排」。
// 自动铺的问题是：用户还没看懂这个 App 是干什么的，首页已经躺着十几条
// 他没答应过的任务，第一反应是「这些是什么」而不是「我该做什么」。
//
// 疫苗驱虫这两条例外，因为漏针是真会出事的，而且它们是「到期提醒」不是
// 「今天要做的事」——不占计划页的格子，只在到期时冒出来。
func (s *Service) seedPetDefaults(tx *gorm.DB, pet *model.Pet) error {
	species := SpeciesOf(pet.Type)
	items := s.careTemplateItems(species, pet.Stage)
	if len(items) == 0 {
		log.Printf("care: 养护方案为空 species=%s stage=%s，新宠 %s 建档后没有可选方案，请到后台配置",
			species, pet.Stage, pet.ID)
	}

	goals := petGoals(pet)
	now := time.Now()
	var reminders []model.Reminder
	seen := map[string]bool{}
	for _, it := range items {
		if it.Kind != model.CareKindReminder || seen[it.Title] {
			continue
		}
		if !goalWantsReminder(goals, it.ReminderType) {
			continue
		}
		seen[it.Title] = true
		r := model.Reminder{
			PetID: pet.ID, UserID: pet.UserID, Type: it.ReminderType,
			Title: it.Title, Frequency: it.Frequency,
		}
		if it.OffsetDays > 0 {
			due := now.AddDate(0, 0, dueDaysFor(it, pet, now))
			r.NextDueDate = &due
		}
		reminders = append(reminders, r)
	}
	if len(reminders) > 0 {
		if err := tx.Create(&reminders).Error; err != nil {
			return err
		}
	}
	return nil
}

// ---- 建档默认值的几个判断 ----

// isNewHome 到家不足 30 天。没填到家日期的按「不是新到家」处理，
// 宁可少排几条安置期任务，也不要给养了三年的狗排「先只开放一个房间」。
func isNewHome(arrivedAt *time.Time, now time.Time) bool {
	if arrivedAt == nil || arrivedAt.IsZero() {
		return false
	}
	return now.Sub(*arrivedAt) < 30*24*time.Hour && !arrivedAt.After(now)
}

// petGoals 取建档时勾选的目标
func petGoals(pet *model.Pet) []string {
	if len(pet.Goals) == 0 {
		return nil
	}
	var goals []string
	if err := json.Unmarshal(pet.Goals, &goals); err != nil {
		return nil
	}
	return goals
}

func wantsGoal(goals []string, keyword string) bool {
	for _, g := range goals {
		if strings.Contains(g, keyword) {
			return true
		}
	}
	return false
}

// goalWantsReminder 目标 → 该不该建这类提醒。
// 一条都没勾（比如从「添加宠物」弹层建的档）时全部建，不做减法。
func goalWantsReminder(goals []string, reminderType string) bool {
	if len(goals) == 0 {
		return true
	}
	switch reminderType {
	case model.ReminderVaccine, model.ReminderDeworm:
		// 疫苗和驱虫不给关。狂犬是法定要求，漏驱虫是真会出事的，
		// 不能因为用户建档时没勾「疫苗驱虫怕忘记」就干脆不提醒。
		return true
	case model.ReminderWeight:
		return wantsGoal(goals, "体重") || wantsGoal(goals, "健康")
	case model.ReminderMonthlyReport:
		return wantsGoal(goals, "报告")
	}
	return true
}

// dueDaysFor 算这条提醒几天后到期。
// 模板里的 OffsetDays 是「典型情况」的天数，疫苗和驱虫必须按真实月龄修正——
// 原来不管多大都排「14 天后首针」，一只 8 月龄才接回家的猫会被安排去打首免。
func dueDaysFor(it model.CareTemplateItem, pet *model.Pet, now time.Time) int {
	months := -1
	if pet.Birthday != nil && !pet.Birthday.IsZero() {
		months = monthsSince(*pet.Birthday)
	}

	switch it.ReminderType {
	case model.ReminderVaccine:
		if months < 0 {
			return it.OffsetDays // 不知道月龄就按模板给的典型值
		}
		switch {
		case months < 2:
			// 首免 8 周龄起。还没到就等到那天，已经到了就尽快约。
			if d := 56 - int(now.Sub(*pet.Birthday).Hours()/24); d > 0 {
				return d
			}
			return 7
		case months < 5:
			return 21 // 幼崽针次之间隔 3-4 周
		case months < 12:
			return 14 // 月龄偏大但多半没打全，两周内补齐
		default:
			return it.OffsetDays // 成年后走模板：年度加强用频率而非到期日
		}
	case model.ReminderDeworm:
		if months >= 0 && months < 6 {
			return 30 // 6 月龄前每月一次
		}
		return it.OffsetDays
	}
	return it.OffsetDays
}

// reminderTitle 修正提醒标题。
// 阶段是用户可以手改的，改错了模板就会给一只 3 月龄的幼崽发「年度疫苗加强」。
// 到期日已经按月龄算过（见 dueDaysFor），标题也得跟上，否则用户照着标题去打错针。
func reminderTitle(it model.CareTemplateItem, pet *model.Pet) string {
	if it.ReminderType != model.ReminderVaccine || pet.Birthday == nil || pet.Birthday.IsZero() {
		return it.Title
	}
	months := monthsSince(*pet.Birthday)
	if months >= 12 {
		return it.Title
	}
	if months < 2 {
		return "首针疫苗接种"
	}
	return "下一针疫苗（按月龄安排）"
}