domain

type ActionExecutorCreator interface {
	CreateExecutor(action *HookAction, hookDef *HookDefinition) (EventHandler, error)
}

type AppProfile struct {
	Log       LogConfig       `koanf:"log"`
	Syncthing SyncthingConfig `koanf:"syncthing"`
	Hooks     []Hook          `koanf:"hooks"`
}

type ConnectionServiceStatus struct {
	Error        *string  `json:"error"`
	LanAddresses []string `json:"lanAddresses"`
	WanAddresses []string `json:"wanAddresses"`
}

type DiscoveryStatus struct {
	Error *string `json:"error"`
}

type Event struct {
	Time time.Time   `json:"time"`
	Type EventType   `json:"type"`
	Data interface{} `json:"data"`
}

type EventCh = <-chan *Event

type EventHandler interface {
	SetNext(next EventHandler)
	GetNext() EventHandler
	// Handle processes the event. It should call next handler in most cases.
	Handle(event *Event)
	// Destroy will be called when the handler will not be used anymore.
	// Typically, it should cancel any ongoing coroutines or release other resources.
	//
	// Do not call next handler.
	Destroy()
}

type EventSource interface {
	Subscribe(eventType EventType, params *HookParameters, hookDef *HookDefinition) (EventCh, error)
	// Unsubscribe must eventually close the given channel.
	Unsubscribe(eventCh EventCh)
}

type EventType string

type Hook struct {
	Name       string         `koanf:"name"`
	EventType  string         `koanf:"event-type"`
	Parameter  HookParameters `koanf:"parameter"`
	Conditions []struct {
		Type  string `koanf:"type"`
		Var   string `koanf:"var"`
		Value string `koanf:"value"`
	} `koanf:"conditions"`
	Action HookAction `koanf:"action"`
}

type HookAction struct {
	Type string   `koanf:"type"`
	Cmd  []string `koanf:"cmd"`
}

type HookDefinition struct {
	Name  string
	Index int
}

type HookManager interface {
	RegisterHook(hook *Hook, hookDef *HookDefinition) error
	UnregisterAll()
}

type HookParameters map[string]any

type IllegalEventParamError struct {
	Message string
}

type LastDialStatus struct {
	When  time.Time `json:"when"`
	Error *string   `json:"error"`
}

type LogConfig struct {
	Stdout struct {
		Enabled bool   `koanf:"enabled"`
		Level   string `koanf:"level"`
	} `koanf:"stdout"`
	File LogFileConfig `koanf:"file"`
}

type LogFileConfig struct {
	Enabled    bool   `koanf:"enabled"`
	Level      string `koanf:"level"`
	Dir        string `koanf:"dir"`
	MaxSize    int    `koanf:"max-size"`
	MaxBackups int    `koanf:"max-backups"`
}

type StApiError struct {
	HttpStatusCode int
	Err            error
}

type SyncthingClient interface {
	GetSystemStatus() (*SystemStatus, error)

	// GetEvents receives events. since sets the ID of the last event you’ve already seen. The default value is 0, which
	// returns all events. The timeout duration can be customized with the parameter timeout(seconds).
	// To receive only a limited number of events, add the limit parameter with a suitable value for n and only the last n
	// events will be returned.
	//
	// Note: if more than one eventTypes filter is given, only subsequent events can be fetched. This function will wait
	// until a new event or timeout. However, if there's only one event type or empty, cached events can be fetched.
	// This is the intended behavior of Syncthing API, details: https://github.com/syncthing/syncthing/issues/8902
	GetEvents(eventTypes []events.EventType, since int, timeout int, limit int) ([]events.Event, error)

	GetDiskEvents(since int, timeout int, limit int) ([]events.Event, error)

	SubscribeEvent(eventTypes []events.EventType, since int) <-chan events.Event

	UnsubscribeEvent(eventCh <-chan events.Event)
}

type SyncthingConfig struct {
	Url    string `koanf:"url"`
	ApiKey string `koanf:"apikey"`
}

type SystemStatus struct {
	Alloc                   int                                `json:"alloc"`
	ConnectionServiceStatus map[string]ConnectionServiceStatus `json:"connectionServiceStatus"`
	DiscoveryEnabled        bool                               `json:"discoveryEnabled"`
	DiscoveryErrors         map[string]string                  `json:"discoveryErrors"`
	DiscoveryStatus         map[string]DiscoveryStatus         `json:"discoveryStatus"`
	DiscoveryMethods        int                                `json:"discoveryMethods"`
	Goroutines              int                                `json:"goroutines"`
	LastDialStatus          map[string]LastDialStatus          `json:"lastDialStatus"`
	MyID                    string                             `json:"myID"`
	PathSeparator           string                             `json:"pathSeparator"`
	StartTime               time.Time                          `json:"startTime"`
	Sys                     int                                `json:"sys"`
	Themes                  []string                           `json:"themes"`
	Tilde                   string                             `json:"tilde"`
	Uptime                  int                                `json:"uptime"`
}

type TimeProvider interface {
	NowUnixMilli() int64
}