import System.*
import System.Concurrency.Tasks.*
import System.Result.*
import System.Storage.*
import System.Storage.File
import System.Storage.Directory
import System.IO.*
import System.Text.*

func Parse(text: string) -> Path {
    return match Path.Parse(text) {
        Ok(let path) => path
        Failure(_) => {
            Panic("Invalid sample path")
            Parse("/")
        }
    }
}

async func WriteMessage(output: OutputStream) -> Task<Result<unit, StreamError>> {
    let writer = StreamWriter(output, true)
    let written = await writer.Write("Hello, värld!")
    writer.Close()
    if let Failure(error) = written {
        return Failure(error)
    }
    return await output.Flush()
}

func ShowText(prefix: string, result: Result<string, TextReadError>) {
    match result {
        Ok(let text) => Console.WriteLine(prefix + text)
        Failure(let error) => Panic(error.ToString())
    }
}

async func FileAccess(file: File) -> Task<()> {
    match file.CreateNew() {
        Ok(let output) => {
            let written = await WriteMessage(output)
            output.Close()
            match written {
                Ok(_) => Console.WriteLine("Created " + file.Name)
                Failure(let error) => Panic(error.ToString())
            }
        }
        Failure(let error) => Panic(error.ToString())
    }
    match file.OpenRead() {
        Ok(let input) => {
            // This reader borrows the input; close it before repositioning.
            let reader: TextReader = StreamReader(input, true)
            let text = await reader.ReadToEnd(64)
            reader.Close()
            ShowText("Read: ", text)
            // Seekability is optional on a generic InputStream.
            let capability: object = input
            if capability is let seek: SeekableStream {
                match seek.Seek(0) {
                    Ok(_) => {
                        let again: TextReader = StreamReader(input, true)
                        let reread = await again.ReadToEnd(64)
                        again.Close()
                        ShowText("Re-read after seek: ", reread)
                    }
                    Failure(let error) => Panic(error.ToString())
                }
            }
            input.Close()
        }
        Failure(let error) => Panic(error.ToString())
    }
    match file.CreateNew() {
        Failure(let error) => Console.WriteLine("Existing file: " + error.ToString())
        Ok(let unexpected) => {
            unexpected.Close()
            Panic("Exclusive creation replaced a file")
        }
    }
    return ()
}

async func Explore(directory: Directory) -> Task<()> {
    // FileAt describes a destination; CreateNew performs exclusive creation.
    match directory.FileAt("message.txt") {
        Ok(let file) => await FileAccess(file)
        Failure(let error) => Panic(error.ToString())
    }
    match directory.GetItems(8) {
        Ok(let items) => {
            Console.WriteLine("Items:")
            for item in items {
                if item is Directory {
                    Console.WriteLine("directory: " + item.Name)
                } else {
                    Console.WriteLine("file: " + item.Name)
                }
            }
        }
        Failure(let error) => Panic(error.ToString())
    }
    match directory.GetDirectory("examples") {
        Ok(let child) => Console.WriteLine("Directory: " + child.Path.Text)
        Failure(let error) => Panic(error.ToString())
    }
    match directory.GetItem(Parse("message.txt")) {
        Ok(let item) => Console.WriteLine("Item: " + item.Name)
        Failure(let error) => Panic(error.ToString())
    }
    match directory.GetFile("missing.txt") {
        Failure(let error) => Console.WriteLine("Missing file: " + error.ToString())
        Ok(_) => Panic("Unexpected fixture file")
    }
    return ()
}

async func Main() -> Task<()> {
    let provider: StorageProvider = FileSystem("storage-demo")
    match provider.GetDirectory(Parse("/")) {
        Ok(let directory) => await Explore(directory)
        Failure(let error) => Panic(error.ToString())
    }
    return ()
}
