resources

type AbstractInstanciatedResource[T ResourceInstanceITF] struct {
	AbstractResource     // AbstractResource contains the basic fields of an object (id, name)
	Instances        []T `json:"instances,omitempty" bson:"instances,omitempty"` // Bill is the bill of the resource            // Bill is the bill of the resource
}

type AbstractResource struct {
	utils.AbstractObject                // AbstractObject contains the basic fields of an object (id, name)
	Type                  string        `json:"type,omitempty" bson:"type,omitempty"`                                               // Type is the type of the resource
	Logo                  string        `json:"logo,omitempty" bson:"logo,omitempty" validate:"required"`                           // Logo is the logo of the resource
	Description           string        `json:"description,omitempty" bson:"description,omitempty"`                                 // Description is the description of the resource
	ShortDescription      string        `json:"short_description,omitempty" bson:"short_description,omitempty" validate:"required"` // ShortDescription is the short description of the resource
	Owners                []utils.Owner `json:"owners,omitempty" bson:"owners,omitempty"`                                           // Owners is the list of owners of the resource
	UsageRestrictions     string        `bson:"usage_restrictions,omitempty" json:"usage_restrictions,omitempty"`
	SelectedInstanceIndex *int          `json:"selected_instance_index,omitempty" bson:"selected_instance_index,omitempty"` // SelectedInstance is the selected instance
}

type ComputeNode struct {
	Name     string           `json:"name,omitempty" bson:"name,omitempty"`
	Quantity int64            `json:"quantity" bson:"quantity" default:"1"`
	RAM      *models.RAM      `bson:"ram,omitempty" json:"ram,omitempty"`   // RAM is the RAM
	CPUs     map[string]int64 `bson:"cpus,omitempty" json:"cpus,omitempty"` // CPUs is the list of CPUs key is model
	GPUs     map[string]int64 `bson:"gpus,omitempty" json:"gpus,omitempty"` // GPUs is the list of GPUs key is model
}

type ComputeResource struct {
	AbstractInstanciatedResource[*ComputeResourceInstance]
	Architecture   string                  `json:"architecture,omitempty" bson:"architecture,omitempty"` // Architecture is the architecture
	Infrastructure enum.InfrastructureType `json:"infrastructure" bson:"infrastructure" default:"-1"`    // Infrastructure is the infrastructure
}

type ComputeResourceInstance struct {
	ResourceInstance[*ComputeResourcePartnership]
	Source             string                 `json:"source,omitempty" bson:"source,omitempty"` // Source is the source of the resource
	SecurityLevel      string                 `json:"security_level,omitempty" bson:"security_level,omitempty"`
	PowerSources       []string               `json:"power_sources,omitempty" bson:"power_sources,omitempty"`
	AnnualCO2Emissions float64                `json:"annual_co2_emissions,omitempty" bson:"co2_emissions,omitempty"`
	CPUs               map[string]*models.CPU `bson:"cpus,omitempty" json:"cpus,omitempty"` // CPUs is the list of CPUs key is model
	GPUs               map[string]*models.GPU `bson:"gpus,omitempty" json:"gpus,omitempty"` // GPUs is the list of GPUs key is model
	Nodes              []*ComputeNode         `json:"nodes,omitempty" bson:"nodes,omitempty"`
}

type ComputeResourcePartnership struct {
	ResourcePartnerShip[*ComputeResourcePricingProfile]
	MinGaranteedCPUsCores    map[string]float64 `json:"garanteed_cpus,omitempty" bson:"garanteed_cpus,omitempty"`
	MinGaranteedGPUsMemoryGB map[string]float64 `json:"garanteed_gpus,omitempty" bson:"garanteed_gpus,omitempty"`
	MinGaranteedRAMSize      float64            `json:"garanteed_ram,omitempty" bson:"garanteed_ram,omitempty"`

	MaxAllowedCPUsCores    map[string]float64 `json:"allowed_cpus,omitempty" bson:"allowed_cpus,omitempty"`
	MaxAllowedGPUsMemoryGB map[string]float64 `json:"allowed_gpus,omitempty" bson:"allowed_gpus,omitempty"`
	MaxAllowedRAMSize      float64            `json:"allowed_ram,omitempty" bson:"allowed_ram,omitempty"`
}

type ComputeResourcePricingProfile struct {
	pricing.ExploitPricingProfile[pricing.TimePricingStrategy]
	// ExploitPricingProfile is the pricing profile of a compute it means that we exploit the resource for an amount of continuous time
	CPUsPrices map[string]float64 `json:"cpus_prices,omitempty" bson:"cpus_prices,omitempty"` // CPUsPrices is the prices of the CPUs
	GPUsPrices map[string]float64 `json:"gpus_prices,omitempty" bson:"gpus_prices,omitempty"` // GPUsPrices is the prices of the GPUs
	RAMPrice   float64            `json:"ram_price" bson:"ram_price" default:"-1"`            // RAMPrice is the price of the RAM
}

type DataInstance struct {
	ResourceInstance[*DataResourcePartnership]
	Source string `json:"source,omitempty" bson:"source,omitempty"` // Source is the source of the data
}

type DataResource struct {
	AbstractInstanciatedResource[*DataInstance]
	Type                   string     `bson:"type,omitempty" json:"type,omitempty"`
	Quality                string     `bson:"quality,omitempty" json:"quality,omitempty"`
	OpenData               bool       `bson:"open_data" json:"open_data" default:"false"` // Type is the type of the storage
	Static                 bool       `bson:"static" json:"static" default:"false"`
	UpdatePeriod           *time.Time `bson:"update_period,omitempty" json:"update_period,omitempty"`
	PersonalData           bool       `bson:"personal_data,omitempty" json:"personal_data,omitempty"`
	AnonymizedPersonalData bool       `bson:"anonymized_personal_data,omitempty" json:"anonymized_personal_data,omitempty"`
	SizeGB                 float64    `json:"size,omitempty" bson:"size,omitempty"` // SizeGB is the size of the data	License              DataLicense `json:"license" bson:"license" description:"license of the data" default:"0"` // License is the license of the data
	// ? Interest               DataLicense `json:"interest" bson:"interest" description:"interest of the data" default:"0"`      // Interest is the interest of the data
	Example string `json:"example,omitempty" bson:"example,omitempty" description:"base64 encoded data"` // Example is an example of the data
}

type DataResourcePartnership struct {
	ResourcePartnerShip[*DataResourcePricingProfile]
	MaxDownloadableGbAllowed      float64 `json:"allowed_gb,omitempty" bson:"allowed_gb,omitempty"`
	PersonalDataAllowed           bool    `json:"personal_data_allowed,omitempty" bson:"personal_data_allowed,omitempty"`
	AnonymizedPersonalDataAllowed bool    `json:"anonymized_personal_data_allowed,omitempty" bson:"anonymized_personal_data_allowed,omitempty"`
}

type DataResourcePricingProfile struct {
	pricing.AccessPricingProfile[DataResourcePricingStrategy] // AccessPricingProfile is the pricing profile of a data it means that we can access the data for an amount of time
}

type DataResourcePricingStrategy int

type GeoPoint struct {
	Latitude  float64 `json:"latitude,omitempty" bson:"latitude,omitempty"`
	Longitude float64 `json:"longitude,omitempty" bson:"longitude,omitempty"`
}

type ItemResource struct {
	Data       *DataResource       `bson:"data,omitempty" json:"data,omitempty"`
	Processing *ProcessingResource `bson:"processing,omitempty" json:"processing,omitempty"`
	Storage    *StorageResource    `bson:"storage,omitempty" json:"storage,omitempty"`
	Compute    *ComputeResource    `bson:"compute,omitempty" json:"compute,omitempty"`
	Workflow   *WorkflowResource   `bson:"workflow,omitempty" json:"workflow,omitempty"`
}

type PricedComputeResource struct {
	PricedResource

	CPUsLocated map[string]float64 `json:"cpus_in_use" bson:"cpus_in_use"` // CPUsInUse is the list of CPUs in use
	GPUsLocated map[string]float64 `json:"gpus_in_use" bson:"gpus_in_use"` // GPUsInUse is the list of GPUs in use
	RAMLocated  float64            `json:"ram_in_use" bson:"ram_in_use"`   // RAMInUse is the RAM in use
}

type PricedDataResource struct {
	PricedResource
	UsageStorageGB float64 `json:"storage_gb,omitempty" bson:"storage_gb,omitempty"`
}

type PricedProcessingResource struct {
	PricedResource
	IsService bool
}

type PricedResource struct {
	Name                     string                    `json:"name,omitempty" bson:"name,omitempty"`
	Logo                     string                    `json:"logo,omitempty" bson:"logo,omitempty"`
	InstancesRefs            map[string]string         `json:"instances_refs,omitempty" bson:"instances_refs,omitempty"`
	SelectedPricing          pricing.PricingProfileITF `json:"selected_pricing,omitempty" bson:"selected_pricing,omitempty"`
	ExplicitBookingDurationS float64                   `json:"explicit_location_duration_s,omitempty" bson:"explicit_location_duration_s,omitempty"`
	UsageStart               *time.Time                `json:"start,omitempty" bson:"start,omitempty"`
	UsageEnd                 *time.Time                `json:"end,omitempty" bson:"end,omitempty"`
	CreatorID                string                    `json:"peer_id,omitempty" bson:"peer_id,omitempty"`
	ResourceID               string                    `json:"resource_id,omitempty" bson:"resource_id,omitempty"`
	ResourceType             tools.DataType            `json:"resource_type,omitempty" bson:"resource_type,omitempty"`
}

type PricedStorageResource struct {
	PricedResource
	UsageStorageGB float64 `json:"storage_gb,omitempty" bson:"storage_gb,omitempty"`
}

type PrivilegeStoragePricingStrategy int

type ProcessingInstance struct {
	ResourceInstance[*ResourcePartnerShip[*ProcessingResourcePricingProfile]]
	Access *ProcessingResourceAccess `json:"access,omitempty" bson:"access,omitempty"` // Access is the access
}

type ProcessingResource struct {
	AbstractInstanciatedResource[*ProcessingInstance]
	Infrastructure enum.InfrastructureType `json:"infrastructure" bson:"infrastructure" default:"-1"` // Infrastructure is the infrastructure
	IsService      bool                    `json:"is_service,omitempty" bson:"is_service,omitempty"`  // IsService is a flag that indicates if the processing is a service
	Usage          *ProcessingUsage        `bson:"usage,omitempty" json:"usage,omitempty"`            // Usage is the usage of the processing
	OpenSource     bool                    `json:"open_source" bson:"open_source" default:"false"`
	License        string                  `json:"license,omitempty" bson:"license,omitempty"`
	Maturity       string                  `json:"maturity,omitempty" bson:"maturity,omitempty"`
}

type ProcessingResourceAccess struct {
	Container *models.Container `json:"container,omitempty" bson:"container,omitempty"` // Container is the container
}

type ProcessingResourcePricingProfile struct {
	pricing.AccessPricingProfile[pricing.TimePricingStrategy] // AccessPricingProfile is the pricing profile of a data it means that we can access the data for an amount of time
}

type ProcessingUsage struct {
	CPUs map[string]*models.CPU `bson:"cpus,omitempty" json:"cpus,omitempty"` // CPUs is the list of CPUs key is model
	GPUs map[string]*models.GPU `bson:"gpus,omitempty" json:"gpus,omitempty"` // GPUs is the list of GPUs key is model
	RAM  *models.RAM            `bson:"ram,omitempty" json:"ram,omitempty"`   // RAM is the RAM

	StorageGb    float64 `bson:"storage,omitempty" json:"storage,omitempty"` // Storage is the storage
	Hypothesis   string  `bson:"hypothesis,omitempty" json:"hypothesis,omitempty"`
	ScalingModel string  `bson:"scaling_model,omitempty" json:"scaling_model,omitempty"` // ScalingModel is the scaling model
}

type ResourceInstance[T ResourcePartnerITF] struct {
	utils.AbstractObject
	Location                 GeoPoint              `json:"location,omitempty" bson:"location,omitempty"`
	Country                  countries.CountryCode `json:"country,omitempty" bson:"country,omitempty"`
	AccessProtocol           string                `json:"access_protocol,omitempty" bson:"access_protocol,omitempty"`
	Env                      []models.Param        `json:"env,omitempty" bson:"env,omitempty"`
	Inputs                   []models.Param        `json:"inputs,omitempty" bson:"inputs,omitempty"`
	Outputs                  []models.Param        `json:"outputs,omitempty" bson:"outputs,omitempty"`
	SelectedPartnershipIndex int                   `json:"selected_partnership_index,omitempty" bson:"selected_partnership_index,omitempty"`
	SelectedBuyingStrategy   int                   `json:"selected_buying_strategy,omitempty" bson:"selected_buying_strategy,omitempty"`
	SelectedStrategy         int                   `json:"selected_strategy,omitempty" bson:"selected_strategy,omitempty"`
	Partnerships             []T                   `json:"partnerships,omitempty" bson:"partnerships,omitempty"`
}

type ResourceInstanceITF interface {
	utils.DBObject
	GetID() string
	GetName() string
	StoreDraftDefault()
	ClearEnv()
	GetProfile() pricing.PricingProfileITF
	GetPricingsProfiles(peerID string, groups []string) []pricing.PricingProfileITF
	GetPeerGroups() ([]ResourcePartnerITF, []map[string][]string)
	ClearPeerGroups()
	GetSelectedPartnership(peerID string, groups []string) ResourcePartnerITF
	GetPartnerships(peerID string, groups []string) []ResourcePartnerITF
}

type ResourceInterface interface {
	utils.DBObject
	Trim()
	ConvertToPricedResource(t tools.DataType, request *tools.APIRequest) pricing.PricedItemITF
	GetType() string
	GetSelectedInstance() ResourceInstanceITF
	ClearEnv() utils.DBObject
	SetAllowedInstances(request *tools.APIRequest)
}

type ResourceMongoAccessor[T ResourceInterface] struct {
	utils.AbstractAccessor // AbstractAccessor contains the basic fields of an accessor (model, caller)
	// contains filtered or unexported fields
}

type ResourcePartnerITF interface {
	GetPricingsProfiles(peerID string, groups []string) []pricing.PricingProfileITF
	GetPeerGroups() map[string][]string
	ClearPeerGroups()
	GetProfile(buying int, strategy int) pricing.PricingProfileITF
}

type ResourcePartnerShip[T pricing.PricingProfileITF] struct {
	Namespace       string              `json:"namespace" bson:"namespace" default:"default-namespace"`
	PeerGroups      map[string][]string `json:"peer_groups,omitempty" bson:"peer_groups,omitempty"`
	PricingProfiles map[int]map[int]T   `json:"pricing_profiles,omitempty" bson:"pricing_profiles,omitempty"`
}

type ResourceSet struct {
	Datas       []string `bson:"datas,omitempty" json:"datas,omitempty"`
	Storages    []string `bson:"storages,omitempty" json:"storages,omitempty"`
	Processings []string `bson:"processings,omitempty" json:"processings,omitempty"`
	Computes    []string `bson:"computes,omitempty" json:"computes,omitempty"`
	Workflows   []string `bson:"workflows,omitempty" json:"workflows,omitempty"`

	DataResources       []*DataResource       `bson:"-" json:"data_resources,omitempty"`
	StorageResources    []*StorageResource    `bson:"-" json:"storage_resources,omitempty"`
	ProcessingResources []*ProcessingResource `bson:"-" json:"processing_resources,omitempty"`
	ComputeResources    []*ComputeResource    `bson:"-" json:"compute_resources,omitempty"`
	WorkflowResources   []*WorkflowResource   `bson:"-" json:"workflow_resources,omitempty"`
}

type StorageResource struct {
	AbstractInstanciatedResource[*StorageResourceInstance]                  // AbstractResource contains the basic fields of an object (id, name)
	StorageType                                            enum.StorageType `bson:"storage_type" json:"storage_type" default:"-1"` // Type is the type of the storage
	Acronym                                                string           `bson:"acronym,omitempty" json:"acronym,omitempty"`    // Acronym is the acronym of the storage
}

type StorageResourceInstance struct {
	ResourceInstance[*StorageResourcePartnership]
	Source        string           `bson:"source,omitempty" json:"source,omitempty"` // Source is the source of the storage
	Path          string           `bson:"path,omitempty" json:"path,omitempty"`     // Path is the store folders in the source
	Local         bool             `bson:"local" json:"local"`
	SecurityLevel string           `bson:"security_level,omitempty" json:"security_level,omitempty"`
	SizeType      enum.StorageSize `bson:"size_type" json:"size_type" default:"0"`           // SizeType is the type of the storage size
	SizeGB        int64            `bson:"size,omitempty" json:"size,omitempty"`             // Size is the size of the storage
	Encryption    bool             `bson:"encryption,omitempty" json:"encryption,omitempty"` // Encryption is a flag that indicates if the storage is encrypted
	Redundancy    string           `bson:"redundancy,omitempty" json:"redundancy,omitempty"` // Redundancy is the redundancy of the storage
	Throughput    string           `bson:"throughput,omitempty" json:"throughput,omitempty"` // Throughput is the throughput of the storage
}

type StorageResourcePartnership struct {
	ResourcePartnerShip[*StorageResourcePricingProfile]
	MaxSizeGBAllowed     float64 `json:"allowed_gb,omitempty" bson:"allowed_gb,omitempty"`
	OnlyEncryptedAllowed bool    `json:"personal_data_allowed,omitempty" bson:"personal_data_allowed,omitempty"`
}

type StorageResourcePricingProfile struct {
	pricing.ExploitPricingProfile[StorageResourcePricingStrategy] // ExploitPricingProfile is the pricing profile of a storage it means that we exploit the resource for an amount of continuous time
}

type StorageResourcePricingStrategy int

type WorkflowResource struct {
	AbstractResource
	WorkflowID string `bson:"workflow_id,omitempty" json:"workflow_id,omitempty"` // WorkflowID is the ID of the native workflow
}

type WorkflowResourcePricingProfile struct{}