stdlib

type AbstractCacheRepository[V any] interface {

	// Get retrieves a value by its key from the cache.
	// If the value is a struct, it will be deserialized from JSON.
	// Returns a pointer to the value or nil if the key does not exist.
	Get(key string) (valueModel *V, err error)

	// GetKeysByPatterns retrieves keys by a pattern from the cache.
	// Returns a slice of keys that match the pattern.
	GetKeysByPatterns(pattern string) (keys []string, err error)

	// Set stores a value in the cache with the specified expiration time.
	// If the value is a struct, it will be serialized to JSON.
	// Returns an error if the operation fails.
	Set(key string, value V, expiration time.Duration) error

	// Del deletes a value from the cache by its key.
	// Returns an error if the operation fails.
	Del(key string) error

	// Exists checks if a key exists in the cache.
	// Returns true if the key exists, false otherwise.
	Exists(key string) (bool, error)

	// HGet retrieves a single field value from a hash in Redis.
	// The method returns the value associated with the specified field
	// and nil if the field does not exist or an error occurs.
	HGet(key string, field string) (*any, error)

	// HGetAll retrieves all fields and their associated values from a hash in Redis.
	// The method returns a map of field names to values or an error if the operation fails.
	HGetAll(key string) (map[string]any, error)

	// HScan iterates over fields in a hash by a pattern.
	// Returns the matching fields and their values.
	HScan(key string, pattern string, count int64) (map[string]string, error)

	// HGetFields retrieves specific fields and their associated values from a hash in Redis.
	// The method returns a map of the requested field names to their values.
	// Fields not found in the hash are excluded from the returned map.
	HGetFields(key string, fields ...string) (map[string]any, error)

	// HSet sets a single field in a hash in Redis.
	// This method stores the specified value under the given field name,
	// overwriting any existing value.
	HSet(key string, field string, value any) error

	// HMSet sets multiple fields in a hash in Redis.
	HMSet(key string, fields map[string]any) error

	// HDel deletes a specific field from a hash in Redis.
	// This method removes the field and its value, returning an error if the operation fails.
	HDel(key string, field string) error

	// HExists checks if a specific field exists in a hash in Redis.
	// The method returns true if the field exists, false otherwise.
	HExists(key string, field string) (bool, error)
}

type AbstractRepository[T Identifiable[K], K ID] interface {

	// FindAll retrieves all entities of type T from the database.
	FindAll() ([]T, error)

	// FindByID retrieves a single entity of type T by its ID.
	FindByID(id K) (T, error)

	// FirstByKey retrieves a single entity of type T by a specific field (key),thats mean
	// only the first Match!
	// The `key` parameter specifies the field to search, and `value` is the value to match.
	//
	// if you want to find all use:
	//	 FindAllByKey(key, value)
	FirstByKey(key, value string) (T, error)

	// FindAllByKey retrieves all entities of type T by a specific field (key)
	// The `key` parameter specifies the field to search, and `value` is the value to match.
	FindAllByKey(key, value string) ([]T, error)

	// Create inserts a new entity of type T into the database and returns its ID.
	// The operation can optionally be executed within a transaction.
	Create(tx *gorm.DB, newEntity T) (T, error)

	// Update modifies an existing entity of type T identified by its ID.
	// The operation can optionally be executed within a transaction.
	Update(tx *gorm.DB, id K, newEntity T) error

	// Delete marks an entity of type T as deleted (soft delete) by its ID.
	// The operation can optionally be executed within a transaction.
	Delete(tx *gorm.DB, id K) error

	// Restore unmarks an entity of type T as deleted (restore) by its ID.
	// The operation can optionally be executed within a transaction.
	Restore(tx *gorm.DB, id K) error

	// GetPreloads returns the default preloads for the repository.
	// 	This need to be overriden by the concrete implementation!!
	// by default is nil
	GetPreloads() []string

	// GetType returns the types defined of the repository.
	GetType() string

	// transactionCheck if is within a transactional context to use the
	// transaction or use the current repository
	TransactionCheck(tx *gorm.DB) *gorm.DB
}

type Conn struct {
	Gorm *gorm.DB
}

type Connection interface {
	Connect(cfg StdLibConfiguration) (Conn, error)
}

type DBWrapper struct {
	Gorm *gorm.DB
}

type ID interface {
	uint | uuid.UUID
}

type Identifiable[K ID] interface {
	GetID() K
}

type MariaDBConnection struct{}

type PostgresConnection struct{}

type StandardError struct {
	ErrorMessage string `json:"error" example:"An error occurred - some context"`
}

type StandardResponse struct {
	Message string      `json:"message" example:"info message"`
	Data    interface{} `json:"data"`
}

type StdLibConfiguration struct {
	DBHost     string
	DBUser     string
	DBPassword string
	DBDatabase string
	DBPort     int
	DBSSLMode  string

	RedisHost     string
	RedisPort     int
	RedisPassword string
	RedisDB       int

	DevMode bool
}

type TransactionalRepository interface {

	// BeginTransaction initializes a transaction by returning the transaction context or a possible error
	BeginTransaction() (*gorm.DB, error)

	// CommitTransaction commits a transaction, returning a possible error
	CommitTransaction(tx *gorm.DB) error
	// RollbackTransaction rolls back a transaction leaving changes uncommitted
	RollbackTransaction(tx *gorm.DB) error

	// ExecuteInTransaction executes a function within a transaction context, logging whether there is a possible error
	ExecuteInTransaction(fn func(tx *gorm.DB) error) error
}

type ValidatorError struct {
	ErrorMessage string            `json:"error"  example:"Validation failed"`
	Fields       map[string]string `json:"fields" example:"{'username': 'Username is required'}"`
}