package swarm

import (
	"context"
	"io"

	"github.com/distribution/distribution/v3/registry/storage/driver"
	"github.com/distribution/distribution/v3/registry/storage/driver/factory"
)

const driverName = "torrent"

func init() {
	factory.Register(driverName, &torrentDriverFactory{})
}

// torrentDriverFactory implements the factory.StorageDriverFactory interface.
type torrentDriverFactory struct{}

var _ factory.StorageDriverFactory = (*torrentDriverFactory)(nil)

func (f *torrentDriverFactory) Create(map[string]interface{}) (driver.StorageDriver, error) {
	return New(), nil
}

// torrentDriver implements the driver.StorageDriver interface
type torrentDriver struct{}

var _ driver.StorageDriver = (*torrentDriver)(nil)

func New() *torrentDriver {
	return &torrentDriver{}
}

// Name returns the human-readable "name" of the driver, useful in error
// messages and logging. By convention, this will just be the registration
// name, but drivers may provide other information here.
func (t *torrentDriver) Name() string {
	return driverName
}

func (t *torrentDriver) Delete(ctx context.Context, path string) error {
	return nil
}

// GetContent retrieves the content stored at "path" as a []byte.
// This should primarily be used for small objects.
func (t *torrentDriver) GetContent(ctx context.Context, path string) ([]byte, error) {
	panic("not implemented") // TODO: Implement
}

// PutContent stores the []byte content at a location designated by "path".
// This should primarily be used for small objects.
func (t *torrentDriver) PutContent(ctx context.Context, path string, content []byte) error {
	panic("not implemented") // TODO: Implement
}

// Reader retrieves an io.ReadCloser for the content stored at "path"
// with a given byte offset.
// May be used to resume reading a stream by providing a nonzero offset.
func (t *torrentDriver) Reader(ctx context.Context, path string, offset int64) (io.ReadCloser, error) {
	panic("not implemented") // TODO: Implement
}

// Writer returns a FileWriter which will store the content written to it
// at the location designated by "path" after the call to Commit.
func (t *torrentDriver) Writer(ctx context.Context, path string, append bool) (driver.FileWriter, error) {
	panic("not implemented") // TODO: Implement
}

// Stat retrieves the FileInfo for the given path, including the current
// size in bytes and the creation time.
func (t *torrentDriver) Stat(ctx context.Context, path string) (driver.FileInfo, error) {
	return &swarmFile{}, nil
}

// List returns a list of the objects that are direct descendants of the
// given path.
func (t *torrentDriver) List(ctx context.Context, path string) ([]string, error) {
	panic("not implemented") // TODO: Implement
}

// Move moves an object stored at sourcePath to destPath, removing the
// original object.
// Note: This may be no more efficient than a copy followed by a delete for
// many implementations.
func (t *torrentDriver) Move(ctx context.Context, sourcePath string, destPath string) error {
	panic("not implemented") // TODO: Implement
}

// URLFor returns a URL which may be used to retrieve the content stored at
// the given path, possibly using the given options.
// May return an ErrUnsupportedMethod in certain StorageDriver
// implementations.
func (t *torrentDriver) URLFor(ctx context.Context, path string, options map[string]interface{}) (string, error) {
	panic("not implemented") // TODO: Implement
}

// Walk traverses a filesystem defined within driver, starting
// from the given path, calling f on each file.
// If the returned error from the WalkFn is ErrSkipDir and fileInfo refers
// to a directory, the directory will not be entered and Walk
// will continue the traversal.  If fileInfo refers to a normal file, processing stops
func (t *torrentDriver) Walk(ctx context.Context, path string, f driver.WalkFn) error {
	panic("not implemented") // TODO: Implement
}