#ifndef BLUE_CORE_STREAM_HPP_
#define BLUE_CORE_STREAM_HPP_

#include <blue/core/encoding.hpp>
#include <blue/core/misc.hpp>
#include <blue/core/object.hpp>
#include <blue/core/status.hpp>
#include <blue/core/stream.h>
#include <blue/core/type.hpp>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <string>

namespace blue::core
{
class stream_buffer : public object
{
};

class stream : public object
{
    public:
	enum class mode : int {
		READ = B_STREAM_READ,
		WRITE = B_STREAM_WRITE,
		BINARY = B_STREAM_BINARY,
		__STATIC = Z__B_STREAM_STATIC,
	};

	enum class seek_origin : int {
		START = B_STREAM_SEEK_START,
		CURRENT = B_STREAM_SEEK_CURRENT,
		END = B_STREAM_SEEK_END,
	};

	static type get_type(void);
	static stream &in(void);
	static stream &out(void);
	static stream &err(void);

	stream(stream &) = delete;

	stream(std::FILE *fp);

	status reserve(std::size_t len);
	status seek(long long offset, seek_origin origin);
	std::size_t cursor(void) const;

	status push_indent(int indent);
	status pop_indent(void);

	status read_char(wchar &c);

	status read_bytes(void *buf, std::size_t count, std::size_t &nr_read);
	status read_bytes(void *buf, std::size_t count)
	{
		std::size_t tmp;
		return read_bytes(buf, count, tmp);
	}

	status read_line(char *s, std::size_t max);
	status read_line(std::string &out);
	status read_line(stream &dest);

	status read_all_bytes(void *p, std::size_t max, std::size_t &nr_read);
	status read_all_bytes(
		stream &dest, stream_buffer &buf, std::size_t &nr_read);

	status read_all_bytes(void *p, std::size_t max)
	{
		std::size_t tmp;
		return read_all_bytes(p, max);
	}

	status read_all_bytes(stream &dest, stream_buffer &buf)
	{
		std::size_t tmp;
		return read_all_bytes(dest, buf);
	}

	status write_char(wchar c);
	status write_string(const char *s, std::size_t &nr_written);
	status write_string(const char *s)
	{
		std::size_t tmp;
		return write_string(s, tmp);
	}

	status write_string(const std::string &s, std::size_t &nr_written)
	{
		return write_string(s.c_str(), nr_written);
	}
	status write_string(const std::string &s)
	{
		std::size_t tmp;
		return write_string(s, tmp);
	}

	status write_bytes(
		const void *buf, std::size_t count, std::size_t &nr_written);
	status write_bytes(const void *buf, std::size_t count)
	{
		std::size_t tmp;
		return write_bytes(buf, count, tmp);
	}

	status write_fmt(std::size_t &nr_written, const char *format, ...);
	status write_vfmt(
		std::size_t &nr_written, const char *format, std::va_list arg);

	status write_fmt(const char *format, ...)
	{
		std::size_t tmp;
		std::va_list arg;
		va_start(arg, format);
		status s = write_vfmt(tmp, format, arg);
		va_end(arg);
		return s;
	}

	status write_vfmt(const char *format, std::va_list arg)
	{
		std::size_t tmp;
		return write_vfmt(tmp, format, arg);
	}

    protected:
	stream() = default;
};
}

Z__B_ENUM_CLASS_BITWISE_OPS(blue::core::stream::mode)

#endif