package api

import (
	"errors"
	"net/url"

	"github.com/cenkalti/backoff/v4"
)

// ErrNotAvailable indicates that a feature is not available
var ErrNotAvailable = backoff.Permanent(errNotAvailable{})

type errNotAvailable struct{}

func (errNotAvailable) Error() string { return "not available" }

// Is matches ErrNotAvailable. Backoff strips the permanent wrapper, hence the
// unwrapped error must match the wrapped sentinel, too.
func (errNotAvailable) Is(target error) bool { return target == ErrNotAvailable }

// ErrUnsupportedPlatform indicates unsupported hardware platform
var ErrUnsupportedPlatform = backoff.Permanent(errUnsupportedPlatform{})

type errUnsupportedPlatform struct{}

func (errUnsupportedPlatform) Error() string { return "unsupported platform" }

// Is matches ErrUnsupportedPlatform. Backoff strips the permanent wrapper, hence
// the unwrapped error must match the wrapped sentinel, too.
func (errUnsupportedPlatform) Is(target error) bool { return target == ErrUnsupportedPlatform }

// ErrMustRetry indicates that a rate-limited operation should be retried
var ErrMustRetry = errors.New("must retry")

// ErrSponsorRequired indicates that a sponsor token is required
var ErrSponsorRequired = errors.New("sponsorship required, see https://docs.evcc.io/docs/sponsorship")

// ErrMissingCredentials indicates that user/password are missing
var ErrMissingCredentials = backoff.Permanent(errMissingCredentials{})

type errMissingCredentials struct{}

func (errMissingCredentials) Error() string { return "missing user/password credentials" }

// Is matches ErrMissingCredentials. Backoff strips the permanent wrapper, hence
// the unwrapped error must match the wrapped sentinel, too.
func (errMissingCredentials) Is(target error) bool { return target == ErrMissingCredentials }

// ErrMissingToken indicates that access/refresh tokens are missing
var ErrMissingToken = backoff.Permanent(errMissingToken{})

type errMissingToken struct{}

func (errMissingToken) Error() string { return "missing token credentials" }

// Is matches ErrMissingToken. Backoff strips the permanent wrapper, hence the
// unwrapped error must match the wrapped sentinel, too.
func (errMissingToken) Is(target error) bool { return target == ErrMissingToken }

// ErrOutdated indicates that result is outdated
var ErrOutdated = errors.New("outdated")

// ErrTimeout is the error returned when a timeout happened
var ErrTimeout = errors.New("timeout")

// LoginRequiredError creates a login error for given auth provider
func LoginRequiredError(providerAuth string) error {
	return backoff.Permanent(&ErrLoginRequired{
		ProviderAuth: providerAuth,
	})
}

// ErrLoginRequired indicates that retrieving tokens credentials waits for login
type ErrLoginRequired struct {
	ProviderAuth string
}

func (err *ErrLoginRequired) Error() string {
	return "login required"
}

// ErrUrl indicates that the error contains an extractable URL
type ErrUrl struct {
	err string
	url *url.URL
}

// UrlError creates an error message containing an url
func UrlError(err string, url *url.URL) *ErrUrl {
	return &ErrUrl{err, url}
}

func (err *ErrUrl) Error() string {
	return err.err
}

func (err *ErrUrl) URL() *url.URL {
	return err.url
}

// ErrAsleep indicates that vehicle is asleep. Caller may chose to wake up the vehicle and retry.
var ErrAsleep error = errAsleep{}

type errAsleep struct{}

func (errAsleep) Error() string { return "asleep" }
func (errAsleep) Unwrap() error { return ErrTimeout }