amcs/internal/store/calendar.go

package store

import (
	"context"
	"fmt"
	"strings"
	"time"

	"github.com/google/uuid"

	"git.warky.dev/wdevs/amcs/internal/generatedmodels"
	ext "git.warky.dev/wdevs/amcs/internal/types"
)

func (db *DB) AddFamilyMember(ctx context.Context, m ext.FamilyMember) (ext.FamilyMember, error) {
	row := db.pool.QueryRow(ctx, `
		insert into family_members (name, relationship, birth_date, notes)
		values ($1, $2, $3, $4)
		returning id, created_at
	`, m.Name, nullStr(m.Relationship), m.BirthDate, nullStr(m.Notes))

	created := m
	var model generatedmodels.ModelPublicFamilyMembers
	if err := row.Scan(&model.ID, &model.CreatedAt); err != nil {
		return ext.FamilyMember{}, fmt.Errorf("insert family member: %w", err)
	}
	created.ID = model.ID.UUID()
	created.CreatedAt = model.CreatedAt.Time()
	return created, nil
}

func (db *DB) ListFamilyMembers(ctx context.Context) ([]ext.FamilyMember, error) {
	rows, err := db.pool.Query(ctx, `select id, name, relationship, birth_date, notes, created_at from family_members order by name`)
	if err != nil {
		return nil, fmt.Errorf("list family members: %w", err)
	}
	defer rows.Close()

	var members []ext.FamilyMember
	for rows.Next() {
		var model generatedmodels.ModelPublicFamilyMembers
		if err := rows.Scan(&model.ID, &model.Name, &model.Relationship, &model.BirthDate, &model.Notes, &model.CreatedAt); err != nil {
			return nil, fmt.Errorf("scan family member: %w", err)
		}
		members = append(members, familyMemberFromModel(model))
	}
	return members, rows.Err()
}

func (db *DB) AddActivity(ctx context.Context, a ext.Activity) (ext.Activity, error) {
	row := db.pool.QueryRow(ctx, `
		insert into activities (family_member_id, title, activity_type, day_of_week, start_time, end_time, start_date, end_date, location, notes)
		values ($1, $2, $3, $4, $5::time, $6::time, $7, $8, $9, $10)
		returning id, created_at
	`, a.FamilyMemberID, a.Title, nullStr(a.ActivityType), nullStr(a.DayOfWeek),
		nullStr(a.StartTime), nullStr(a.EndTime), a.StartDate, a.EndDate,
		nullStr(a.Location), nullStr(a.Notes))

	created := a
	var model generatedmodels.ModelPublicActivities
	if err := row.Scan(&model.ID, &model.CreatedAt); err != nil {
		return ext.Activity{}, fmt.Errorf("insert activity: %w", err)
	}
	created.ID = model.ID.UUID()
	created.CreatedAt = model.CreatedAt.Time()
	return created, nil
}

func (db *DB) GetWeekSchedule(ctx context.Context, weekStart time.Time) ([]ext.Activity, error) {
	weekEnd := weekStart.AddDate(0, 0, 7)

	rows, err := db.pool.Query(ctx, `
		select a.id, a.family_member_id, fm.name, a.title, a.activity_type,
		       a.day_of_week, a.start_time::text, a.end_time::text,
		       a.start_date, a.end_date, a.location, a.notes, a.created_at
		from activities a
		left join family_members fm on fm.id = a.family_member_id
		where (a.start_date >= $1 and a.start_date < $2)
		   or (a.day_of_week is not null and (a.end_date is null or a.end_date >= $1))
		order by a.start_date, a.start_time
	`, weekStart, weekEnd)
	if err != nil {
		return nil, fmt.Errorf("get week schedule: %w", err)
	}
	defer rows.Close()

	return scanActivities(rows)
}

func (db *DB) SearchActivities(ctx context.Context, query, activityType string, memberID *uuid.UUID) ([]ext.Activity, error) {
	args := []any{}
	conditions := []string{}

	if q := strings.TrimSpace(query); q != "" {
		args = append(args, "%"+q+"%")
		conditions = append(conditions, fmt.Sprintf("(a.title ILIKE $%d OR a.notes ILIKE $%d)", len(args), len(args)))
	}
	if t := strings.TrimSpace(activityType); t != "" {
		args = append(args, t)
		conditions = append(conditions, fmt.Sprintf("a.activity_type = $%d", len(args)))
	}
	if memberID != nil {
		args = append(args, *memberID)
		conditions = append(conditions, fmt.Sprintf("a.family_member_id = $%d", len(args)))
	}

	q := `
		select a.id, a.family_member_id, fm.name, a.title, a.activity_type,
		       a.day_of_week, a.start_time::text, a.end_time::text,
		       a.start_date, a.end_date, a.location, a.notes, a.created_at
		from activities a
		left join family_members fm on fm.id = a.family_member_id
	`
	if len(conditions) > 0 {
		q += " where " + strings.Join(conditions, " and ")
	}
	q += " order by a.start_date, a.start_time"

	rows, err := db.pool.Query(ctx, q, args...)
	if err != nil {
		return nil, fmt.Errorf("search activities: %w", err)
	}
	defer rows.Close()

	return scanActivities(rows)
}

func (db *DB) AddImportantDate(ctx context.Context, d ext.ImportantDate) (ext.ImportantDate, error) {
	row := db.pool.QueryRow(ctx, `
		insert into important_dates (family_member_id, title, date_value, recurring_yearly, reminder_days_before, notes)
		values ($1, $2, $3, $4, $5, $6)
		returning id, created_at
	`, d.FamilyMemberID, d.Title, d.DateValue, d.RecurringYearly, d.ReminderDaysBefore, nullStr(d.Notes))

	created := d
	var model generatedmodels.ModelPublicImportantDates
	if err := row.Scan(&model.ID, &model.CreatedAt); err != nil {
		return ext.ImportantDate{}, fmt.Errorf("insert important date: %w", err)
	}
	created.ID = model.ID.UUID()
	created.CreatedAt = model.CreatedAt.Time()
	return created, nil
}

func (db *DB) GetUpcomingDates(ctx context.Context, daysAhead int) ([]ext.ImportantDate, error) {
	if daysAhead <= 0 {
		daysAhead = 30
	}
	now := time.Now()
	cutoff := now.AddDate(0, 0, daysAhead)

	// For yearly recurring events, check if this year's occurrence falls in range
	rows, err := db.pool.Query(ctx, `
		select d.id, d.family_member_id, fm.name, d.title, d.date_value,
		       d.recurring_yearly, d.reminder_days_before, d.notes, d.created_at
		from important_dates d
		left join family_members fm on fm.id = d.family_member_id
		where (
			(d.recurring_yearly = false and d.date_value between $1 and $2)
			or
			(d.recurring_yearly = true and
			 make_date(extract(year from now())::int, extract(month from d.date_value)::int, extract(day from d.date_value)::int)
			 between $1 and $2)
		)
		order by d.date_value
	`, now, cutoff)
	if err != nil {
		return nil, fmt.Errorf("get upcoming dates: %w", err)
	}
	defer rows.Close()

	var dates []ext.ImportantDate
	for rows.Next() {
		var model generatedmodels.ModelPublicImportantDates
		var memberName *string
		if err := rows.Scan(&model.ID, &model.FamilyMemberID, &memberName, &model.Title, &model.DateValue,
			&model.RecurringYearly, &model.ReminderDaysBefore, &model.Notes, &model.CreatedAt); err != nil {
			return nil, fmt.Errorf("scan important date: %w", err)
		}
		dates = append(dates, importantDateFromModel(model, strVal(memberName)))
	}
	return dates, rows.Err()
}

func scanActivities(rows interface {
	Next() bool
	Scan(...any) error
	Err() error
	Close()
}) ([]ext.Activity, error) {
	defer rows.Close()
	var activities []ext.Activity
	for rows.Next() {
		var model generatedmodels.ModelPublicActivities
		var memberName *string
		if err := rows.Scan(
			&model.ID, &model.FamilyMemberID, &memberName, &model.Title, &model.ActivityType,
			&model.DayOfWeek, &model.StartTime, &model.EndTime,
			&model.StartDate, &model.EndDate, &model.Location, &model.Notes, &model.CreatedAt,
		); err != nil {
			return nil, fmt.Errorf("scan activity: %w", err)
		}
		activities = append(activities, activityFromModel(model, strVal(memberName)))
	}
	return activities, rows.Err()
}