Lua-CSharp/src/Lua/IO/ILuaFileSystem.cs

using Lua.Internal;

namespace Lua.IO;

public interface ILuaFileSystem
{
    public bool IsReadable(string path);
    public ValueTask<LuaFileContent> ReadFileContentAsync(string path, CancellationToken cancellationToken);
    public ILuaIOStream? Open(string path, LuaFileOpenMode mode, bool throwError);
    public void Rename(string oldName, string newName);
    public void Remove(string path);
    public string DirectorySeparator { get; }
    public string GetTempFileName();
    public ILuaIOStream OpenTempFileStream();
}

public interface ILuaIOStream : IDisposable
{
    public ValueTask<string?> ReadLineAsync(CancellationToken cancellationToken);
    public ValueTask<string> ReadToEndAsync(CancellationToken cancellationToken);
    public ValueTask<string?> ReadStringAsync(int count, CancellationToken cancellationToken);
    public ValueTask WriteAsync(ReadOnlyMemory<char> buffer, CancellationToken cancellationToken);
    public ValueTask FlushAsync(CancellationToken cancellationToken);
    public void SetVBuf(LuaFileBufferingMode mode, int size);
    public long Seek(long offset, SeekOrigin origin);
}

public sealed class FileSystem : ILuaFileSystem
{
    public static readonly FileSystem Instance = new();

    public static (FileMode, FileAccess access) GetFileMode(LuaFileOpenMode luaFileOpenMode)
    {
        return luaFileOpenMode switch
        {
            LuaFileOpenMode.Read => (FileMode.Open, FileAccess.Read),
            LuaFileOpenMode.Write => (FileMode.Create, FileAccess.Write),
            LuaFileOpenMode.Append => (FileMode.Append, FileAccess.Write),
            LuaFileOpenMode.ReadWriteOpen => (FileMode.Open, FileAccess.ReadWrite),
            LuaFileOpenMode.ReadWriteCreate => (FileMode.Create, FileAccess.ReadWrite),
            LuaFileOpenMode.ReadAppend => (FileMode.Append, FileAccess.ReadWrite),
            _ => throw new ArgumentOutOfRangeException(nameof(luaFileOpenMode), luaFileOpenMode, null)
        };
    }

    public bool IsReadable(string path)
    {
        if (!File.Exists(path)) return false;
        try
        {
            File.Open(path, FileMode.Open, FileAccess.Read).Dispose();
            return true;
        }
        catch (Exception)
        {
            return false;
        }
    }

    public ValueTask<LuaFileContent> ReadFileContentAsync(string path, CancellationToken cancellationToken)
    {
        var bytes = File.ReadAllBytes(path);
        return new(new LuaFileContent(bytes));
    }

    public ILuaIOStream? Open(string path, LuaFileOpenMode luaMode, bool throwError)
    {
        if (luaMode == LuaFileOpenMode.ReadAppend)
        {
            throw new NotSupportedException("a+ mode is not supported.");
        }

        var (mode, access) = GetFileMode(luaMode);
        try
        {
            return new LuaIOStreamWrapper(File.Open(path, mode, access));
        }
        catch (Exception)
        {
            if (throwError)
            {
                throw;
            }

            return null;
        }
    }

    public void Rename(string oldName, string newName)
    {
        if (oldName == newName) return;
        File.Move(oldName, newName);
        File.Delete(oldName);
    }

    public void Remove(string path)
    {
        File.Delete(path);
    }

    static readonly string directorySeparator = Path.DirectorySeparatorChar.ToString();
    public string DirectorySeparator => directorySeparator;

    public string GetTempFileName()
    {
        return Path.GetTempFileName();
    }

    public ILuaIOStream OpenTempFileStream()
    {
        return new LuaIOStreamWrapper(File.Open(Path.GetTempFileName(), FileMode.OpenOrCreate, FileAccess.ReadWrite));
    }
}

public sealed class LuaIOStreamWrapper(Stream innerStream) : ILuaIOStream
{
    StreamReader? reader;
    StreamWriter? writer;

    public ValueTask<string?> ReadLineAsync(CancellationToken cancellationToken)
    {
        ThrowIfNotReadable();
        reader ??= new(innerStream);

        return new(reader.ReadLine());
    }

    public ValueTask<string> ReadToEndAsync(CancellationToken cancellationToken)
    {
        ThrowIfNotReadable();
        reader ??= new(innerStream);

        return new(reader.ReadToEnd());
    }

    public ValueTask<string?> ReadStringAsync(int count, CancellationToken cancellationToken)
    {
        ThrowIfNotReadable();
        reader ??= new(innerStream);

        using var byteBuffer = new PooledArray<char>(count);
        var span = byteBuffer.AsSpan();
        var ret = reader.Read(span);
        if (ret != span.Length)
        {
            return new(default(string));
        }

        return new(span.ToString());
    }

    public ValueTask WriteAsync(ReadOnlyMemory<char> buffer, CancellationToken cancellationToken)
    {
        ThrowIfNotWritable();
        writer ??= new(innerStream);
        writer.Write(buffer.Span);
        return new();
    }

    public ValueTask FlushAsync(CancellationToken cancellationToken)
    {
        ThrowIfNotWritable();
        writer?.Flush();
        return new();
    }

    public void SetVBuf(LuaFileBufferingMode mode, int size)
    {
        writer ??= new(innerStream);
        // Ignore size parameter
        writer.AutoFlush = mode is LuaFileBufferingMode.NoBuffering or LuaFileBufferingMode.LineBuffering;
    }

    public long Seek(long offset, SeekOrigin origin) => innerStream.Seek(offset, origin);
    public bool CanRead => innerStream.CanRead;
    public bool CanSeek => innerStream.CanSeek;
    public bool CanWrite => innerStream.CanWrite;

    void ThrowIfNotReadable()
    {
        if (!innerStream.CanRead)
        {
            throw new IOException("Stream is not readable.");
        }
    }

    void ThrowIfNotWritable()
    {
        if (!innerStream.CanWrite)
        {
            throw new IOException("Stream is not writable.");
        }
    }

    public void Dispose() => innerStream.Dispose();
}