resource

type DirCache struct {
	K Kind
	// Label names the row, and Dir is the directory it measures.
	Label string
	Dir   string
	// Purpose is what the bytes are for, said in the row.
	Purpose string
	// Fill is how this cache comes to have anything in it, in the words the
	// row shows where the Fetch button cannot be pressed. Three of these fill
	// themselves as the map is used and one does not, and a page that said the
	// first sentence about all four left buildings looking like a download
	// that had failed.
	Fill string
	// FillPanel is the page a cache nothing fills on its own is fetched from,
	// so the row can offer the way there rather than only describing it.
	FillPanel string
	// OnRequest marks the cache nothing fills on its own, so the row says
	// "only when asked" rather than claiming the application will see to it.
	OnRequest bool
	// Terms is the attribution the data arrived under, shown on demand. The
	// data is somebody else's; saying so is not optional.
	Terms string
}

type Fetcher interface {
	Fetch(ctx context.Context, name, version string, progress func(done, total int64)) error
}

type HTTPDoer interface {
	Do(*http.Request) (*http.Response, error)
}

type Kind string

type Licensor interface {
	Licence(name, version string) string
}

type Provider interface {
	// Kind is what this provider produces, and names its rows in the panel.
	Kind() Kind
	// List reads what is on disk. It never touches the network: opening the
	// panel must not start a download.
	List(ctx context.Context) ([]Row, error)
	// Remove deletes one row's bytes. The caller has already confirmed.
	Remove(ctx context.Context, row Row) error
}

type Row struct {
	Kind Kind
	// Name identifies the row to a person; Version distinguishes two of the
	// same thing where that idea applies, and is empty where it does not.
	Name    string
	Version string
	// Path is where it lives on disk, empty when nothing is cached. A remove
	// acts on this rather than on the name, because the name is a label.
	Path string
	// Bytes is measured when Cached and estimated otherwise, and Estimated
	// says which - a guess presented as a survey is the thing this package
	// exists to stop.
	Bytes     int64
	Estimated bool
	State     State
	// Why carries the reason for anything that is not a plain on-disk row:
	// what it is needed for, or why it cannot be had.
	Why string
	// Auto is whether the application may fetch this without asking. Not the
	// same as enabled - presence is the state above - but whether bandwidth
	// may be spent on the operator's behalf.
	Auto bool
	// Fetchable is whether this row can be downloaded on demand from the
	// panel. A SoftDevice can: it is one file at a known address. A terrain
	// cache cannot, because what to fetch depends on where the operator is
	// looking - it fills as the map is used, and the panel says so rather
	// than offering a button that has nothing to ask for.
	Fetchable bool
	// HowTo is how this is obtained when it cannot be obtained from here, and
	// the row is not finished without it.
	//
	// A row that names a missing thing and stops is a dead end: building
	// footprints sat at nothing with Fetch disabled and the words "fills itself
	// as the map is used" beside it, which was true of terrain and false of
	// them - they are pulled from Configuration > Environ, and nothing on the
	// page said so.
	HowTo string
	// HowToPanel is the page that does have it, where there is one. The row
	// carries the name and the interface decides what opening it means, which
	// is the only part of this a provider has no business knowing.
	HowToPanel string
	// Licensed is whether there are terms to show. Somebody else's data comes
	// with somebody else's conditions, and the panel is where they belong.
	Licensed bool
}

type SoftDevice struct {
	// CacheDir is the resource cache root; releases land under it by name and
	// version, so two can coexist.
	CacheDir string
	// HTTP is the client, so a test answers without a network.
	HTTP interface {
		Do(*http.Request) (*http.Response, error)
	}
	// Needed is how many nodes in this scenario cannot boot without one, so a
	// missing row can say that rather than sit there looking optional.
	Needed int
}

type State string

type Toolchain struct {
	// Dir is the tools directory: where the emulator lookup already searches,
	// and therefore the only place a fetch is worth putting anything.
	Dir string
	// HTTP is the client, so a test answers without a network.
	HTTP HTTPDoer
	// Needed counts the nodes in this scenario that cannot boot without each
	// tool, keyed by the tool's name, so a missing row reads as blocking
	// rather than optional.
	Needed map[string]int
	// Find is the lookup a booting node does - the environment, then beside
	// the binary, then the tools directory, then PATH. Injected so this
	// package needs no emulator to be tested, and so the row and the node
	// cannot answer differently about the same machine.
	Find func(name string) (string, error)
}

type Verified struct {
	// URL is where it is, and SHA256 is what it has to hash to. An empty
	// digest is refused rather than skipped: this type exists to check.
	URL    string
	SHA256 string
	// Bytes is what the publisher says the size is, used for progress when
	// the server declares none - a redirect often arrives with no
	// Content-Length, and a job reading "0 of 0" on a 61 MB download reads as
	// a stall.
	Bytes int64
	// Name is what to call this in an error, in the words the operator saw it
	// offered under.
	Name string
	// Dir is where the part file is written. The caller moves it into place,
	// because where "in place" is differs per caller and only they know
	// whether what landed is what they wanted.
	Dir  string
	HTTP HTTPDoer
}