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

package service

import (
	"encoding/json"
	"errors"
	"fmt"
	"strings"
	"time"

	"gorm.io/gorm"

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

// 模板分组。注意 StageNewHome 不是年龄阶段，而是「刚到家」叠加包：
// 建档时先按年龄阶段取一套，若到家不足 30 天，再把这一套叠上去。
const (
	StageNewHome  = "刚到家 0-30 天"
	StageJuvenile = "幼年期"
	StageAdult    = "成年期"
	StageSenior   = "老年期"
)

// CareSpecies / CareStages 支持的物种与分组（字符串与 onboarding 一致）
var CareSpecies = []string{model.SpeciesCat, model.SpeciesDog}
var CareStages = []string{StageNewHome, StageJuvenile, StageAdult, StageSenior}

// AgeStages 只含年龄阶段，用于推断和校验（不含叠加包）
var AgeStages = []string{StageJuvenile, StageAdult, StageSenior}

// StageFromBirthday 由生日推断年龄阶段。
// 猫：12 月龄成年、7 岁进入老年。
// 犬：12 月龄成年（大型犬实际 18-24 月，这里取通用值）、7 岁进入老年。
// 拿不到生日就回落到成年期——它的模板最保守，不会给幼崽排年度疫苗、
// 也不会给成年犬排"每周两次称重"。
func StageFromBirthday(species string, birthday *time.Time) string {
	if birthday == nil || birthday.IsZero() {
		return StageAdult
	}
	months := monthsSince(*birthday)
	switch {
	case months < 12:
		return StageJuvenile
	case months >= 7*12:
		return StageSenior
	default:
		return StageAdult
	}
}

// monthsSince 从某天到今天的整月数（不足一月算 0）
func monthsSince(t time.Time) int {
	now := time.Now()
	m := (now.Year()-t.Year())*12 + int(now.Month()) - int(t.Month())
	if now.Day() < t.Day() {
		m--
	}
	if m < 0 {
		m = 0
	}
	return m
}

// NormalizeStage 定下最终使用的年龄阶段。
// 用户手选优先（他可能比生日更清楚，比如领养来的估算年龄），
// 但只认三个年龄阶段；传了「刚到家」或空值时，一律按生日推断。
func NormalizeStage(species, picked string, birthday *time.Time) string {
	for _, s := range AgeStages {
		if picked == s {
			return picked
		}
	}
	return StageFromBirthday(species, birthday)
}

// SpeciesOf 由宠物类型（猫猫/狗狗）映射到模板物种键
func SpeciesOf(petType string) string {
	if strings.Contains(petType, "狗") {
		return model.SpeciesDog
	}
	return model.SpeciesCat
}

func validSpecies(s string) bool { return s == model.SpeciesCat || s == model.SpeciesDog }
func validStage(s string) bool {
	for _, x := range CareStages {
		if x == s {
			return true
		}
	}
	return false
}

// careTemplateItems 取某组合的模板明细。模板是后台配的内容数据，代码里不再留
// 一套内置默认——没配就是没配，这里返回空，由调用方决定怎么处理（见 seedPetDefaults）。
func (s *Service) careTemplateItems(species, stage string) []model.CareTemplateItem {
	var tpl model.CareTemplate
	err := s.db.
		Preload("Items", func(db *gorm.DB) *gorm.DB { return db.Order("kind, sort, id") }).
		Where("species = ? AND stage = ?", species, stage).First(&tpl).Error
	if err != nil {
		return nil
	}
	return tpl.Items
}

// GetCareTemplate 后台读取：返回某组合的明细（DB 优先，无则内置默认）
func (s *Service) GetCareTemplate(species, stage string) (map[string]any, error) {
	if !validSpecies(species) || !validStage(stage) {
		return nil, errors.New("invalid species or stage")
	}
	return map[string]any{
		"species": species,
		"stage":   stage,
		"items":   s.careTemplateItems(species, stage),
	}, nil
}

// SaveCareTemplate 后台保存：整表替换该组合的明细
func (s *Service) SaveCareTemplate(species, stage string, items []model.CareTemplateItem) error {
	if !validSpecies(species) || !validStage(stage) {
		return errors.New("invalid species or stage")
	}
	return s.db.Transaction(func(tx *gorm.DB) error {
		var tpl model.CareTemplate
		err := tx.Where("species = ? AND stage = ?", species, stage).First(&tpl).Error
		if errors.Is(err, gorm.ErrRecordNotFound) {
			tpl = model.CareTemplate{Species: species, Stage: stage}
			if err := tx.Create(&tpl).Error; err != nil {
				return err
			}
		} else if err != nil {
			return err
		}
		if err := tx.Where("template_id = ?", tpl.ID).Delete(&model.CareTemplateItem{}).Error; err != nil {
			return err
		}
		clean := make([]model.CareTemplateItem, 0, len(items))
		for i := range items {
			it := items[i]
			if strings.TrimSpace(it.Title) == "" {
				continue
			}
			it.ID = ""
			it.TemplateID = tpl.ID
			it.Sort = i
			clean = append(clean, it)
		}
		if len(clean) > 0 {
			if err := tx.Create(&clean).Error; err != nil {
				return err
			}
		}
		return nil
	})
}

// GenerateCareTemplate 后台「AI 生成草稿」：不落库，仅返回建议明细。
// AI 未开启或失败时回退内置默认，保证总有可用草稿。
func (s *Service) GenerateCareTemplate(species, stage string) ([]model.CareTemplateItem, error) {
	if !validSpecies(species) || !validStage(stage) {
		return nil, errors.New("invalid species or stage")
	}
	if !s.ai.Enabled() {
		return nil, errors.New("AI 未开启，无法生成草稿；请手动添加明细")
	}
	spName := "猫"
	if species == model.SpeciesDog {
		spName = "狗"
	}
	system := aiSafetyPrompt + `

你现在为后台生成一套「养护模板」，用于新宠建档时自动生成任务/计划/提醒。
只输出 JSON，结构如下（不要多余文字）：
{
  "tasks": [{"title":"","description":"","priority":"重要或空","sheet_type":"weight|poop|food|symptom|vaccine|medicine 或空"}],
  "plan":  [{"day":0,"day_label":"今天","title":"","description":"","sheet_type":"weight|vaccine|medicine|report|taskDetail 或空"}],
  "reminders":[{"reminder_type":"vaccine|deworm|weight|monthlyReport","title":"","offset_days":18,"frequency":"到期用天数则填0并写频率，如每周二五"}]
}
要求：tasks 3 条、plan 4 条、reminders 3-4 条；贴合该物种与阶段的真实照护节奏（如成年比幼年疫苗/驱虫间隔更长，狗驱虫比猫更频繁）。`
	user := fmt.Sprintf("为【%s · %s】生成一套养护模板。", spName, stage)

	out, err := s.ai.Complete(system, []ai.Message{{Role: "user", Content: user}}, ai.Options{JSON: true, Temperature: -1})
	if err != nil {
		return nil, fmt.Errorf("AI 生成失败：%w", err)
	}
	items, ok := parseCareItems(out)
	if !ok || len(items) == 0 {
		return nil, errors.New("AI 返回的内容解析不出可用明细，请重试或手动添加")
	}
	return items, nil
}

// parseCareItems 解析 AI 返回的分组 JSON → 扁平明细
func parseCareItems(out string) ([]model.CareTemplateItem, bool) {
	var raw struct {
		Tasks []struct {
			Title, Description, Priority, SheetType string
		} `json:"tasks"`
		Plan []struct {
			Day                                     int
			DayLabel, Title, Description, SheetType string
		} `json:"plan"`
		Reminders []struct {
			ReminderType, Title, Frequency string
			OffsetDays                     int
		} `json:"reminders"`
	}
	if err := json.Unmarshal([]byte(extractJSON(out)), &raw); err != nil {
		return nil, false
	}
	var items []model.CareTemplateItem
	for _, t := range raw.Tasks {
		if t.Title == "" {
			continue
		}
		items = append(items, careTask(t.Title, t.Description, t.Priority, t.SheetType))
	}
	for _, p := range raw.Plan {
		if p.Title == "" {
			continue
		}
		items = append(items, carePlan(p.Day, p.DayLabel, p.Title, p.Description, p.SheetType))
	}
	for _, r := range raw.Reminders {
		if r.Title == "" {
			continue
		}
		items = append(items, careReminder(r.ReminderType, r.Title, r.OffsetDays, r.Frequency))
	}
	return items, len(items) > 0
}

// ---- 明细构造小工具（供 AI 草稿解析用）----

// careTask 原来产出 kind=task（今日任务）。task 和 plan 已经合并——
// 「每天要做的事」就是「repeat=daily 的计划节点」，AI 草稿里那部分照这个走
func careTask(title, desc, priority, sheet string) model.CareTemplateItem {
	return model.CareTemplateItem{Kind: model.CareKindPlan, Repeat: model.RepeatDaily,
		Title: title, Description: desc, Priority: priority, SheetType: sheet}
}
func carePlan(day int, label, title, desc, sheet string) model.CareTemplateItem {
	return model.CareTemplateItem{Kind: model.CareKindPlan, Repeat: model.RepeatOnce,
		Day: day, DayLabel: label, Title: title, Description: desc, SheetType: sheet}
}
func careReminder(rtype, title string, offset int, freq string) model.CareTemplateItem {
	return model.CareTemplateItem{Kind: model.CareKindReminder, ReminderType: rtype, Title: title, OffsetDays: offset, Frequency: freq}
}