schedule.go

package gomeassistant

import (
	"context"
	"fmt"
	"log/slog"
	"time"

	"github.com/golang-module/carbon"
	"saml.dev/gome-assistant/internal"
)

type ScheduleCallback func(*Service, State)

// DailySchedule is a `scheduledAction` that runs once per day.
type DailySchedule struct {
	// 0-23
	hour int
	// 0-59
	minute int

	callback    ScheduleCallback
	nextRunTime time.Time

	isSunrise bool
	isSunset  bool
	sunOffset DurationString

	exceptionDates []time.Time
	allowlistDates []time.Time

	enabledEntities  []internal.EnabledDisabledInfo
	disabledEntities []internal.EnabledDisabledInfo
}

func (s DailySchedule) Hash() string {
	return fmt.Sprint(s.hour, s.minute, s.callback)
}

type scheduleBuilder struct {
	schedule DailySchedule
}

type scheduleBuilderCall struct {
	schedule DailySchedule
}

type scheduleBuilderEnd struct {
	schedule DailySchedule
}

func NewDailySchedule() scheduleBuilder {
	return scheduleBuilder{
		DailySchedule{
			hour:      0,
			minute:    0,
			sunOffset: "0s",
		},
	}
}

func (s DailySchedule) String() string {
	return fmt.Sprintf("Schedule{ call %q daily at %s }",
		internal.GetFunctionName(s.callback),
		stringHourMinute(s.hour, s.minute),
	)
}

func stringHourMinute(hour, minute int) string {
	return fmt.Sprintf("%02d:%02d", hour, minute)
}

func (sb scheduleBuilder) Call(callback ScheduleCallback) scheduleBuilderCall {
	sb.schedule.callback = callback
	return scheduleBuilderCall(sb)
}

// At takes a string in 24hr format time like "15:30".
func (sb scheduleBuilderCall) At(s string) scheduleBuilderEnd {
	t := internal.ParseTime(s)
	sb.schedule.hour = t.Hour()
	sb.schedule.minute = t.Minute()
	return scheduleBuilderEnd(sb)
}

// Sunrise takes an optional duration string that is passed to time.ParseDuration.
// Examples include "-1.5h", "30m", etc. See https://pkg.go.dev/time#ParseDuration
// for full list.
func (sb scheduleBuilderCall) Sunrise(offset ...DurationString) scheduleBuilderEnd {
	sb.schedule.isSunrise = true
	if len(offset) > 0 {
		sb.schedule.sunOffset = offset[0]
	}
	return scheduleBuilderEnd(sb)
}

// Sunset takes an optional duration string that is passed to time.ParseDuration.
// Examples include "-1.5h", "30m", etc. See https://pkg.go.dev/time#ParseDuration
// for full list.
func (sb scheduleBuilderCall) Sunset(offset ...DurationString) scheduleBuilderEnd {
	sb.schedule.isSunset = true
	if len(offset) > 0 {
		sb.schedule.sunOffset = offset[0]
	}
	return scheduleBuilderEnd(sb)
}

func (sb scheduleBuilderEnd) ExceptionDates(t time.Time, tl ...time.Time) scheduleBuilderEnd {
	sb.schedule.exceptionDates = append(tl, t)
	return sb
}

func (sb scheduleBuilderEnd) OnlyOnDates(t time.Time, tl ...time.Time) scheduleBuilderEnd {
	sb.schedule.allowlistDates = append(tl, t)
	return sb
}

/*
Enable this schedule only when the current state of {entityID} matches {state}.
If there is a network error while retrieving state, the schedule runs if {runOnNetworkError} is true.
*/
func (sb scheduleBuilderEnd) EnabledWhen(entityID, state string, runOnNetworkError bool) scheduleBuilderEnd {
	if entityID == "" {
		panic(fmt.Sprintf("entityID is empty in EnabledWhen entityID='%s' state='%s'", entityID, state))
	}
	i := internal.EnabledDisabledInfo{
		Entity:     entityID,
		State:      state,
		RunOnError: runOnNetworkError,
	}
	sb.schedule.enabledEntities = append(sb.schedule.enabledEntities, i)
	return sb
}

/*
Disable this schedule when the current state of {entityID} matches {state}.
If there is a network error while retrieving state, the schedule runs if {runOnNetworkError} is true.
*/
func (sb scheduleBuilderEnd) DisabledWhen(entityID, state string, runOnNetworkError bool) scheduleBuilderEnd {
	if entityID == "" {
		panic(fmt.Sprintf("entityID is empty in EnabledWhen entityID='%s' state='%s'", entityID, state))
	}
	i := internal.EnabledDisabledInfo{
		Entity:     entityID,
		State:      state,
		RunOnError: runOnNetworkError,
	}
	sb.schedule.disabledEntities = append(sb.schedule.disabledEntities, i)
	return sb
}

func (sb scheduleBuilderEnd) Build() DailySchedule {
	return sb.schedule
}

// run invokes `s.maybeRunCallback()` based on its configured
// schedule. Terminate when `ctx` is canceled.
func (s *DailySchedule) run(ctx context.Context, app *App) {
	// Create a new, but stopped, timer for sleeping on:
	timer := time.NewTimer(1 * time.Hour)
	if !timer.Stop() {
		<-timer.C
	}
	defer stopAndDrainTimer(timer)

	for ctx.Err() == nil {
		if s.nextRunTime.After(time.Now()) {
			slog.Info("Next schedule", "start_time", s.nextRunTime)

			timer.Reset(time.Until(s.nextRunTime))
			select {
			case <-timer.C:
			case <-ctx.Done():
				return
			}
		}

		s.maybeRunCallback(app)
		s.updateNextRunTime(app)
	}
}

func (s DailySchedule) maybeRunCallback(app *App) {
	if c := checkExceptionDates(s.exceptionDates); c.fail {
		return
	}
	if c := checkAllowlistDates(s.allowlistDates); c.fail {
		return
	}
	if c := checkEnabledEntity(app.state, s.enabledEntities); c.fail {
		return
	}
	if c := checkDisabledEntity(app.state, s.disabledEntities); c.fail {
		return
	}
	if app.ctx.Err() != nil {
		return
	}
	app.goTracked(func() {
		s.callback(app.service, app.state)
	})
}

// updateNextRunTime updates `s.nextRunTime` to the next time that `s`
// should run.
func (s *DailySchedule) updateNextRunTime(app *App) {
	if s.isSunrise || s.isSunset {
		var nextSunTime carbon.Carbon
		// "0s" is default value
		if s.sunOffset != "0s" {
			nextSunTime = getNextSunRiseOrSet(app, s.isSunrise, s.sunOffset)
		} else {
			nextSunTime = getNextSunRiseOrSet(app, s.isSunrise)
		}

		s.nextRunTime = nextSunTime.Carbon2Time()
	} else {
		s.nextRunTime = carbon.Time2Carbon(s.nextRunTime).AddDay().Carbon2Time()
	}
}