db

type Annotation struct {
	Model
	BottleID uint

	Key   string // unique per bottle
	Value string
}

type Author struct {
	BottleMemberLocated

	Name  string `gorm:"index"`
	URL   string // TODO should this be URI as well?
	Email string `gorm:"index"`
}

type Base struct {
	Model
	ProcessorVersion uint `gorm:"index"`
	Data             Data // Base belongs to Data
	DataID           uint
}

type Blob struct {
	Base
}

type BlobProcessor struct{}

type Bottle struct {
	Base
	APIVersion      string
	Description     string
	Authors         []Author         // Bottle has many authors
	Sources         []Source         // Bottle has many sources
	Metrics         []Metric         // Bottle has many metrics
	PublicArtifacts []PublicArtifact // Bottle has many public_artifacts
	Labels          []Label          // Bottle has many labels
	Annotations     []Annotation     // Bottle has many annotations
	Parts           []Part           // Bottle has many parts
	Deprecates      []Deprecates     // Bottle has many deprecates
	Signatures      []Signature      // Bottle has many signatures
}

type BottleMemberLocated struct {
	Model
	BottleID uint // foreign key

	// Location in the array from JSON
	Location uint
}

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

type BottleRelative struct {
	Bottle
	Digested
	PartSelectors selectors.LabelSelectorSet `gorm:"-"` // Optional if the relationship is partial
}

type Data struct {
	Model
	RawData         []byte
	CanonicalDigest digest.Digest `gorm:"uniqueIndex"` // canonical digest is an internal only digest (like blake2 or sha3 used for de-duplication)
}

type DefaultTrustAnchor struct{}

type Deprecates struct {
	BottleMemberLocated

	DeprecatedBottleDigest digest.Digest
}

type Digest struct {
	Model
	Data   Data // Digest belongs to Data
	DataID uint
	Digest digest.Digest `gorm:"uniqueIndex"` // A user provided name/digest for this data
}

type Digested struct {
	DigestsCSV string `gorm:"digests_csv" json:"-"`
	// DataID  uint            `json:"-"`
	Digests []digest.Digest `gorm:"-"`
}

type Event struct {
	Base

	ManifestID uint
	Manifest   Manifest // Event belongs to Manifest
	// While a manifest may have different digests (different algorithms) this event is specific to this manifest.
	// The repository in this event may only have one (name) digest for this Manifest.
	ManifestDigest digest.Digest `gorm:"index"`

	BottleID     uint // Event belongs to Bottle (prejoining since the association is not allowed to change)
	Bottle       Bottle
	BottleDigest digest.Digest `gorm:"index"` // prejoin since it does not change

	Action       string // pull or push
	Repository   string
	Tag          string
	AuthRequired bool
	Bandwidth    uint64
	Timestamp    time.Time `gorm:"index"`
	Username     string    `gorm:"index"`
}

type EventProcessor struct{}

type Generation []BottleRelative

type GormLogger interface {
	logger.Interface
	IgnoreRecordNotFoundError(bool) GormLogger
	SlowThreshold(time.Duration) GormLogger
}

type Label struct {
	Model
	BottleID uint

	Key          string  `gorm:"index"` // unique per bottle
	Value        string  `gorm:"index"`
	NumericValue float64 `gorm:"index" json:"-"` // We drop this is JSON marshalling to avoid issues with logging
}

type Layer struct {
	Model
	ManifestID uint
	Location   uint

	Digest digest.Digest `gorm:"index"` // This is not tracked by the telemetry server so it is just a string (not a reference to a Digest record)

}

type Manifest struct {
	Base
	BottleID     uint
	Bottle       Bottle        // Manifest belongs to Bottle
	BottleDigest digest.Digest `gorm:"index"`
	Layers       []Layer       // Bottle has many layers
}

type ManifestProcessor struct{}

type Metric struct {
	BottleMemberLocated

	Name        string // unique per bottle
	Description string
	Value       float64
}

type Model struct {
	gorm.Model
}

type NextGenerationFinder func(con *gorm.DB, digests []digest.Digest) (Generation, error)

type NonBottleRelative struct {
	URI string
}

type Part struct {
	BottleMemberLocated

	Name   string // unique per bottle
	Size   uint64
	Digest digest.Digest `gorm:"index"` // we do not guarantee this exists in the telemetry server so this is just a string, not a Digest and DigestID

	// LabelStr is stored in the DB but code is expected to use Labels directly.
	LabelsStr string            `json:"-"`
	Labels    map[string]string `gorm:"-"`
}

type Processor interface {
	PrimaryTable() string
	Process(con *gorm.DB, base Base) error
	Version() uint
}

type PublicArtifact struct {
	BottleMemberLocated

	Name      string
	MediaType string
	Path      string `gorm:"index"` // unique per bottle
	Data      Data   // PublicArtifact belongs to Data
	DataID    uint

	// Digest is the digest of the artifact.
	// We need to preserve the digest used by the bottle to reference this artifact.
	Digest digest.Digest // `gorm:"index"` we might want an index here
}

type Relative interface {
	BottleRelative | NonBottleRelative | UnknownBottleRelative
}

type Signature struct {
	Base

	ManifestID uint
	Manifest   Manifest // Event belongs to Manifest
	// While a manifest may have different digests (different algorithms) this signature is specific to this manifest.
	// The repository in this signature may only have one (name) digest for this Manifest.
	ManifestDigest digest.Digest `gorm:"index"`

	BottleID     uint // Signature belongs to Bottle (prejoining since the association is not allowed to change)
	Bottle       Bottle
	BottleDigest digest.Digest `gorm:"index"` // prejoin since it does not change

	SignatureType        string                // currently dev.cosignproject.cosign/signature
	Signature            []byte                // raw signature payload data
	PublicKey            string                // PEM encoded public key associated with signature (Verify)
	PublicKeyFingerPrint digest.Digest         `gorm:"index"` // the digest of the public key
	Annotations          []SignatureAnnotation // extra data, such as verify api, userid, etc.

	// Trusted is used in the code but not saved in the database.
	Trusted func(TrustAnchor) bool `gorm:"-"` // true if the signature identity can be validated against a given trust anchor (fingerprint+id known)
}

type SignatureAnnotation struct {
	Model
	SignatureID uint

	Key   string // unique per bottle
	Value string
}

type SignatureProcessor struct{}

type Source struct {
	BottleMemberLocated

	Name string `gorm:"index"`
	URI  string `gorm:"index"`

	// optional if the URL is a bottle
	BottleDigest digest.Digest `gorm:"index"` // we do not guarantee this exists in the telemetry server so this is just a string, not a DataID, DigestID, or BottleID

	// PartSelectors are used in the code but not saved in the database. They are derived from the URI query parameters
	PartSelectors selectors.LabelSelectorSet `gorm:"-"`
}

type TrustAnchor interface {
	VerifyTrust() bool
}

type UnknownBottleRelative struct {
	Digest        digest.Digest
	PartSelectors selectors.LabelSelectorSet
}