namespace StorageExperiment

import System.*
import System.Collections.*
import System.Result.*
import System.IO.*

// Two-byte transfers deliberately exercise short-read and short-write loops.
class MemoryInput : InputStream, SeekableStream {
    private field bytes: List<byte>
    private field position: int = 0
    private field closed: bool = false

    init(bytes: List<byte>) {
        self.bytes = bytes
    }

    func Read(buffer: byte[], offset: int, count: int) -> Result<int, StreamError> {
        if closed {
            return Failure<StreamError>(StreamError.Closed)
        }
        if offset < 0 {
            return Failure<StreamError>(StreamError.InvalidRange)
        }
        if count < 0 {
            return Failure<StreamError>(StreamError.InvalidRange)
        }
        if offset > buffer.Length {
            return Failure<StreamError>(StreamError.InvalidRange)
        }
        if count > buffer.Length - offset {
            return Failure<StreamError>(StreamError.InvalidRange)
        }
        if count > 65536 {
            return Failure<StreamError>(StreamError.LimitExceeded)
        }
        var read = 0
        while read < count && read < 2 && position < bytes.Count {
            buffer[offset + read] = bytes[position]
            position += 1
            read += 1
        }
        return Ok(read)
    }

    func GetPosition() -> Result<long, StreamError> {
        if closed {
            return Failure<StreamError>(StreamError.Closed)
        }
        return Ok((long)position)
    }

    func Seek(position: long) -> Result<long, StreamError> {
        if closed {
            return Failure<StreamError>(StreamError.Closed)
        }
        if position < 0 {
            return Failure<StreamError>(StreamError.InvalidRange)
        }
        if position > 2147483647 {
            return Failure<StreamError>(StreamError.LimitExceeded)
        }
        self.position = (int)position
        return Ok(position)
    }

    func Close() {
        closed = true
    }
}

class MemoryOutput : OutputStream {
    private field bytes: List<byte>
    private field closed: bool = false

    init(bytes: List<byte>) {
        self.bytes = bytes
    }

    func Write(buffer: byte[], offset: int, count: int) -> Result<int, StreamError> {
        if closed {
            return Failure<StreamError>(StreamError.Closed)
        }
        if offset < 0 {
            return Failure<StreamError>(StreamError.InvalidRange)
        }
        if count < 0 {
            return Failure<StreamError>(StreamError.InvalidRange)
        }
        if offset > buffer.Length {
            return Failure<StreamError>(StreamError.InvalidRange)
        }
        if count > buffer.Length - offset {
            return Failure<StreamError>(StreamError.InvalidRange)
        }
        if count > 65536 || count > 65536 - bytes.Count {
            return Failure<StreamError>(StreamError.LimitExceeded)
        }
        var written = 0
        while written < count && written < 2 {
            bytes.Add(buffer[offset + written])
            written += 1
        }
        return Ok(written)
    }

    func Flush() -> Result<unit, StreamError> {
        if closed {
            return Failure<StreamError>(StreamError.Closed)
        }
        return Ok(())
    }

    func Close() {
        closed = true
    }
}
