profiledb

type AuthenticationFailedError struct {
	Message string
}

type BadRequestError struct {
	Message string
}

type Config struct {
	// Logger is used for logging the operation of profile database.  It must
	// not be nil.
	Logger *slog.Logger

	// BaseCustomLogger is the base logger used for the custom filters.  It must
	// not be nil.
	BaseCustomLogger *slog.Logger

	// ProfileAccessConstructor is used to create access managers for profiles.
	// It must not be nil.
	ProfileAccessConstructor *access.ProfileConstructor

	// Clock is used to get current time during refreshes.  It must not be nil.
	Clock timeutil.Clock

	// CustomDomainDB is used to keep track of the data about custom domains and
	// their certificates.  It must not be nil.
	CustomDomainDB CustomDomainDB

	// ErrColl is used to collect errors during refreshes.  It must not be nil.
	ErrColl errcoll.Interface

	// ProfileMetrics is used for the collection of the profile access engine
	// statistics.  It must not be nil.
	ProfileMetrics access.ProfileMetrics

	// Metrics is used for the collection of the user profiles statistics.  It
	// must not be nil.
	Metrics Metrics

	// Storage returns the data for this profile DB.  It must not be nil.
	Storage Storage

	// CacheFilePath is the path to the profile cache file.  If cacheFilePath is
	// the string "none", filesystem cache is disabled.  It must not be empty.
	CacheFilePath string

	// CacheFileIvl is the interval between updates of the profile cache file.
	// It must be positive if filesystem cache is enabled, see CacheFilePath.
	CacheFileIvl time.Duration

	// FullSyncIvl is the interval between two full synchronizations with the
	// storage.  It must be positive.
	FullSyncIvl time.Duration

	// FullSyncRetryIvl is the interval between two retries of full
	// synchronizations with the storage.  It must be positive.
	FullSyncRetryIvl time.Duration

	// ResponseSizeEstimate is the estimate of the size of one DNS response for
	// the purposes of custom ratelimiting.  Responses over this estimate are
	// counted as several responses.  It must be positive.
	ResponseSizeEstimate datasize.ByteSize

	// Opaque determines whether the profile cache will use the protobuf opaque
	// API.
	Opaque bool
}

type CustomDomainDB interface {
	// AddCertificate adds information about a current certificate.  domains
	// must contain only valid domain names and wildcards like
	// "*.domain.example".  s must not be nil and must be valid.
	AddCertificate(
		ctx context.Context,
		profID agd.ProfileID,
		domains []string,
		state *agd.CustomDomainStateCurrent,
	)

	// DeleteAllWellKnownPaths removes all data about well-known paths for
	// certificate validation.
	DeleteAllWellKnownPaths(ctx context.Context)

	// SetWellKnownPath adds a well-known path for certificate validation to the
	// database and sets the expiration time.  s must not be nil and must be
	// valid.
	SetWellKnownPath(ctx context.Context, s *agd.CustomDomainStatePending)
}

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

type DeviceQuotaExceededError struct {
	Message string
}

type Disabled struct{}

type EmptyCustomDomainDB struct{}

type EmptyMetrics struct{}

type Interface interface {
	// CreateAutoDevice creates a new automatic device for the given profile
	// with the given human-readable device ID and device type.  All arguments
	// must be valid.
	CreateAutoDevice(
		ctx context.Context,
		id agd.ProfileID,
		humanID agd.HumanID,
		devType agd.DeviceType,
	) (p *agd.Profile, d *agd.Device, err error)

	// ProfileByDedicatedIP returns the profile and the device identified by its
	// dedicated DNS server IP address.  ip must be valid.
	ProfileByDedicatedIP(
		ctx context.Context,
		ip netip.Addr,
	) (p *agd.Profile, d *agd.Device, err error)

	// ProfileByDeviceID returns the profile and the device identified by id.
	// id must be valid.
	ProfileByDeviceID(
		ctx context.Context,
		id agd.DeviceID,
	) (p *agd.Profile, d *agd.Device, err error)

	// ProfileByHumanID returns the profile and the device identified by the
	// profile ID and the lowercase version of the human-readable device ID.
	// id and humanIDLower must be valid.
	ProfileByHumanID(
		ctx context.Context,
		id agd.ProfileID,
		humanIDLower agd.HumanIDLower,
	) (p *agd.Profile, d *agd.Device, err error)

	// ProfileByLinkedIP returns the profile and the device identified by its
	// linked IP address.  ip must be valid.
	ProfileByLinkedIP(ctx context.Context, ip netip.Addr) (p *agd.Profile, d *agd.Device, err error)
}

type Metrics interface {
	// HandleProfilesUpdate handles the user profile update.  m must not be nil.
	HandleProfilesUpdate(ctx context.Context, m *UpdateMetrics)

	// SetProfilesAndDevicesNum sets the total number of user profiles and the
	// total number of devices.
	SetProfilesAndDevicesNum(ctx context.Context, profNum, devNum uint)

	// IncrementSyncTimeouts increments the total number of timeout errors
	// during user profile update.
	IncrementSyncTimeouts(ctx context.Context, isFullSync bool)

	// IncrementDeleted increments the total number of deleted user profiles.
	IncrementDeleted(ctx context.Context)

	// SetLastFileCacheSyncTime sets the time of the last successful cache file
	// synchronization.
	SetLastFileCacheSyncTime(ctx context.Context, t time.Time)

	// SetFileCacheSize sets the size of the cache file.
	SetFileCacheSize(ctx context.Context, size datasize.ByteSize)

	// ObserveFileCacheStoreDuration observes the duration of storing file cache
	// to disk.
	ObserveFileCacheStoreDuration(ctx context.Context, d time.Duration)
}

type RateLimitedError struct {
	// Message is the error message from the storage.
	Message string

	// RetryDelay is the hint to use for when to retry the request.
	//
	// TODO(a.garipov):  Use in [Default.Refresh].
	RetryDelay time.Duration
}

type Storage interface {
	// CreateAutoDevice creates an auto device based on the given data.
	// req must not be nil.
	CreateAutoDevice(
		ctx context.Context,
		req *StorageCreateAutoDeviceRequest,
	) (resp *StorageCreateAutoDeviceResponse, err error)

	// Profiles returns profile and device data that has changed since
	// req.SyncTime.  req must not be nil.
	Profiles(
		ctx context.Context,
		req *StorageProfilesRequest,
	) (resp *StorageProfilesResponse, err error)
}

type StorageCreateAutoDeviceRequest struct {
	ProfileID  agd.ProfileID
	HumanID    agd.HumanID
	DeviceType agd.DeviceType
}

type StorageCreateAutoDeviceResponse struct {
	// Device is the resulting device.  If the error returned with this response
	// is nil, Device is never nil.
	Device *agd.Device
}

type StorageDeviceChange struct {
	// DeletedDeviceIDs are the IDs of devices deleted during a partial update
	// of a profile.
	DeletedDeviceIDs []agd.DeviceID

	// IsPartial is true when the profile has been updated partially.
	IsPartial bool
}

type StorageProfilesRequest struct {
	// SyncTime is the last time profiles were synced.
	SyncTime time.Time
}

type StorageProfilesResponse struct {
	// SyncTime is the time that should be saved and used as the next
	// [ProfilesRequest.SyncTime].
	SyncTime time.Time

	// DeviceChanges defines the device changes committed in this response.
	//
	// TODO(a.garipov):  This is currently rather badly designed.  Find ways of
	// making this less awkward.
	DeviceChanges map[agd.ProfileID]*StorageDeviceChange

	// Profiles are the profiles data from the [Storage].
	Profiles []*agd.Profile

	// Devices are the device data from the [Storage].
	Devices []*agd.Device
}

type UpdateMetrics = struct {
	// Duration is the duration of the user profiles update operation.
	Duration time.Duration

	// ProfilesNum is the total number of updated profiles.
	ProfilesNum uint

	// DevicesNum is the total number of updated devices.
	DevicesNum uint

	// IsSuccess indicates whether the update was successful.
	IsSuccess bool

	// IsFullSync indicates whether the update was full or partial.
	IsFullSync bool
}