domain

type Agent struct {
	BaseEntity

	Name string `json:"name" gorm:"not null"`

	// Status management
	Status           AgentStatus `json:"status" gorm:"not null"`
	LastStatusUpdate time.Time   `json:"lastStatusUpdate" gorm:"index"`

	// Tags representing capabilities or certifications of this agent
	Tags pq.StringArray `json:"tags" gorm:"type:text[]"`

	// Relationships
	AgentTypeID properties.UUID `json:"agentTypeId" gorm:"not null"`
	AgentType   *AgentType      `json:"agentType,omitempty" gorm:"foreignKey:AgentTypeID"`
	ProviderID  properties.UUID `json:"providerId" gorm:"not null"`
	Provider    *Participant    `json:"-" gorm:"foreignKey:ProviderID"`
}

type AgentCommander interface {
	// Create creates a new agent
	Create(ctx context.Context, name string, providerID properties.UUID, agentTypeID properties.UUID, tags []string) (*Agent, error)

	// Update updates an agent
	Update(ctx context.Context, id properties.UUID, name *string, status *AgentStatus, tags *[]string) (*Agent, error)

	// Delete removes an agent by ID after checking for dependencies
	Delete(ctx context.Context, id properties.UUID) error

	// UpdateStatus updates the agent status and the related timestamp
	UpdateStatus(ctx context.Context, id properties.UUID, status AgentStatus) (*Agent, error)
}

type AgentQuerier interface {
	BaseEntityQuerier[Agent]

	// CountByProvider returns the number of agents for a specific provider
	CountByProvider(ctx context.Context, providerID properties.UUID) (int64, error)

	// FindByServiceTypeAndTags finds agents that support a service type and have all required tags
	FindByServiceTypeAndTags(ctx context.Context, serviceTypeID properties.UUID, tags []string) ([]*Agent, error)
}

type AgentRepository interface {
	AgentQuerier
	BaseEntityRepository[Agent]

	// MarkInactiveAgentsAsDisconnected marks agents that haven't updated their status in the given duration as disconnected
	MarkInactiveAgentsAsDisconnected(ctx context.Context, inactiveDuration time.Duration) (int64, error)
}

type AgentStatus string

type AgentType struct {
	BaseEntity
	Name         string        `json:"name" gorm:"not null;unique"`
	ServiceTypes []ServiceType `json:"-" gorm:"many2many:agent_type_service_types;"`
}

type AgentTypeQuerier interface {
	BaseEntityQuerier[AgentType]
}

type AgentTypeRepository interface {
	AgentTypeQuerier
	BaseEntityRepository[AgentType]
}

type AggregateType string

type BaseEntity struct {
	ID        properties.UUID `json:"id" gorm:"type:uuid;primary_key;default:gen_random_uuid()"`
	CreatedAt time.Time       `json:"-" gorm:"not null;default:CURRENT_TIMESTAMP"`
	UpdatedAt time.Time       `json:"-" gorm:"not null;default:CURRENT_TIMESTAMP"`
}

type BaseEntityQuerier[T Entity] interface {

	// Get retrieves an entity by ID
	Get(ctx context.Context, id properties.UUID) (*T, error)

	// Exists checks if an entity with the given ID exists
	Exists(ctx context.Context, id properties.UUID) (bool, error)

	// List retrieves a list of entities based on the provided filters
	List(ctx context.Context, scope *auth.IdentityScope, req *PageReq) (*PageRes[T], error)

	// Count returns the number of entities
	Count(ctx context.Context) (int64, error)

	// AuthScope returns the authorization scope for the entity
	AuthScope(ctx context.Context, id properties.UUID) (auth.ObjectScope, error)
}

type BaseEntityRepository[T Entity] interface {
	BaseEntityQuerier[T]

	// Create creates a new entity
	Create(ctx context.Context, entity *T) error

	// Save updates an existing entity
	Save(ctx context.Context, entity *T) error

	// Delete removes an entity by ID
	Delete(ctx context.Context, id properties.UUID) error
}

type Entity interface {
	GetID() properties.UUID
}

type Event struct {
	BaseEntity

	// For strict ordering of events
	SequenceNumber int64 `json:"sequenceNumber" gorm:"autoIncrement;uniqueIndex;not null"`

	InitiatorType InitiatorType `gorm:"not null"`
	InitiatorID   string        `gorm:"not null"`

	Type    EventType       `gorm:"not null"`
	Payload properties.JSON `gorm:"type:jsonb"`

	// Target entity ID for the event
	EntityID *properties.UUID `gorm:"index"`

	// Optional IDs for related entities and filtering
	ParticipantID *properties.UUID `gorm:"type:uuid"`
	ProviderID    *properties.UUID `gorm:"type:uuid"`
	AgentID       *properties.UUID `gorm:"type:uuid"`
	ConsumerID    *properties.UUID `gorm:"type:uuid"`
}

type EventOption func(*Event) error

type EventQuerier interface {
	BaseEntityQuerier[Event]

	// ListFromSequence retrieves events starting from a specific sequence number
	ListFromSequence(ctx context.Context, fromSequenceNumber int64, limit int) ([]*Event, error)

	// ServiceUptime returns the uptime and downtime in seconds of a service in a time range
	ServiceUptime(ctx context.Context, serviceID properties.UUID, start time.Time, end time.Time) (uptimeSeconds uint64, downtimeSeconds uint64, err error)
}

type EventRepository interface {
	BaseEntityRepository[Event]
	EventQuerier

	// Create stores a new event
	Create(ctx context.Context, entry *Event) error
}

type EventSubscription struct {
	BaseEntity

	SubscriberID               string     `json:"subscriber_id" gorm:"not null;uniqueIndex"`
	LastEventSequenceProcessed int64      `json:"last_event_sequence_processed" gorm:"not null;default:0"`
	LeaseOwnerInstanceID       *string    `json:"lease_owner_instance_id,omitempty" gorm:"index"`
	LeaseAcquiredAt            *time.Time `json:"lease_acquired_at,omitempty"`
	LeaseExpiresAt             *time.Time `json:"lease_expires_at,omitempty" gorm:"index"`
	IsActive                   bool       `json:"is_active" gorm:"not null;default:true"`
}

type EventSubscriptionCommander interface {
	// UpdateProgress updates the last event sequence processed
	UpdateProgress(ctx context.Context, subscriberID string, lastEventSequenceProcessed int64) (*EventSubscription, error)

	// AcquireLease attempts to acquire a lease for processing events
	AcquireLease(ctx context.Context, subscriberID string, instanceID string, duration time.Duration) (*EventSubscription, error)

	// RenewLease renews an existing lease
	RenewLease(ctx context.Context, subscriberID string, instanceID string, duration time.Duration) (*EventSubscription, error)

	// ReleaseLease releases the lease for the subscription
	ReleaseLease(ctx context.Context, subscriberID string, instanceID string) (*EventSubscription, error)

	// AcknowledgeEvents acknowledges processed events by updating progress, but only if the instance holds a valid lease
	AcknowledgeEvents(ctx context.Context, subscriberID string, instanceID string, lastEventSequenceProcessed int64) (*EventSubscription, error)

	// SetActive sets the active status of the subscription
	SetActive(ctx context.Context, subscriberID string, isActive bool) (*EventSubscription, error)

	// Delete removes an event subscription
	Delete(ctx context.Context, subscriberID string) error
}

type EventSubscriptionQuerier interface {
	BaseEntityRepository[EventSubscription]

	// FindBySubscriberID retrieves an entity by subscriber ID
	FindBySubscriberID(ctx context.Context, subscriberID string) (*EventSubscription, error)

	// ExistsBySubscriberID checks if an entity with the given subscriber ID exists
	ExistsBySubscriberID(ctx context.Context, subscriberID string) (bool, error)

	// ListExpiredLeases retrieves subscriptions with expired leases
	ListExpiredLeases(ctx context.Context) ([]*EventSubscription, error)
}

type EventSubscriptionRepository interface {
	EventSubscriptionQuerier
	BaseEntityRepository[EventSubscription]

	// DeleteBySubscriberID removes an entity by subscriber ID
	DeleteBySubscriberID(ctx context.Context, subscriberID string) error
}

type EventType string

type InitiatorType string

type InvalidInputError struct {
	Err error
}

type Job struct {
	BaseEntity

	Action   ServiceAction `gorm:"type:varchar(50);not null"`
	Priority int           `gorm:"not null;default:1"`

	// Status management
	Status       JobStatus  `gorm:"type:varchar(20);not null"`
	ErrorMessage string     `gorm:"type:text"`
	ClaimedAt    *time.Time `gorm:""`
	CompletedAt  *time.Time `gorm:""`

	// Relationships
	AgentID    properties.UUID `gorm:"not null"`
	Agent      *Agent          `gorm:"foreignKey:AgentID"`
	ServiceID  properties.UUID `gorm:"not null"`
	Service    *Service        `gorm:"foreignKey:ServiceID"`
	ProviderID properties.UUID `gorm:"not null"`
	Provider   *Participant    `gorm:"foreignKey:ProviderID"`
	ConsumerID properties.UUID `gorm:"not null"`
	Consumer   *Participant    `gorm:"foreignKey:ConsumerID"`
}

type JobCommander interface {
	// Claim claims a job for an agent
	Claim(ctx context.Context, jobID properties.UUID) error

	// Complete marks a job as completed
	Complete(ctx context.Context, jobID properties.UUID, resources *properties.JSON, externalID *string) error

	// Fail marks a job as failed
	Fail(ctx context.Context, jobID properties.UUID, errorMessage string) error
}

type JobQuerier interface {
	BaseEntityQuerier[Job]

	// GetPendingJobsForAgent retrieves pending jobs targeted for a specific agent
	GetPendingJobsForAgent(ctx context.Context, agentID properties.UUID, limit int) ([]*Job, error)

	// GetTimeOutJobs retrieves jobs that have been processing for too long and returns them
	GetTimeOutJobs(ctx context.Context, olderThan time.Duration) ([]*Job, error)
}

type JobRepository interface {
	JobQuerier
	BaseEntityRepository[Job]

	// DeleteOldCompletedJobs removes completed or failed jobs older than the specified interval
	DeleteOldCompletedJobs(ctx context.Context, olderThan time.Duration) (int, error)
}

type JobStatus string

type MetricEntityType string

type MetricEntry struct {
	// Base entity fields
	ID        properties.UUID `json:"id" gorm:"type:uuid;primary_key"`
	CreatedAt time.Time       `json:"-" gorm:"not null;default:CURRENT_TIMESTAMP;index:idx_metric_aggregate,priority:3"`
	UpdatedAt time.Time       `json:"-" gorm:"not null;default:CURRENT_TIMESTAMP"`

	ResourceID string  `gorm:"not null"`
	Value      float64 `gorm:"not null"`

	// Relationships
	TypeID     properties.UUID `gorm:"not null;index:idx_metric_aggregate,priority:2"`
	Type       *MetricType     `gorm:"foreignKey:TypeID"`
	AgentID    properties.UUID `gorm:"not null"`
	Agent      *Agent          `gorm:"foreignKey:AgentID"`
	ServiceID  properties.UUID `gorm:"not null;index:idx_metric_aggregate,priority:1"`
	Service    *Service        `gorm:"foreignKey:ServiceID"`
	ProviderID properties.UUID `gorm:"not null"`
	Provider   *Participant    `gorm:"foreignKey:ProviderID"`
	ConsumerID properties.UUID `gorm:"not null"`
	Consumer   *Participant    `gorm:"foreignKey:ConsumerID"`
}

type MetricEntryCommander interface {
	// Create creates a new metric entry
	Create(ctx context.Context, typeName string, agentID properties.UUID, serviceID properties.UUID, resourceID string, value float64) (*MetricEntry, error)

	// CreateWithExternalID creates a new metric entry using service's external ID
	CreateWithExternalID(ctx context.Context, typeName string, agentID properties.UUID, externalID string, resourceID string, value float64) (*MetricEntry, error)
}

type MetricEntryQuerier interface {
	BaseEntityQuerier[MetricEntry]

	// CountByMetricType counts the number of entries for a specific metric type
	CountByMetricType(ctx context.Context, typeID properties.UUID) (int64, error)

	// Aggregate performs aggregation operations on metric entries for a specific metric type and service within a time range
	Aggregate(ctx context.Context, aggregateType AggregateType, serviceID properties.UUID, typeID properties.UUID, start time.Time, end time.Time) (float64, error)
}

type MetricEntryRepository interface {
	MetricEntryQuerier
	BaseEntityRepository[MetricEntry]
}

type MetricType struct {
	BaseEntity
	Name       string           `json:"name" gorm:"not null;unique"`
	EntityType MetricEntityType `json:"entityType" gorm:"not null"`
}

type MetricTypeCommander interface {
	// Create creates a new metric-type
	Create(ctx context.Context, name string, kind MetricEntityType) (*MetricType, error)

	// Update updates a metric-type
	Update(ctx context.Context, id properties.UUID, name *string) (*MetricType, error)

	// Delete removes a metric-type by ID after checking for dependencies
	Delete(ctx context.Context, id properties.UUID) error
}

type MetricTypeQuerier interface {
	BaseEntityQuerier[MetricType]

	// FindByName retrieves a metric type by name
	FindByName(ctx context.Context, name string) (*MetricType, error)
}

type MetricTypeRepository interface {
	MetricTypeQuerier
	BaseEntityRepository[MetricType]
}

type NotFoundError struct {
	Err error
}

type PageReq struct {
	Filters  map[string][]string // Filters to be applied
	Sort     bool                // Should sort
	SortBy   string              // Field to sort by
	SortAsc  bool                // Sort dir
	Page     int                 // Current page number
	PageSize int                 // Number of items per page
}

type PageRes[T any] struct {
	Items       []T
	TotalItems  int64
	TotalPages  int
	CurrentPage int
	HasNext     bool
	HasPrev     bool
}

type Participant struct {
	BaseEntity

	Name   string            `json:"name" gorm:"not null"`
	Status ParticipantStatus `json:"status" gorm:"not null"`

	// Relationships
	Agents []Agent `json:"agents,omitempty" gorm:"foreignKey:ProviderID"` // Agent struct will be updated later
}

type ParticipantCommander interface {
	// Create creates a new participant
	Create(ctx context.Context, name string, status ParticipantStatus) (*Participant, error)

	// Update updates a participant
	Update(ctx context.Context, id properties.UUID, name *string, status *ParticipantStatus) (*Participant, error)

	// Delete removes a participant by ID after checking for dependencies
	Delete(ctx context.Context, id properties.UUID) error
}

type ParticipantQuerier interface {
	BaseEntityQuerier[Participant]
}

type ParticipantRepository interface {
	ParticipantQuerier
	BaseEntityRepository[Participant]
}

type ParticipantStatus string

type Service struct {
	BaseEntity

	Name string `json:"name" gorm:"not null"`

	// Status management
	CurrentStatus     ServiceStatus    `json:"currentStatus" gorm:"not null"`
	TargetStatus      *ServiceStatus   `json:"targetStatus,omitempty"`
	ErrorMessage      *string          `json:"errorMessage,omitempty"`
	FailedAction      *ServiceAction   `json:"failedAction,omitempty"`
	RetryCount        int              `json:"retryCount"`
	CurrentProperties *properties.JSON `json:"currentProperties,omitempty" gorm:"type:jsonb"`
	TargetProperties  *properties.JSON `json:"targetProperties,omitempty" gorm:"type:jsonb"`

	// To store an external ID for the agent's use to facilitate metric reporting
	ExternalID *string `json:"externalId,omitempty" gorm:"uniqueIndex:service_external_id_uniq"`
	// Safe place for the Agent for store data
	Resources *properties.JSON `json:"resources,omitempty" gorm:"type:jsonb"`

	// Relationships
	ProviderID    properties.UUID `json:"providerId" gorm:"not null"`
	Provider      *Participant    `json:"-" gorm:"foreignKey:ProviderID"`
	ConsumerID    properties.UUID `json:"consumerId" gorm:"not null"`
	Consumer      *Participant    `json:"-" gorm:"foreignKey:ConsumerID"`
	GroupID       properties.UUID `gorm:"not null" json:"groupId"`
	Group         *ServiceGroup   `json:"-" gorm:"foreignKey:GroupID"`
	AgentID       properties.UUID `json:"agentId" gorm:"not null"`
	Agent         *Agent          `json:"-" gorm:"foreignKey:AgentID"`
	ServiceTypeID properties.UUID `json:"serviceTypeId" gorm:"not null"`
	ServiceType   *ServiceType    `json:"-" gorm:"foreignKey:ServiceTypeID"`
}

type ServiceAction string

type ServiceCommander interface {
	// Create handles service creation and creates a job for the agent
	Create(ctx context.Context, agentID properties.UUID, serviceTypeID properties.UUID, groupID properties.UUID, name string, properties properties.JSON) (*Service, error)

	// CreateWithTags handles service creation using agent discovery by tags
	CreateWithTags(ctx context.Context, serviceTypeID properties.UUID, groupID properties.UUID, name string, properties properties.JSON, serviceTags []string) (*Service, error)

	// Update handles service updates and creates a job for the agent
	Update(ctx context.Context, id properties.UUID, name *string, props *properties.JSON) (*Service, error)

	// Transition transitions a service to a new status
	Transition(ctx context.Context, id properties.UUID, target ServiceStatus) (*Service, error)

	// Retry retries a failed service operation
	Retry(ctx context.Context, id properties.UUID) (*Service, error)

	// FailTimeoutServicesAndJobs fails services and jobs that have timed out
	FailTimeoutServicesAndJobs(ctx context.Context, timeout time.Duration) (int, error)
}

type ServiceGroup struct {
	BaseEntity

	Name string `json:"name" gorm:"not null"`

	// Relationships
	Services    []Service       `json:"-" gorm:"foreignKey:GroupID"`
	ConsumerID  properties.UUID `json:"consumerId" gorm:"not null"`
	Participant *Participant    `json:"-" gorm:"foreignKey:ConsumerID"`
}

type ServiceGroupCommander interface {
	// Create creates a new service group
	Create(ctx context.Context, name string, consumerID properties.UUID) (*ServiceGroup, error)

	// Update updates an existing service group
	Update(ctx context.Context, id properties.UUID, name *string) (*ServiceGroup, error)

	// Delete removes a service group by ID after checking for dependencies
	Delete(ctx context.Context, id properties.UUID) error
}

type ServiceGroupQuerier interface {
	BaseEntityQuerier[ServiceGroup]
}

type ServiceGroupRepository interface {
	ServiceGroupQuerier
	BaseEntityRepository[ServiceGroup]
}

type ServiceQuerier interface {
	BaseEntityQuerier[Service]

	// FindByExternalID retrieves a service by its external ID and agent ID
	FindByExternalID(ctx context.Context, agentID properties.UUID, externalID string) (*Service, error)

	// CountByGroup returns the number of services in a specific group
	CountByGroup(ctx context.Context, groupID properties.UUID) (int64, error)

	// CountByAgent returns the number of services handled by a specific agent
	CountByAgent(ctx context.Context, agentID properties.UUID) (int64, error)
}

type ServiceRepository interface {
	ServiceQuerier
	BaseEntityRepository[Service]
}

type ServiceStatus string

type ServiceType struct {
	BaseEntity
	Name           string               `json:"name" gorm:"not null;unique"`
	PropertySchema *schema.CustomSchema `json:"propertySchema,omitempty" gorm:"type:jsonb"`
}

type ServiceTypeQuerier interface {
	BaseEntityQuerier[ServiceType]
}

type ServiceTypeRepository interface {
	ServiceTypeQuerier
	BaseEntityRepository[ServiceType]
}

type Store interface {
	// Atomic executes function in a transaction
	Atomic(context.Context, func(Store) error) error

	// Repositories
	AgentTypeRepo() AgentTypeRepository
	AgentRepo() AgentRepository
	TokenRepo() TokenRepository
	ServiceTypeRepo() ServiceTypeRepository
	ServiceGroupRepo() ServiceGroupRepository
	ServiceRepo() ServiceRepository
	JobRepo() JobRepository
	EventRepo() EventRepository
	EventSubscriptionRepo() EventSubscriptionRepository
	MetricTypeRepo() MetricTypeRepository
	MetricEntryRepo() MetricEntryRepository
	ParticipantRepo() ParticipantRepository
}

type Token struct {
	BaseEntity

	Name        string    `json:"name" gorm:"not null"`
	Role        auth.Role `json:"role" gorm:"not null"`
	PlainValue  string    `json:"-" gorm:"-"`
	HashedValue string    `json:"-" gorm:"not null"`
	ExpireAt    time.Time `json:"expireAt" gorm:"not null"`

	// Relationships
	ParticipantID *properties.UUID `json:"participantId,omitempty"`           // New field
	Participant   *Participant     `json:"-" gorm:"foreignKey:ParticipantID"` // New field
	AgentID       *properties.UUID `json:"agentId,omitempty"`
	Agent         *Agent           `json:"-" gorm:"foreignKey:AgentID"`
}

type TokenCommander interface {
	// Create creates a new token
	Create(ctx context.Context, name string, role auth.Role, expireAt *time.Time, scopeID *properties.UUID) (*Token, error)

	// Update updates a token
	Update(ctx context.Context, id properties.UUID, name *string, expireAt *time.Time) (*Token, error)

	// Delete removes a token by ID
	Delete(ctx context.Context, id properties.UUID) error

	// Regenerate regenerates the token value
	Regenerate(ctx context.Context, id properties.UUID) (*Token, error)
}

type TokenQuerier interface {
	BaseEntityQuerier[Token]

	// FindByHashedValue finds a token by its hashed value
	FindByHashedValue(ctx context.Context, hashedValue string) (*Token, error)
}

type TokenRepository interface {
	TokenQuerier
	BaseEntityRepository[Token]

	// DeleteByParticipantID removes all tokens associated with a participant ID
	DeleteByParticipantID(ctx context.Context, participantID properties.UUID) error

	// DeleteByAgentID removes all tokens associated with an agent ID
	DeleteByAgentID(ctx context.Context, agentID properties.UUID) error
}

type UnauthorizedError struct {
	Err error
}

type ValidationError struct {
	Errors []ValidationErrorDetail `json:"errors"`
}

type ValidationErrorDetail struct {
	Path    string `json:"path"`
	Message string `json:"message"`
}