plugins

type BoolOption struct {
	K                string
	V                bool
	Required, Hidden bool
	C                string
}

type Downloader func(int, Reporter) error

type ErrHTTPStatusCode struct {
	StatusCode int
}

type FloatOption struct {
	K                string
	V                float64
	Required, Hidden bool
	C                string
}

type ForceDisableOption struct {
	BoolOption
}

type ForceMaxWorkersOption struct {
	IntOption
}

type ForceZipOption struct {
	BoolOption
}

type IntOption struct {
	K                string
	V                int
	Required, Hidden bool
	C                string
}

type Option interface {
	Key() string
	Value() interface{}
	// Set the value using user input.
	Set(string) error
	IsRequired() bool
	IsHidden() bool
	Comment() string
}

type Plugin interface {
	// The name of the plugin.
	Name() string
	// The version of the plugin. Do not prefix it with "v" or anything like that.
	// Can return an empty string.
	Version() string
	// Should return whether or not it can deal with a URL.
	// There is no guarantee that DownloadGenerator() will be called later.
	// There is also no guarantee that the last call to this is the URL that
	// will be passed to DownloadGenerator(). In other words, don't store stuff
	// here for later use.
	CanHandle(url string) bool
	// Returns a slice of all the options. If the user wants to, they can
	// be set. Of course, if an option needs a value and the user does not
	// set it, either make sure you have a default value or that IsRequired()
	// returns true. The latter will not allow the plugin to run without setting it.
	Options() []Option
	// A generator function that returns a generator that generates downloaders.
	// Sounds overly convoluted, but when combined with closures, it's pretty damn neat.
	// The outer function could theoretically be dropped and just have it directly generate
	// Downloader functions, but if you have to initialize stuff first, you'd have to check
	// whether or not you've initialized at the start of the function for every call.
	// With this signature, you can just initialize and return the generator as a closure to
	// keep all the local variables and not have to store them anywhere first. This also
	// makes it ideal for having one single object per plugin without ever having to remake it.
	//
	// The "dls" is the number of downloaders that are going to be returned. Use UnknownTotal
	// if it's unknown. You can go over or under the total without it breaking anything important.
	// It's simply used for displaying progress through the interface.
	//
	// See the Dummy plugin for an example implementation.
	DownloadGenerator(url string) (dlgen func() Downloader, dls int)
	// A method called by the download manager at the end. If an error caused the manager
	// to abort, it is passed. Otherwise nil is passed.
	Cleanup(error)
}

type Reporter interface {
	// Should be used when you have something you need to download, but not
	// actually something you want the manager to save and count as part of
	// the resulting files.
	//
	// This doesn't directly benefit the downloader, but it allows the manager
	// to keep track of download speeds, and more importantly if something were
	// to go wrong in another downloader, it can detect that and stop the downloader
	// from keeping the application from exiting.
	Copy(dst io.Writer, src io.Reader) (written int64, err error)
	// Saves the data/file into a file as a successful download.
	// The path must be relative, as the downloader will take care of where to save files.
	// The report bool determines whether or not it should report download speeds.
	// In other words, whether or not src is getting its data straight from the network.
	SaveData(dst string, src io.Reader, report bool) (written int64, err error)
	// Saves the file as a successful download. The destination path must be relative,
	// as the downloader will take care of where to save files. The file is renamed (moved)
	// to the final destination rather than copied. This only works if the file resides on
	// the same disk drive as the the destination, so use SaveFile() if unsure.
	// Should be safe to use with TempFile() files. src must be closed before using this.
	SaveFile(dst, src string) (size int64, err error)
	// For when you need a temporary file. Should ensure the file resides on the same
	// disk drive as the download directory, allowing for use with SaveFile().
	TempFile() (*os.File, error)
	// Returns a writer to the destination file. The caller must close it.
	// Download completion is reported on close.
	FileWriter(dst string, report bool) (io.WriteCloser, error)
}

type StringOption struct {
	K, V             string
	Required, Hidden bool
	C                string
}