filesystem

type CFeature[MakeTypedFeature interface{}] struct {
	feature.CFeature
	CGormDBPathSupport[MakeTypedFeature]

	Localized   bool
	MountPoints feature.MountedPoints
	// contains filtered or unexported fields
}

type CGormDBPathSupport[MakeTypedFeature interface{}] struct {
}

type EmbedPathSupport[MakeTypedFeature interface{}] interface {
}

type Feature[MakeTypedFeature interface{}] interface {
	feature.Feature

	// IsLocalized returns true if the top-level directories are expected to be valid language.Tag codes
	IsLocalized() (supported bool)

	// MountPathROFS mounts the given fs.FileSystem path to the virtual URI point
	MountPathROFS(path, point string, rofs fs.FileSystem)

	// MountPathRWFS mounts the given fs.RWFileSystem path to the virtual URI point
	MountPathRWFS(path, point string, rwfs fs.RWFileSystem)

	// FindPathMountPoint returns the available mounts matching the given path.
	// For example if there are mounted points of "/stuff" and "/", calling:
	//
	//   f.FindPathMountPoint("/thing")
	//
	// would return the "/" mounts and calling:
	//
	//   f.FindPathMountPoint("/stuff/thing")
	//
	// would return the "/stuff" mounts
	FindPathMountPoint(path string) (mps feature.MountPoints)

	// Exists returns true if the given URI path is present on any of this
	// feature instance's mounted filesystems (can be a file or directory)
	Exists(path string) (present bool)

	// FindPageMatterPath looks for the actual path by checking for the prefix
	// with each of the enjin provided page format extensions, this allows for
	// finding PageMatter without knowing the page's actual format or language
	// first. Uses FindPathMountPoint on the prefix to find the correct
	// filesystem
	FindPageMatterPath(prefix string) (path string, err error)

	// FindReadPageMatter parses the given path file data into a matter.PageMatter
	// structure, suitable for further processing as page.Page or any other
	// type. The first fs.FileSystem which has the given path is used. The order
	// checked is the order features are added during the main enjin build
	// phase. ReadPageMatter uses FindPageMatterPath to find the matter for
	// reading
	FindReadPageMatter(path string) (pm *matter.PageMatter, err error)

	// ReadPageMatter is like FindReadPageMatter except that it uses the path
	// without using FindPageMatterPath
	ReadPageMatter(path string) (pm *matter.PageMatter, err error)

	// WritePageMatter constructs new file data from the existing pm.Body with
	// pm.Matter (using pm.FrontMatterType) and writes it to the first
	// fs.RWFileSystem that matches the PageMatter's path
	WritePageMatter(pm *matter.PageMatter) (err error)

	// GetMountedPoints returns the map of all points currently mounted
	GetMountedPoints() (mountPoints feature.MountedPoints)
}

type GormDBPathSupport[MakeTypedFeature interface{}] interface {
}

type LocalPathSupport[MakeTypedFeature interface{}] interface {
}

type MakeFeature[MakeTypedFeature interface{}] interface {
	Support[MakeTypedFeature]
	LocalPathSupport[MakeTypedFeature]
	EmbedPathSupport[MakeTypedFeature]
	ZipPathSupport[MakeTypedFeature]
	GormDBPathSupport[MakeTypedFeature]
}

type Support[MakeTypedFeature interface{}] interface {
	// MountFS maps the local filesystem `path` to the enjin URL `point`
	//
	// The `point` is pruned from the URL during an HTTP request and the `path`
	// prefixes the file's real path. For example, it's common for the following
	// pattern:
	//
	//   f.MountLocalPath("/", "public")
	//
	// This configuration means to provide everything within the local path of
	// `./public/*` (recursively) at the root point of the URL, so for example
	// the URL `/favicon.ico` would translate to the local filesystem path of
	// `./public/favicon.ico`
	MountFS(point, path string, ifs fs.FileSystem) MakeTypedFeature
}

type ZipPathSupport[MakeTypedFeature interface{}] interface {
}