interfaces

type ACLPermissionChecker interface {
	CheckPermission(ctx context.Context, userID string, permissionCode string) (role string, err error)
}

type BasicAuthValidator interface {
	ValidateBasic(ctx context.Context, username, password string) error
}

type Broker interface {
	GetPublisher() Publisher
	GetName() types.Worker
	Health() map[string]error
	Closer
}

type Cache interface {
	Get(ctx context.Context, key string) ([]byte, error)
	GetKeys(ctx context.Context, pattern string) ([]string, error)
	GetTTL(ctx context.Context, key string) (time.Duration, error)
	Set(ctx context.Context, key string, value any, expire time.Duration) error
	Exists(ctx context.Context, key string) (bool, error)
	Delete(ctx context.Context, key string) error
	DoCommand(ctx context.Context, isWrite bool, command string, args ...any) (reply any, err error)
}

type Closer interface {
	Disconnect(ctx context.Context) error
}

type GRPCHandler interface {
	Register(server *grpc.Server, middlewareGroup *types.MiddlewareGroup)
}

type GRPCMiddleware interface {
	GRPCBasicAuth(ctx context.Context) (context.Context, error)
	GRPCBearerAuth(ctx context.Context) (context.Context, error)
	GRPCMultipleAuth(ctx context.Context) (context.Context, error)

	// GRPCPermissionACL method.
	// This middleware required TokenValidator (GRPCBearerAuth middleware must executed before) for extract userID
	// default from `Subject` field in token claim payload
	// or you can custom extract user id with `SetUserIDExtractor` option when construct middleware in configs
	GRPCPermissionACL(permissionCode string) types.MiddlewareFunc
}

type GraphQLHandler interface {
	Query() any
	Mutation() any
	Subscription() any
	Schema() string
}

type GraphQLMiddleware interface {
	GraphQLAuth(ctx context.Context, directive *gqltypes.Directive, input any) (context.Context, error)

	// GraphQLPermissionACL method.
	// This middleware required TokenValidator (GraphQLAuth middleware with BEARER must executed before) for extract userID
	// default from `Subject` field in token claim payload
	// or you can custom extract user id with `SetUserIDExtractor` option when construct middleware in configs
	GraphQLPermissionACL(ctx context.Context, directive *gqltypes.Directive, input any) (context.Context, error)
}

type HTTPMiddleware interface {
	HTTPBasicAuth(next http.Handler) http.Handler
	HTTPBearerAuth(next http.Handler) http.Handler
	HTTPMultipleAuth(next http.Handler) http.Handler
	HTTPCache(next http.Handler) http.Handler

	// HTTPPermissionACL method.
	// This middleware required TokenValidator (HTTPBearerAuth middleware must executed before) for extract userID
	// default from `Subject` field in token claim payload
	// or you can custom extract user id with `SetUserIDExtractor` option when construct middleware in configs
	HTTPPermissionACL(permissionCode string) func(http.Handler) http.Handler
}

type Locker interface {
	IsLocked(key string) bool
	IsLockedTTL(key string, ttl time.Duration) bool
	HasBeenLocked(key string) bool
	Unlock(key string)
	Reset(key string)
	Lock(key string, timeout time.Duration) (unlockFunc func(), err error)
	GetPrefixLocker() string
	GetTTLLocker() time.Duration
	Closer
}

type Middleware interface {
	Basic(ctx context.Context, authKey string) error
	Bearer(ctx context.Context, token string) (*candishared.TokenClaim, error)

	HTTPMiddleware
	GRPCMiddleware
	GraphQLMiddleware
}

type MongoDatabase interface {
	ReadDB() *mongo.Database
	WriteDB() *mongo.Database
	Health() map[string]error
	Closer
}

type Publisher interface {
	PublishMessage(ctx context.Context, args *candishared.PublisherArgument) (err error)
}

type RESTHandler interface {
	Mount(group RESTRouter)
}

type RESTRouter interface {
	Use(middlewares ...func(http.Handler) http.Handler)
	Group(pattern string, middlewares ...func(http.Handler) http.Handler) RESTRouter
	HandleFunc(pattern string, h http.HandlerFunc, middlewares ...func(http.Handler) http.Handler)
	CONNECT(pattern string, h http.HandlerFunc, middlewares ...func(http.Handler) http.Handler)
	DELETE(pattern string, h http.HandlerFunc, middlewares ...func(http.Handler) http.Handler)
	GET(pattern string, h http.HandlerFunc, middlewares ...func(http.Handler) http.Handler)
	HEAD(pattern string, h http.HandlerFunc, middlewares ...func(http.Handler) http.Handler)
	OPTIONS(pattern string, h http.HandlerFunc, middlewares ...func(http.Handler) http.Handler)
	PATCH(pattern string, h http.HandlerFunc, middlewares ...func(http.Handler) http.Handler)
	POST(pattern string, h http.HandlerFunc, middlewares ...func(http.Handler) http.Handler)
	PUT(pattern string, h http.HandlerFunc, middlewares ...func(http.Handler) http.Handler)
	TRACE(pattern string, h http.HandlerFunc, middlewares ...func(http.Handler) http.Handler)
}

type RSAKey interface {
	PrivateKey() *rsa.PrivateKey
	PublicKey() *rsa.PublicKey
}

type RedisPool interface {
	ReadPool() *redis.Pool
	WritePool() *redis.Pool
	Health() map[string]error
	Cache() Cache
	Closer
}

type SQLDatabase interface {
	ReadDB() *sql.DB
	WriteDB() *sql.DB
	Health() map[string]error
	Closer
}

type ServerHandler interface {
	MountHandlers(group any) // why interface? cause every server is different type for grouping route handler
}

type TokenValidator interface {
	ValidateToken(ctx context.Context, token string) (*candishared.TokenClaim, error)
}

type Validator interface {
	// ValidateDocument method using jsonschema with input is json source
	ValidateDocument(reference string, document any) error

	// ValidateStruct method, rules from struct tag using github.com/go-playground/validator
	ValidateStruct(data any) error
}

type WorkerHandler interface {
	MountHandlers(group *types.WorkerHandlerGroup)
}