module fs

import io
import os

// FileInfo describes a file or directory entry.
pub interface FileInfo {
    name() string
    size() u64
    mode() os.FileMode
    mod_time() i64
    is_dir() bool
}

// DirEntry describes a single directory entry.
pub interface DirEntry {
    name() string
    is_dir() bool
    typ() os.FileType
    info() !FileInfo
}

// File is the minimum interface required to read from a filesystem entry.
pub interface File {
    io.Reader
    stat() !FileInfo
mut:
    close()
}

// FS opens slash-separated paths that pass `valid_path`.
pub interface FS {
    open(name string) !File
}

// ReadDirFile can read directory entries directly from an opened file.
pub interface ReadDirFile {
    File
mut:
    read_dir(n int) ![]DirEntry
}

// ReadDirFS can read a directory without first opening it as a `File`.
pub interface ReadDirFS {
    read_dir(name string) ![]DirEntry
}

// ReadFileFS can read a whole file without first opening it as a `File`.
pub interface ReadFileFS {
    read_file(name string) ![]u8
}

// StatFS can stat a path without first opening it as a `File`.
pub interface StatFS {
    stat(name string) !FileInfo
}

// GlobFS can expand glob patterns within a filesystem.
pub interface GlobFS {
    glob(pattern string) ![]string
}

// SubFS can return a filesystem rooted at a subdirectory.
pub interface SubFS {
    sub(dir string) !FS
}

struct FileInfoDirEntry {
    source FileInfo
}

fn (entry FileInfoDirEntry) name() string {
    return entry.source.name()
}

fn (entry FileInfoDirEntry) is_dir() bool {
    return entry.source.is_dir()
}

fn (entry FileInfoDirEntry) typ() os.FileType {
    return entry.source.mode().typ
}

fn (entry FileInfoDirEntry) info() !FileInfo {
    return entry.source
}

fn sort_dir_entries(mut entries []DirEntry) {
    entries.sort(a.name() < b.name())
}

// valid_path reports whether `name` is a valid slash-separated path for `FS.open`.
pub fn valid_path(name string) bool {
    if name == '.' {
        return true
    }
    if name.len == 0 {
        return false
    }
    for elem in name.split('/') {
        if elem.len == 0 || elem == '.' || elem == '..' {
            return false
        }
    }
    return true
}

// file_info_to_dir_entry wraps a `FileInfo` in a `DirEntry`.
pub fn file_info_to_dir_entry(info FileInfo) DirEntry {
    return FileInfoDirEntry{
        source: info
    }
}

// read_file reads the named file from `filesystem`.
pub fn read_file(filesystem FS, name string) ![]u8 {
    if filesystem is ReadFileFS {
        reader := filesystem as ReadFileFS
        return reader.read_file(name)
    }
    mut file := filesystem.open(name)!
    defer {
        file.close()
    }
    reader := file as io.Reader
    return io.read_all(
        reader:                reader
        read_to_end_of_stream: true
    )
}

// read_dir reads and sorts the named directory from `filesystem`.
pub fn read_dir(filesystem FS, name string) ![]DirEntry {
    if filesystem is ReadDirFS {
        reader := filesystem as ReadDirFS
        mut entries := reader.read_dir(name)!
        sort_dir_entries(mut entries)
        return entries
    }
    mut file := filesystem.open(name)!
    defer {
        file.close()
    }
    if mut file is ReadDirFile {
        mut entries := file.read_dir(-1)!
        sort_dir_entries(mut entries)
        return entries
    }
    return error('fs: `${name}` does not support read_dir')
}

// stat returns file information for the named path from `filesystem`.
pub fn stat(filesystem FS, name string) !FileInfo {
    if filesystem is StatFS {
        stats := filesystem as StatFS
        return stats.stat(name)
    }
    mut file := filesystem.open(name)!
    defer {
        file.close()
    }
    return file.stat()
}