store

type Activity struct {
	BookingID   string            `json:"booking_id" yaml:"booking_id"`
	Description Description       `json:"description" yaml:"description"`
	ConfigURL   string            `json:"config_url,omitempty"  yaml:"config_url,omitempty"`
	Streams     map[string]Stream `json:"streams" yaml:"streams"`
	UIs         []UIDescribed     `json:"ui" yaml:"ui"`
	NotBefore   time.Time         `json:"nbf" yaml:"nbf"`
	ExpiresAt   time.Time         `json:"exp" yaml:"exp"`
}

type Booking struct {
	// Cancelled indicates if booking cancelled
	Cancelled bool `json:"cancelled" yaml:"cancelled"`
	// CancelledAt represents when the booking was cancelled
	CancelledAt time.Time `json:"cancelled_at" yaml:"cancelled_at"`
	// CancelledBy indicates who cancelled e.g. auto-grace-period, admin or user
	CancelledBy string `json:"cancelled_by" yaml:"cancelled_by"`
	// Group
	Group string `json:"group" yaml:"group"`
	// booking unique reference
	Name string `json:"name" yaml:"name"`
	// reference to policy it was booked under
	Policy string `json:"policy" yaml:"policy"`
	// slot name
	Slot    string `json:"slot" yaml:"slot"`
	Started bool   `json:"started" yaml:"started"`
	//StartedAt is for reporting purposes, do not use to calculate usage
	StartedAt string `json:"started_at" yaml:"started_at"`
	//when the resource was unavailable
	Unfulfilled bool `json:"unfulfilled" yaml:"unfulfilled"`
	// User represents user's name
	User string `json:"user" yaml:"user"`

	// UsageCharged represents how much usage was charged
	// This is updated on cancellation and is for convenience of admin looking at exports/reports
	// Replace(Old)Bookings should calculate the usage to be charged based on the policy
	// That avoids those editing bookings to upload from performing this calculation manually
	UsageCharged time.Duration `json:"usage_charged" yaml:"usage_charged"`

	When interval.Interval `json:"when" yaml:"when"`
}

type Description struct {
	Name    string `json:"name" yaml:"name"`
	Type    string `json:"type" yaml:"type"`
	Short   string `json:"short" yaml:"short"`
	Long    string `json:"long,omitempty" yaml:"long,omitempty"`
	Further string `json:"further,omitempty" yaml:"further,omitempty"`
	Thumb   string `json:"thumb,omitempty" yaml:"thumb,omitempty"`
	Image   string `json:"image,omitempty" yaml:"image,omitempty"`
}

type DisplayGuide struct {
	BookAhead time.Duration `json:"book_ahead" yaml:"book_ahead"`
	Duration  time.Duration `json:"duration" yaml:"duration"`
	Label     string        `json:"label" yaml:"label"`
	MaxSlots  int           `json:"max_slots" yaml:"max_slots"`
}

type Group struct {
	Description string   `json:"description" yaml:"description"`
	Policies    []string `json:"policies" yaml:"policies"`
}

type GroupDescribed struct {
	Description Description `json:"description"  yaml:"description"`
	// keep track of the description reference, needed for manifest export
	DescriptionReference string   `json:"-" yaml:"-"`
	Policies             []string `json:"policies" yaml:"policies"`
}

type Manifest struct {
	Descriptions  map[string]Description  `json:"descriptions" yaml:"descriptions"`
	DisplayGuides map[string]DisplayGuide `json:"display_guides" yaml:"display_guides"`
	Groups        map[string]Group        `json:"groups" yaml:"groups"`
	Policies      map[string]Policy       `json:"policies" yaml:"policies"`
	Resources     map[string]Resource     `json:"resources" yaml:"resources"`
	Slots         map[string]Slot         `json:"slots" yaml:"slots"`
	Streams       map[string]Stream       `json:"streams" yaml:"streams"`
	UIs           map[string]UI           `json:"uis" yaml:"uis"`
	UISets        map[string]UISet        `json:"ui_sets" yaml:"ui_sets"`
	Windows       map[string]Window       `json:"windows" yaml:"windows"`
}

type Policy struct {
	// AllowStartInPastWithin gives some latitude to accept a booking starting now that gets delayed on the way to the server. A bookng at minimum acceptable duration will be reduced to as much as this duration, so that there is no need to include logic about how to handle a shift in the end time. Typically values might be 10s or 1m.
	AllowStartInPastWithin time.Duration `json:"allow_start_in_past_within"  yaml:"allow_start_in_past_within"`
	//booking must finish within the book_ahead duration, if enforced
	BookAhead     time.Duration `json:"book_ahead"  yaml:"book_ahead"`
	Description   string        `json:"description"  yaml:"description"`
	DisplayGuides []string      `json:"display_guides"  yaml:"display_guides"`
	// In the manifest, we will refer to display guides by reference
	// For users, we want to send policy descriptions that are complete
	// so store a local copy of the displayguides to ease the process of fulfilling GET policy_name requests
	// but don't include this local copy of information in any manifests
	DisplayGuidesMap map[string]DisplayGuide `json:"-"  yaml:"-"` //local copy so that exported policies are complete but exclude from json/yaml so not duplicated in manifests
	// EnforceAllowStartInPast lets a request starting before now (e.g. due to delayed communication of request) be accepted if other policies are still met.
	EnforceAllowStartInPast bool `json:"enforce_allow_start_in_past"  yaml:"enforce_allow_start_in_past"`
	EnforceBookAhead        bool `json:"enforce_book_ahead"  yaml:"enforce_book_ahead"`
	EnforceGracePeriod      bool `json:"enforce_grace_period"  yaml:"enforce_grace_period"`
	EnforceMaxBookings      bool `json:"enforce_max_bookings"  yaml:"enforce_max_bookings"`
	EnforceMaxDuration      bool `json:"enforce_max_duration"  yaml:"enforce_max_duration"`
	EnforceMinDuration      bool `json:"enforce_min_duration"  yaml:"enforce_min_duration"`
	EnforceMaxUsage         bool `json:"enforce_max_usage"  yaml:"enforce_max_usage"`
	EnforceNextAvailable    bool `json:"enforce_next_available"  yaml:"enforce_next_available"`
	EnforceStartsWithin     bool `json:"enforce_starts_within"  yaml:"enforce_starts_within"`
	//EnforceUnlimitedUsers if true, bookings are not checked, and the token is granted if otherwise within policy. This supports hardware-less simulations to be
	// included without needing to specify multiple slots. We don't set a finite limit here to avoid having to track multiple overlapping bookings when usually simulations
	// run entirely in client-side code - if a simulation has a resource limit e.g. due to using some central heavyweight server to crunch data, then slots should be specified
	// same as for hardware, and this option left as false.
	EnforceUnlimitedUsers bool `json:"enforce_unlimited_users"  yaml:"enforce_unlimited_users"`
	// GracePeriod is how long after When.Start that the booking will be kept
	GracePeriod time.Duration `json:"grace_period" yaml:"grace_period"`
	// GracePenalty represents the time lost to finding a new user after auto-cancellation
	GracePenalty time.Duration `json:"grace_penalty" yaml:"grace_penalty"`
	MaxBookings  int64         `json:"max_bookings"  yaml:"max_bookings"`
	MaxDuration  time.Duration `json:"max_duration"  yaml:"max_duration"`
	MinDuration  time.Duration `json:"min_duration"  yaml:"min_duration"`
	MaxUsage     time.Duration `json:"max_usage"  yaml:"max_usage"`
	// NextAvailable allows for a small gap in bookings to give some flex in case the availability windows are presented with reduced resolution at some point in the system
	// i.e. set to 2min to allow a request that is rounded up to start at the next minute after the last booking ends, instead of expecting ms precision from everyone
	// Leaving this to default to zero requires the booking UI to return the exact figure given in the availability list, which probably works for now but might not later when other developers
	// working on other features maybe don't realise how strict the calculation is without this allowance, or we change the precision somewhere in the system for human-readability and lose the
	// exact value that the system would expect due to loss of precision - resulting in a rejected booking that is otherwise within the spirit of the policy.
	// Also, some use cases might actually let this be say 15min or 30min - we can't predict the use cases, but can expect them to vary within the same booking system,
	// so don't make this a system-wide parameter.
	NextAvailable time.Duration   `json:"next_available"  yaml:"next_available"`
	Slots         []string        `json:"slots" yaml:"slots"`
	SlotMap       map[string]bool `json:"-" yaml:"-"` // internal usage, do not populate from file
	// booking must start within this duration from now, if enforced
	StartsWithin time.Duration `json:"starts_within"  yaml:"starts_within"`
}

type PolicyStatus struct {
	CurrentBookings int64         `json:"current_bookings"  yaml:"current_bookings"`
	OldBookings     int64         `json:"old_bookings"  yaml:"old_bookings"`
	Usage           time.Duration `json:"usage"  yaml:"usage"`
}

type Resource struct {

	// ConfigURL represents a hardware configuration file URL
	// that may be useful to a UI
	ConfigURL string `json:"config_url,omitempty"  yaml:"config_url,omitempty"`

	// Description is a reference to a named description of the resource
	// that will probably only be shown on admin dashboards (not to students)
	Description string `json:"description"  yaml:"description"`

	// Diary is held in memory, not in the manifest, so don't unmarshall it.
	Diary *diary.Diary `json:"-"  yaml:"-"`

	// Streams is a list of stream types used by this resource, e.g. data, video, logging
	// We autogenerate the full stream details needed by the UI  when making a live activity,
	// using a rule to generate the topic and filling in the other details from the stream prototype
	// Streams are required because sims would still use logging, and if not
	// just add a dummy stream called null so that we have a check on streams
	// being included for the main use case.
	Streams []string `json:"streams"  yaml:"streams"`

	Tests []string `json:"tests"  yaml:"tests"`

	//TopicStub is the name that should be used to make the topic <TopicStub>-<for>
	TopicStub string `json:"topic_stub" yaml:"topic_stub"`
}

type Slot struct {
	Description string `json:"description"  yaml:"description"`
	Policy      string `json:"policy"  yaml:"policy"`
	Resource    string `json:"resource"  yaml:"resource"`
	UISet       string `json:"ui_set"  yaml:"ui_set"`
	Window      string `json:"window"  yaml:"window"`
}

type Store struct {
	*sync.RWMutex `json:"-"`

	// Checker does grace checking on bookings
	Checker *check.Checker

	// Bookings represents all the live bookings, indexed by booking id
	Bookings map[string]*Booking

	// Descriptions represents all the descriptions of various entities, indexed by description name
	Descriptions map[string]Description

	DisableCancelAfterUse bool

	DisplayGuides map[string]DisplayGuide

	// Filters are how the windows are checked, mapped by window name (populated after loading window info from manifest)
	Filters map[string]*filter.Filter

	// Groups represent groups of policies - we bake in the description to reduce overhead on this common operation
	Groups map[string]GroupDescribed

	// GraceRebound represents how long to wait before checking any bookings that were
	// supposed to be checked but the store was locked (see GraceCheck)
	GraceRebound time.Duration

	Locked bool

	// Message represents our message of the day, to send to users (e.g. to explain system is locked)
	Message string

	//useful for admin dashboard - don't need to also parse logs if keep old bookings
	// Old Bookings represents the
	OldBookings map[string]*Booking

	// TimePolicies represents all the TimePolicy(ies) in use
	Policies map[string]Policy

	// Resources represent all the actual physical experiments, indexed by name
	Resources map[string]Resource

	// Slots represent the combinations of virtual equipments and booking policies that apply to them
	Slots map[string]Slot

	Streams map[string]Stream

	// UIs represents all the user interfaces that are available
	UIs map[string]UIDescribed

	// UISets represents the lists of user interfaces for particular slots
	UISets map[string]UISet

	// Users maps all users.
	Users map[string]*User

	// Window represents allowed and denied time periods for slots
	Windows map[string]Window
	// contains filtered or unexported fields
}

type StoreStatusAdmin struct {
	Bookings     int64     `json:"bookings"  yaml:"bookings"`
	Descriptions int64     `json:"descriptions"  yaml:"descriptions"`
	Filters      int64     `json:"filters" yaml:"filters"`
	Groups       int64     `json:"groups" yaml:"groups"`
	Locked       bool      `json:"locked" yaml:"locked"`
	Message      string    `json:"message" yaml:"message"`
	Now          time.Time `json:"now" yaml:"now"`
	OldBookings  int64     `json:"old_bookings"  yaml:"old_bookings"`
	Policies     int64     `json:"policies" yaml:"policies"`
	Resources    int64     `json:"resources" yaml:"resources"`
	Slots        int64     `json:"slots" yaml:"slots"`
	Streams      int64     `json:"streams" yaml:"streams"`
	UIs          int64     `json:"uis" yaml:"uis"`
	UISets       int64     `json:"ui_sets" yaml:"ui_sets"`
	Users        int64     `json:"users" yaml:"users"`
	Windows      int64     `json:"windows" yaml:"windows"`
}

type StoreStatusUser struct {
	Locked  bool      `json:"locked" yaml:"locked"`
	Message string    `json:"message" yaml:"message"`
	Now     time.Time `json:"now" yaml:"now"`
}

type Stream struct {
	Audience string `json:"audience" yaml:"audience"`
	// ConnectionType is whether for session or shell e.g. session
	ConnectionType string `json:"connection_type"  yaml:"connection_type"`

	// For is the key in the UI's URL in which the client puts
	// the relay (wss) address and code after getting them
	// from the relay, e.g. data
	For string `json:"for"  yaml:"for"`

	// Scopes represent what the client can do e.g. read, write
	Scopes []string `json:"scopes"  yaml:"scopes"`

	// Topic is the relay topic, usually <resource name>-<for>. e.g. pend03-data
	Topic string `json:"topic"  yaml:"topic"`

	// URL of the relay access point for this stream e.g. https://relay-access.practable.io
	URL string `json:"url"  yaml:"url"`
}

type UI struct {
	Description string `json:"description"  yaml:"description"`
	// URL with moustache {{key}} templating for stream connections
	URL             string   `json:"url"  yaml:"url"`
	StreamsRequired []string `json:"streams_required"  yaml:"streams_required"`
}

type UIDescribed struct {
	Description Description `json:"description"  yaml:"description"`
	// Keep track of the description's name, needed for ExportManifest
	DescriptionReference string `json:"-" yaml:"-"`
	// URL with moustache {{key}} templating for stream connections
	URL             string   `json:"url"  yaml:"url"`
	StreamsRequired []string `json:"streams_required"  yaml:"streams_required"`
}

type UISet struct {
	UIs []string `json:"uis" yaml:"uis"`
}

type User struct {
	Bookings    map[string]*Booking       //map by id for retrieval
	OldBookings map[string]*Booking       //map by id, for admin dashboards
	Groups      map[string]bool           //map of groups of policies that the user can access
	Usage       map[string]*time.Duration //map by policy for checking usage
}

type UserExternal struct {
	Bookings    []string `json:"bookings" yaml:"bookings"`
	OldBookings []string `json:"old_bookings" yaml:"old_bookings"`
	Groups      []string `json:"groups" yaml:"groups"`
	//map humanised durations by policy name
	Usage map[string]string `json:"usage" yaml:"usage"`
}

type Window struct {
	Allowed []interval.Interval `json:"allowed"  yaml:"allowed"`
	Denied  []interval.Interval `json:"denied"  yaml:"denied"`
}