module io

pub struct BufferedWriter {
mut:
	n  int
	wr Writer
pub mut:
	buf []u8
}

@[params]
pub struct BufferedWriterConfig {
pub:
	writer Writer
	cap    int = 128 * 1024
}

// new_buffered_writer creates a new BufferedWriter with the specified BufferedWriterConfig.
// Returns an error when cap is 0 or negative.
pub fn new_buffered_writer(o BufferedWriterConfig) !&BufferedWriter {
	if o.cap < 1 {
		return error('`o.cap` must be a positive integer')
	}

	return &BufferedWriter{
		buf: []u8{len: o.cap}
		wr:  o.writer
	}
}

// reset resets the buffer to its initial state.
pub fn (mut b BufferedWriter) reset() {
	cap := b.buf.len
	b.buf = []u8{len: cap}
	b.n = 0
}

// buffered returns the number of bytes currently stored in the buffer.
pub fn (b BufferedWriter) buffered() int {
	return b.n
}

// flush writes the buffered data to the underlying writer and clears the buffer, ensures all data is
// written.
// Returns an error if the writer fails to write all buffered data.
pub fn (mut b BufferedWriter) flush() ! {
	if b.buffered() == 0 {
		return
	}
	mut written := 0
	for written < b.n {
		n := b.wr.write(b.buf[written..b.n]) or {
			b.shift_unwritten_to_front(written)
			return err
		}
		if n <= 0 || n > b.n - written {
			b.shift_unwritten_to_front(written)
			return error('writer returned an invalid number of bytes while flushing')
		}
		written += n
	}
	b.n = 0
}

// available returns the amount of available space left in the buffer.
pub fn (b BufferedWriter) available() int {
	return b.buf.len - b.n
}

fn (mut b BufferedWriter) shift_unwritten_to_front(written int) {
	if written <= 0 {
		return
	}
	remaining := b.n - written
	if remaining <= 0 {
		b.n = 0
		return
	}
	copy(mut b.buf[..remaining], b.buf[written..b.n])
	b.n = remaining
}

// write writes `src` in the buffer, flushing it to the underlying writer as needed, and returns the
// number of bytes written.
pub fn (mut b BufferedWriter) write(src []u8) !int {
	mut written := 0
	for written < src.len {
		remaining := src.len - written
		if b.buffered() == 0 && remaining > b.available() {
			n := b.wr.write(src[written..])!
			if n <= 0 || n > remaining {
				return error('writer returned an invalid number of bytes while writing')
			}
			written += n
			continue
		}
		n := copy(mut b.buf[b.n..], src[written..])
		b.n += n
		written += n
		if b.available() == 0 {
			b.flush()!
		}
	}
	return written
}