#pragma once
#include <mutex>
#include <string>
namespace lsp
{
	class stream
	{
	public:
		virtual ~stream() = default;
		virtual  bool fail() = 0;
		virtual  bool bad() = 0;
		virtual  bool eof() = 0;
		virtual  bool good() = 0;
		virtual  void clear() = 0;
		virtual  std::string  what() = 0;
		virtual  bool need_to_clear_the_state()
		{
			return false;
		}

		bool  operator!()
		{
			return bad();
		}
	};
	class istream : public  stream
	{
	public:
		virtual  int get() = 0;
		virtual ~istream() = default;
		virtual  istream& read(char* str, std::streamsize count) = 0;
	};
	template <class T >
	class base_istream : public istream
	{
	public:
		explicit  base_istream(T& _t) :_impl(_t)
		{

		}

		int get() override
		{
			return  _impl.get();
		}
		bool fail() override
		{
			return  _impl.fail();
		}
		bool bad() override
		{
			return  _impl.bad();
		}
		bool eof() override
		{
			return  _impl.eof();
		}
		bool good() override
		{
			return  _impl.good();
		}
		istream& read(char* str, std::streamsize count) override
		{
			_impl.read(str, count);
			return *this;
		}

		void clear() override
		{
			_impl.clear();
		}
		T& _impl;
	};
	class ostream : public  stream
	{
	public:
		virtual ~ostream() = default;

		virtual  ostream& write(const std::string&) = 0;
		virtual  ostream& write(std::streamsize) = 0;
		virtual  ostream& flush() = 0;

	};
	template <class T >
	class base_ostream : public ostream
	{
	public:
		explicit  base_ostream(T& _t) :_impl(_t)
		{

		}

		bool fail() override
		{
			return  _impl.fail();
		}
		bool good() override
		{
			return  _impl.good();
		}
		bool bad() override
		{
			return  _impl.bad();
		}
		bool eof() override
		{
			return  _impl.eof();
		}

		ostream& write(const std::string& c) override
		{
			_impl << c;
			return *this;
		}

		ostream& write(std::streamsize _s) override
		{

			_impl << std::to_string(_s);
			return *this;
		}

		ostream& flush() override
		{
			_impl.flush();
			return *this;
		}

		void clear() override
		{
			_impl.clear();
		}
	protected:
		T& _impl;
	};

	template <class T >
	class base_iostream : public istream, public ostream
	{
	public:
		explicit  base_iostream(T& _t) :_impl(_t)
		{

		}

		int get() override
		{
			return  _impl.get();
		}
		bool fail() override
		{
			return  _impl.fail();
		}
		bool bad() override
		{
			return  _impl.bad();
		}
		bool eof() override
		{
			return  _impl.eof();
		}
		bool good() override
		{
			return  _impl.good();
		}
		istream& read(char* str, std::streamsize count) override
		{
			_impl.read(str, count);
			return *this;
		}
		ostream& write(const std::string& c) override
		{
			_impl << c;
			return *this;
		}

		ostream& write(std::streamsize _s) override
		{
			_impl << std::to_string(_s);
			return *this;
		}

		ostream& flush() override
		{
			_impl.flush();
			return *this;
		}

		void clear() override
		{
			_impl.clear();
		}
	protected:
		T& _impl;
	};
}