subtrack/internal/store/checkins.go

package store

import (
	"database/sql"
	"errors"

	"daili/internal/domain"
)

// Checkin 每日服务打卡。
type Checkin struct {
	ID           int64
	SubID        int64
	ServiceDate  string
	Status       string
	Note         string
	OperatorID   int64
	OperatorName string
	CreatedAt    string
	UpdatedAt    string
}

// SaveCheckin 打卡（同订阅同日覆盖），按次套餐完成时扣次。
func (db *DB) SaveCheckin(subID int64, date, status, note string, operatorID int64) error {
	if status != "done" && status != "skipped" {
		return errors.New("打卡状态不正确")
	}
	if _, err := domain.ParseDate(date); err != nil {
		return errors.New("日期格式不正确")
	}
	return db.withTx(func(tx *sql.Tx) error {
		s, err := scanSub(tx.QueryRow(subSelect+` WHERE s.id=?`, subID))
		if err != nil {
			return err
		}
		if s.Status == domain.StatusClosed {
			return errors.New("订阅已结束，无法打卡")
		}
		var oldStatus string
		err = tx.QueryRow(`SELECT status FROM checkins WHERE sub_id=? AND service_date=?`, subID, date).Scan(&oldStatus)
		hasOld := err == nil
		if err != nil && !errors.Is(err, sql.ErrNoRows) {
			return err
		}

		delta := 0
		if s.Abyss {
			if s.CycleDays <= 0 {
				return errors.New("该深渊套餐未设置周期天数")
			}
			d, _ := domain.ParseDate(date)
			start := domain.ParseDateOr(s.StartDate, domain.Today())
			idx := domain.CycleIndex(start, d, s.CycleDays)
			if idx < 0 || idx >= s.TotalCount {
				return errors.New("日期不在深渊周期内")
			}
			cycStart := domain.Date(domain.CycleStart(start, s.CycleDays, idx))
			cycEnd := domain.Date(domain.CycleEnd(start, s.CycleDays, idx))
			var otherDone int
			if err := tx.QueryRow(`SELECT COUNT(*) FROM checkins WHERE sub_id=? AND status='done'
				AND service_date BETWEEN ? AND ? AND service_date<>?`, subID, cycStart, cycEnd, date).Scan(&otherDone); err != nil {
				return err
			}
			oldDone := hasOld && oldStatus == "done"
			newDone := status == "done"
			switch {
			case newDone && !oldDone && otherDone == 0:
				if s.UsedCount >= s.TotalCount {
					return errors.New("所有周期已完成")
				}
				delta = 1
			case !newDone && oldDone && otherDone == 0:
				delta = -1
			}
		} else if s.Unit == domain.UnitCount {
			oldDone := hasOld && oldStatus == "done"
			newDone := status == "done"
			switch {
			case newDone && !oldDone:
				if s.UsedCount+1 > s.TotalCount {
					return errors.New("剩余次数不足，请先追加次数")
				}
				delta = 1
			case !newDone && oldDone:
				delta = -1
			}
		}

		now := nowStamp()
		if hasOld {
			if _, err := tx.Exec(`UPDATE checkins SET status=?, note=?, operator_id=?, updated_at=? WHERE sub_id=? AND service_date=?`,
				status, note, nullIfZero(operatorID), now, subID, date); err != nil {
				return err
			}
		} else {
			if _, err := tx.Exec(`INSERT INTO checkins(sub_id,service_date,status,note,operator_id,created_at,updated_at)
				VALUES(?,?,?,?,?,?,?)`, subID, date, status, note, nullIfZero(operatorID), now, now); err != nil {
				return err
			}
		}
		if delta != 0 {
			newUsed := s.UsedCount + delta
			if newUsed < 0 {
				newUsed = 0
			}
			if _, err := tx.Exec(`UPDATE subscriptions SET used_count=?, updated_at=? WHERE id=?`, newUsed, now, subID); err != nil {
				return err
			}
		}
		return nil
	})
}

// DeleteCheckin 撤销打卡（按次套餐返还次数），返回所属订阅 ID。
func (db *DB) DeleteCheckin(id, operatorID int64) (int64, error) {
	var subID int64
	var status string
	var date string
	err := db.withTx(func(tx *sql.Tx) error {
		if err := tx.QueryRow(`SELECT sub_id,status,service_date FROM checkins WHERE id=?`, id).
			Scan(&subID, &status, &date); err != nil {
			if errors.Is(err, sql.ErrNoRows) {
				return ErrNotFound
			}
			return err
		}
		if _, err := tx.Exec(`DELETE FROM checkins WHERE id=?`, id); err != nil {
			return err
		}
		s, err := scanSub(tx.QueryRow(subSelect+` WHERE s.id=?`, subID))
		if err != nil {
			return err
		}
		delta := 0
		if s.Unit == domain.UnitCount && status == "done" {
			delta = -1
		}
		if s.Abyss && status == "done" && s.CycleDays > 0 {
			d, _ := domain.ParseDate(date)
			start := domain.ParseDateOr(s.StartDate, domain.Today())
			idx := domain.CycleIndex(start, d, s.CycleDays)
			if idx >= 0 {
				cycStart := domain.Date(domain.CycleStart(start, s.CycleDays, idx))
				cycEnd := domain.Date(domain.CycleEnd(start, s.CycleDays, idx))
				var remain int
				if err := tx.QueryRow(`SELECT COUNT(*) FROM checkins WHERE sub_id=? AND status='done'
					AND service_date BETWEEN ? AND ?`, subID, cycStart, cycEnd).Scan(&remain); err != nil {
					return err
				}
				if remain == 0 {
					delta = -1
				}
			}
		}
		if delta != 0 {
			newUsed := s.UsedCount + delta
			if newUsed < 0 {
				newUsed = 0
			}
			if _, err := tx.Exec(`UPDATE subscriptions SET used_count=?, updated_at=? WHERE id=?`,
				newUsed, nowStamp(), subID); err != nil {
				return err
			}
		}
		return nil
	})
	return subID, err
}

// CheckinsBetween 取区间内打卡，索引为 [subID][date]。
func (db *DB) CheckinsBetween(from, to string) (map[int64]map[string]Checkin, error) {
	rows, err := db.sql.Query(`SELECT c.id,c.sub_id,c.service_date,c.status,c.note,IFNULL(c.operator_id,0),
		IFNULL(u.display_name,''),c.created_at,c.updated_at
		FROM checkins c LEFT JOIN users u ON u.id=c.operator_id
		WHERE c.service_date BETWEEN ? AND ?`, from, to)
	if err != nil {
		return nil, err
	}
	return scanCheckinMap(rows)
}

// CheckinsForSubs 只取指定订阅在区间内的打卡，避免客户自助页把全部客户的打卡读进内存。
func (db *DB) CheckinsForSubs(ids []int64, from, to string) (map[int64]map[string]Checkin, error) {
	out := map[int64]map[string]Checkin{}
	if len(ids) == 0 {
		return out, nil
	}
	args := make([]any, 0, len(ids)+2)
	for _, id := range ids {
		args = append(args, id)
	}
	args = append(args, from, to)
	rows, err := db.sql.Query(`SELECT c.id,c.sub_id,c.service_date,c.status,c.note,IFNULL(c.operator_id,0),
		IFNULL(u.display_name,''),c.created_at,c.updated_at
		FROM checkins c LEFT JOIN users u ON u.id=c.operator_id
		WHERE c.sub_id IN (`+placeholders(len(ids))+`) AND c.service_date BETWEEN ? AND ?`, args...)
	if err != nil {
		return nil, err
	}
	return scanCheckinMap(rows)
}

func scanCheckinMap(rows *sql.Rows) (map[int64]map[string]Checkin, error) {
	out := map[int64]map[string]Checkin{}
	defer rows.Close()
	for rows.Next() {
		var c Checkin
		if err := rows.Scan(&c.ID, &c.SubID, &c.ServiceDate, &c.Status, &c.Note, &c.OperatorID,
			&c.OperatorName, &c.CreatedAt, &c.UpdatedAt); err != nil {
			return nil, err
		}
		if out[c.SubID] == nil {
			out[c.SubID] = map[string]Checkin{}
		}
		out[c.SubID][c.ServiceDate] = c
	}
	return out, rows.Err()
}

// CheckinsForSub 某订阅的打卡历史。
func (db *DB) CheckinsForSub(subID int64, limit int) ([]Checkin, error) {
	rows, err := db.sql.Query(`SELECT c.id,c.sub_id,c.service_date,c.status,c.note,IFNULL(c.operator_id,0),
		IFNULL(u.display_name,''),c.created_at,c.updated_at
		FROM checkins c LEFT JOIN users u ON u.id=c.operator_id
		WHERE c.sub_id=? ORDER BY c.service_date DESC LIMIT ?`, subID, limit)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	out := []Checkin{}
	for rows.Next() {
		var c Checkin
		if err := rows.Scan(&c.ID, &c.SubID, &c.ServiceDate, &c.Status, &c.Note, &c.OperatorID,
			&c.OperatorName, &c.CreatedAt, &c.UpdatedAt); err != nil {
			return nil, err
		}
		out = append(out, c)
	}
	return out, rows.Err()
}

// CheckinFor 取某订阅某天的打卡。
func (db *DB) CheckinFor(subID int64, date string) (*Checkin, error) {
	var c Checkin
	err := db.sql.QueryRow(`SELECT c.id,c.sub_id,c.service_date,c.status,c.note,IFNULL(c.operator_id,0),
		IFNULL(u.display_name,''),c.created_at,c.updated_at
		FROM checkins c LEFT JOIN users u ON u.id=c.operator_id
		WHERE c.sub_id=? AND c.service_date=?`, subID, date).
		Scan(&c.ID, &c.SubID, &c.ServiceDate, &c.Status, &c.Note, &c.OperatorID, &c.OperatorName, &c.CreatedAt, &c.UpdatedAt)
	if err != nil {
		if errors.Is(err, sql.ErrNoRows) {
			return nil, ErrNotFound
		}
		return nil, err
	}
	return &c, nil
}