ifttt

type Action interface {
	// Options is called during an action dynamic option request
	// Use req.FieldSlug for the field requested by this action.
	// If your action does not contain dynamic options, return nil, nil here.
	Options(req *Request) (*DynamicOption, error)
	// Handle is called then an applet triggered this action.
	// This is where you should check the validity of the request and handle the action.
	// If the request was unauthorized, return ifttt.ErrorInvalidToken
	// If the request cannot be performed due to a temporary error and you want IFTTT to retry this action later, set skip to false and return the error.
	// If there is a problem with the request that you cannot handle(eg: conflicting parameters), set skip to true and return the error, IFTTT will notify the user with the description of your error and give up.
	Handle(r *ActionHandleRequest, req *Request) (res *ActionResult, skip bool, err error)
}

type ActionHandleRequest struct {
	// ActionFields are the parameters set in an applet
	ActionFields map[string]string
	// User contains the metadata of the IFTTT user (eg: timezone)
	User map[string]string
}

type ActionResult struct {
	// ID a string value which uniquely identifies the resource created or modified by the action.
	ID string
	// URL optional parameter, URL to the resource created or modified by the action.
	URL string
}

type AuthError struct {
	Message string
}

type DynamicOption struct {
	// contains filtered or unexported fields
}

type Notification struct {
	// contains filtered or unexported fields
}

type Request struct {
	// Authenticated whether the request was carrying an OAuth token or not
	Authenticated bool
	// UserAccessToken if Authenticated is true, this is the token provided by IFTTT, is not, this is set to the claimed Service Key from IFTTT
	UserAccessToken string
	// RequestUUID is a unique string which identifies requests for debugging purposes
	RequestUUID string
	// Slug the slug name of the action/trigger, you generally dont need to check this as requests are automatically routed by the package to their endpoints.
	Slug string
	// FieldSlug the field slug requested by the request, empty string in non field-related requests
	FieldSlug string
	// TriggerIdentity the identification of the trigger which initiated this request, empty string if not available
	TriggerIdentity string
	// DecodedBody the decoded JSON body of the request, you can extract data manually if it was not exposed by this package
	DecodedBody *gabs.Container
	// Type the type of the request, you generally dont need to check this as requests are automatically routed by the package to their endpoints.
	Type RequestType
	// RawRequest the raw HTTP request from IFTTT
	RawRequest *http.Request
	// ServiceRef reference to the service struct
	ServiceRef *Service
}

type RequestType int

type Service struct {

	// IFTTT service key used to identify your service
	// get it from you dashboard
	ServiceKey string
	// Healthy should return whether the service is functioning normally
	// Defaults to true
	Healthy func() bool
	// UserInfo should return user info identified by req.UserAccessToken
	// if your service does not require authentication, passing nil should be OK
	UserInfo func(req *Request) (*UserInfo, error)
	// contains filtered or unexported fields
}

type Trigger interface {
	// Poll askes the trigger for event updates
	// Implementations should return recent events regarding this trigger.
	// It does not matter if you return events which is already reported before, as long as the ID was kept the same.
	Poll(req *TriggerPollRequest, r *Request) (TriggerEventCollection, error)
	// Options is called during a trigger dynamic option request
	// Use req.FieldSlug for the field requested by this request.
	// If your trigger does not contain dynamic options, return nil, nil here.
	Options(req *Request) (*DynamicOption, error)
	// ValidateField is called during a trigger single-field validation request
	// Use req.FieldSlug for the field requested by this request.
	// If the field value is unacceptable, return a non-nil error which contains a friendly message describing the problem
	ValidateField(fieldslug string, value string, req *Request) error
	// ValidateContext is called during a trigger field context validation request
	// You need to contact IFTTT first to have this feature enabled
	// If you do not use this feature, return nil, nil here.
	ValidateContext(values map[string]string, req *Request) (map[string]error, error)
	// RemoveIdentity is called to notify the the trigger identified by triggerid has been deleted and the endpoint can stop tracking updates to this trigger
	// This is for performance reasons, especially when you are using real-time functions.
	// You can safely ignore this by returning nil directly.
	RemoveIdentity(triggerid string) error
	// RealTie should return whether this service supports the IFTTT real-time API.
	// If set to true, IFTTT will poll a lot less often on this trigger and rely on your active notification instead.
	// If you does not know what is IFTTT real-time API, return false here.
	RealTime() bool
}

type TriggerEvent struct {
	// Ingredients contains values of the ingredients of this event
	Ingredients map[string]string
	// Meta contains metadata of this event
	Meta TriggerEventMeta
}

type TriggerEventCollection []TriggerEvent

type TriggerEventMeta struct {
	// ID should be a unique string identifier to an event, events with different IDs would be considered different events
	ID string
	// Time should be the creation or modification time of the resource that triggers the trigger
	// This field don't have to be constant, but the trigger will not be triggered if the time returned was earlier than the time the trigger was created
	Time time.Time
}

type TriggerPollRequest struct {
	// TriggerIdentity the identification string of the trigger
	TriggerIdentity string
	// TriggerFields the values of the trigger fields
	TriggerFields map[string]string
	// Limit max number of events requested, you can return a little more but extra events will be ignored
	Limit int
	// User contains the metadata of the IFTTT user (eg: timezone)
	User map[string]string
}

type UserInfo struct {
	Name string
	ID   string
	URL  string
}