datastore

type AddressRef struct {
	// Address is the address of the contract on the chain.
	Address string `json:"address"`
	// ChainSelector is the chain-selector of the chain where the contract is deployed.
	ChainSelector uint64 `json:"chainSelector"`
	// Labels are the labels associated with the contract.
	Labels LabelSet `json:"labels"`
	// Qualifier is an optional qualifier for the contract.
	Qualifier string `json:"qualifier"`
	// ContractType is a simple string type for identifying contract types.
	Type ContractType `json:"type"`
	// Version is the version of the contract.
	Version *semver.Version `json:"version"`
}

type AddressRefKey interface {
	Comparable[AddressRefKey]
	fmt.Stringer

	// ChainSelector returns the chain-selector selector of the chain where the contract is deployed.
	ChainSelector() uint64
	// Type returns the contract type of the contract.
	// This is a simple string type for identifying contract
	Type() ContractType
	// Version returns the semantic version of the contract.
	Version() *semver.Version
	// Qualifier returns the optional qualifier for the contract.
	// This can be used to differentiate between different references of the same contract.
	Qualifier() string
}

type AddressRefStore interface {
	Store[AddressRefKey, AddressRef]
}

type BaseCatalogStore interface {
	BaseDataStoreV2[
		MutableRefStoreV2[AddressRefKey, AddressRef], MutableStoreV2[ChainMetadataKey, ChainMetadata],
		MutableStoreV2[ContractMetadataKey, ContractMetadata], MutableUnaryStoreV2[EnvMetadata],
	]
}

type BaseDataStore[
	R AddressRefStore, CH ChainMetadataStore, CM ContractMetadataStore, EM EnvMetadataStore,
] interface {
	Addresses() R
	ChainMetadata() CH
	ContractMetadata() CM
	EnvMetadata() EM
}

type BaseDataStoreV2[
	R MutableRefStoreV2[AddressRefKey, AddressRef],
	CH MutableStoreV2[ChainMetadataKey, ChainMetadata],
	CM MutableStoreV2[ContractMetadataKey, ContractMetadata],
	EM MutableUnaryStoreV2[EnvMetadata],
] interface {
	Addresses() R
	ChainMetadata() CH
	ContractMetadata() CM
	EnvMetadata() EM
}

type CatalogStore interface {
	Transactional
	BaseCatalogStore
}

type ChainMetadata struct {
	// ChainSelector refers to the chain associated with the metadata.
	ChainSelector uint64 `json:"chainSelector"`
	// Metadata is the metadata associated with the chain.
	Metadata any `json:"metadata"`
}

type ChainMetadataKey interface {
	Comparable[ChainMetadataKey]
	fmt.Stringer

	// ChainSelector returns the chain-selector of the chain associated with the metadata.
	ChainSelector() uint64
}

type ChainMetadataStore interface {
	Store[ChainMetadataKey, ChainMetadata]
}

type Comparable[T any] interface {
	// Equals	returns true if the two instances are equal, false otherwise.
	Equals(T) bool
}

type ContractMetadata struct {
	// Address is the address of the contract on the chain.
	Address string `json:"address"`
	// ChainSelector is the chain-selector of the chain where the contract is deployed.
	ChainSelector uint64 `json:"chainSelector"`
	// Metadata is the metadata associated with the contract.
	Metadata any `json:"metadata"`
}

type ContractMetadataKey interface {
	Comparable[ContractMetadataKey]
	fmt.Stringer

	// Address returns the address of the contract on the chain.
	Address() string
	// ChainSelector returns the chain-selector of the chain where the contract is deployed.
	ChainSelector() uint64
}

type ContractMetadataStore interface {
	Store[ContractMetadataKey, ContractMetadata]
}

type ContractType string

type DataStore interface {
	BaseDataStore[
		AddressRefStore, ChainMetadataStore,
		ContractMetadataStore, EnvMetadataStore,
	]
}

type EnvMetadata struct {
	// Metadata is the metadata associated with the domain and environment.
	Metadata any `json:"metadata"`
}

type EnvMetadataStore interface {
	UnaryStore[EnvMetadata]
}

type Fetcher[R any] interface {
	// Fetch returns a slice of records representing the entire data set. The returned slice
	// will be a newly allocated slice (not a reference to an existing one), and each record should
	// be a copy of the corresponding stored data. Modifying the returned slice or its records must
	// not affect the underlying data.
	Fetch() ([]R, error)
}

type FetcherV2[R any] interface {
	// Fetch returns a slice of records representing the entire data set. The returned slice
	// will be a newly allocated slice (not a reference to an existing one), and each record should
	// be a copy of the corresponding stored data. Modifying the returned slice or its records must
	// not affect the underlying data.
	Fetch(context.Context) ([]R, error)
}

type FilterFunc[K Comparable[K], R UniqueRecord[K, R]] func([]R) []R

type Filterable[K Comparable[K], R UniqueRecord[K, R]] interface {
	Filter(filters ...FilterFunc[K, R]) []R
}

type FilterableV2[K Comparable[K], R UniqueRecord[K, R]] interface {
	Filter(context.Context, ...FilterFunc[K, R]) ([]R, error)
}

type GetOption interface {
	// contains filtered or unexported methods
}

type Getter[K Comparable[K], R UniqueRecord[K, R]] interface {
	// Get returns the record with the given key, or an error if no such record exists.
	Get(K) (R, error)
}

type GetterV2[K Comparable[K], R UniqueRecord[K, R]] interface {
	// Get returns the record with the given key, or an error if no such record exists.
	//
	// GetOptions may be supplied to modify the semantics of the call, as specified in the option.
	Get(context.Context, K, ...GetOption) (R, error)
}

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

type MemoryAddressRefStore struct {
	Records []AddressRef `json:"records"`
	// contains filtered or unexported fields
}

type MemoryChainMetadataStore struct {
	Records []ChainMetadata `json:"records"`
	// contains filtered or unexported fields
}

type MemoryContractMetadataStore struct {
	Records []ContractMetadata `json:"records"`
	// contains filtered or unexported fields
}

type MemoryDataStore struct {
	AddressRefStore       *MemoryAddressRefStore       `json:"addressRefStore"`
	ChainMetadataStore    *MemoryChainMetadataStore    `json:"chainMetadataStore"`
	ContractMetadataStore *MemoryContractMetadataStore `json:"contractMetadataStore"`
	EnvMetadataStore      *MemoryEnvMetadataStore      `json:"envMetadataStore"`
}

type MemoryEnvMetadataStore struct {
	Record *EnvMetadata `json:"record"`
	// contains filtered or unexported fields
}

type Merger[T any] interface {
	// Merge merges the given data into the current data store.
	// It should return an error if the merge fails.
	Merge(other T) error
}

type MetadataUpdaterF func(latest any, incoming any) (any, error)

type MutableAddressRefStore interface {
	MutableStore[AddressRefKey, AddressRef]
}

type MutableChainMetadataStore interface {
	MutableStore[ChainMetadataKey, ChainMetadata]
}

type MutableContractMetadataStore interface {
	MutableStore[ContractMetadataKey, ContractMetadata]
}

type MutableDataStore interface {
	Merger[DataStore]
	Sealer[DataStore]

	BaseDataStore[
		MutableAddressRefStore, MutableChainMetadataStore,
		MutableContractMetadataStore, MutableEnvMetadataStore,
	]
}

type MutableEnvMetadataStore interface {
	MutableUnaryStore[EnvMetadata]
}

type MutableRefStoreV2[K Comparable[K], R UniqueRecord[K, R]] interface {
	FetcherV2[R]
	GetterV2[K, R]
	FilterableV2[K, R]

	Add(ctx context.Context, record R) error

	Update(ctx context.Context, record R) error

	Upsert(ctx context.Context, record R) error

	Delete(ctx context.Context, key K) error
}

type MutableStore[K Comparable[K], R UniqueRecord[K, R]] interface {
	Store[K, R]

	// Add inserts a new record into the MutableStore.
	Add(record R) error

	// Upsert behaves like Add where there is not already a record with the same composite primary key as the
	// supplied record, otherwise it behaves like an update.
	Upsert(record R) error

	// Update edits an existing record whose fields match the primary key elements of the supplied AddressRecord, with
	// the non-primary-key values of the supplied AddressRecord.
	Update(record R) error

	// Delete deletes record whose primary key elements match the supplied key, returning an error if no
	// such record exists to be deleted
	Delete(key K) error
}

type MutableStoreV2[K Comparable[K], R UniqueRecord[K, R]] interface {
	FetcherV2[R]
	GetterV2[K, R]
	FilterableV2[K, R]

	// Add inserts a new record into the MutableStore.
	Add(ctx context.Context, record R) error

	// Upsert behaves like Add where there is not already a record with the same composite primary key as the
	// supplied record, otherwise it behaves like an update.
	// Options can be provided to customize the behavior (e.g., custom updater function).
	Upsert(ctx context.Context, key K, metadata any, opts ...UpdateOption) error

	// Update edits an existing record whose fields match the primary key elements of the supplied AddressRecord, with
	// the non-primary-key values of the supplied AddressRecord.
	// Options can be provided to customize the behavior (e.g., custom updater function).
	Update(ctx context.Context, key K, metadata any, opts ...UpdateOption) error

	// Delete deletes record whose primary key elements match the supplied key, returning an error if no
	// such record exists to be deleted
	Delete(ctx context.Context, key K) error
}

type MutableUnaryStore[R any] interface {
	// Get returns a copy of the record or an error.
	// If the record exists, the error should be nil.
	// If the record does not exist, the error should not be nil.
	Get() (R, error)

	// Set sets the record in the store.
	// If the record already exists, it should be replaced.
	// If the record does not exist, it should be added.
	Set(record R) error
}

type MutableUnaryStoreV2[R any] interface {
	// Get returns a copy of the record or an error.
	// If the record exists, the error should be nil.
	// If the record does not exist, the error should not be nil.
	Get(ctx context.Context, options ...GetOption) (R, error)

	// Set sets the record in the store.
	// If the record already exists, it should be replaced.
	// If the record does not exist, it should be added.
	// Options can be provided to customize the behavior (e.g., custom updater function).
	Set(ctx context.Context, metadata any, opts ...UpdateOption) error
}

type PrimaryKeyHolder[K Comparable[K]] interface {
	// Key returns the primary key for the implementing type.
	Key() K
}

type Sealer[T any] interface {
	// Seal seals the data store, preventing further modifications.
	Seal() T
}

type Store[K Comparable[K], R UniqueRecord[K, R]] interface {
	Fetcher[R]
	Getter[K, R]
	Filterable[K, R]
}

type TransactionLogic func(ctx context.Context, catalog BaseCatalogStore) error

type Transactional interface {
	// WithTransaction allows the caller to wrap their datastore operations in a transactional
	// boundary, such that any datastore operations will succeed or fail together. The caller
	// supplies a lambda containing the operations, which the calling context being plumbed
	// through. Starting and committing the transaction is automated, and if an error is
	// returned, the transaction is rolled-back instead.
	WithTransaction(ctx context.Context, fn TransactionLogic) error
}

type UnaryStore[R any] interface {
	// Get returns the record or an error.
	// if the record exists, the error should be nil.
	// If the record does not exist, the error should not be nil.
	Get() (R, error)
}

type UniqueRecord[K Comparable[K], R PrimaryKeyHolder[K]] interface {
	PrimaryKeyHolder[K]
}

type UpdateOption func(*UpdateOptions)

type UpdateOptions struct {
	Updater MetadataUpdaterF
}