use std::hash::{DefaultHasher, Hash, Hasher};

use futures::{AsyncBufRead, AsyncRead, AsyncSeek, AsyncWrite};
use pyo3::prelude::*;

mod utils;
pub use utils::*;

/// The `Whence` enum represents the reference point for seeking operations in a stream.
#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
#[pyclass(frozen)]
#[repr(u8)]
pub enum Whence {
  Start = 0,
  End = 1,
  Current = 2,
}

#[pymethods]
impl Whence {
  /// Returns the `Start` variant of `Whence`.
  #[staticmethod]
  pub fn start() -> Self {
    Self::Start
  }

  /// Returns the `End` variant of `Whence`.
  #[staticmethod]
  pub fn end() -> Self {
    Self::End
  }

  /// Returns the `Current` variant of `Whence`.
  #[staticmethod]
  pub fn current() -> Self {
    Self::Current
  }

  pub fn __str__(&self) -> &'static str {
    match self {
      Self::Start => "start",
      Self::End => "end",
      Self::Current => "current",
    }
  }

  pub fn __repr__(&self) -> &'static str {
    match self {
      Self::Start => "Whence::Start",
      Self::End => "Whence::End",
      Self::Current => "Whence::Current",
    }
  }

  pub fn __eq__(&self, other: Self) -> bool {
    *self == other
  }

  pub fn __ne__(&self, other: Self) -> bool {
    *self != other
  }

  pub fn __hash__(&self) -> u64 {
    (*self as u8) as u64
  }

  pub fn __int__(&self) -> u8 {
    *self as u8
  }
}

/// The `SeekFrom` struct is used to specify a position in a stream for seeking operations.
/// It combines a `Whence` value with an offset.
#[derive(Copy, Clone, Eq, PartialEq, Hash)]
#[pyclass]
pub struct SeekFrom {
  /// the `Whence` value of the `SeekFrom` instance.
  #[pyo3(get, set)]
  whence: Whence,
  /// the offset of the `SeekFrom` instance.
  #[pyo3(get, set)]
  offset: i64,
}

impl From<std::io::SeekFrom> for SeekFrom {
  fn from(seek_from: std::io::SeekFrom) -> Self {
    match seek_from {
      std::io::SeekFrom::Start(offset) => Self::start(offset),
      std::io::SeekFrom::End(offset) => Self::end(offset),
      std::io::SeekFrom::Current(offset) => Self::current(offset),
    }
  }
}

impl From<SeekFrom> for std::io::SeekFrom {
  fn from(seek_from: SeekFrom) -> Self {
    match seek_from.whence {
      Whence::Start => Self::Start(seek_from.offset as u64),
      Whence::End => Self::End(seek_from.offset),
      Whence::Current => Self::Current(seek_from.offset),
    }
  }
}

#[pymethods]
impl SeekFrom {
  #[new]
  pub fn new(offset: i64, whence: Whence) -> Self {
    Self { whence, offset }
  }

  /// Creates a new `SeekFrom` instance with `Whence::Start` and the specified offset.
  #[staticmethod]
  pub fn start(offset: u64) -> Self {
    Self::new(offset as i64, Whence::Start)
  }

  /// Creates a new `SeekFrom` instance with `Whence::End` and the specified offset.
  #[staticmethod]
  pub fn end(offset: i64) -> Self {
    Self::new(offset, Whence::End)
  }

  /// Creates a new `SeekFrom` instance with `Whence::Current` and the specified offset.
  #[staticmethod]
  pub fn current(offset: i64) -> Self {
    Self::new(offset, Whence::Current)
  }

  pub fn __str__(&self) -> ::std::string::String {
    match self.whence {
      Whence::Start => format!("start({})", self.offset),
      Whence::End => format!("end({})", self.offset),
      Whence::Current => format!("current({})", self.offset),
    }
  }

  pub fn __repr__(&self) -> ::std::string::String {
    match self.whence {
      Whence::Start => format!("SeekFrom::Start({})", self.offset),
      Whence::End => format!("SeekFrom::End({})", self.offset),
      Whence::Current => format!("SeekFrom::Current({})", self.offset),
    }
  }

  pub fn __eq__(&self, other: Self) -> bool {
    self.whence == other.whence && self.offset == other.offset
  }

  pub fn __ne__(&self, other: Self) -> bool {
    self.whence != other.whence || self.offset != other.offset
  }

  pub fn __hash__(&self) -> u64 {
    let mut hasher = DefaultHasher::new();
    self.hash(&mut hasher);
    hasher.finish()
  }
}

#[doc(hidden)]
pub enum State<T> {
  Ok(T),
  Closed,
}

#[doc(hidden)]
pub mod __private {
  pub use super::*;
  pub use ::smallvec;
  pub use futures;
  pub use futures::lock::Mutex;
  pub use paste;
  pub use pyo3;
}

#[doc(hidden)]
pub trait AsyncReadWrite: AsyncRead + AsyncWrite + Send + Sync + Unpin + 'static {}

impl<T> AsyncReadWrite for T where T: AsyncRead + AsyncWrite + Send + Sync + Unpin + 'static {}

#[doc(hidden)]
pub trait AsyncBufReadWrite: AsyncBufRead + AsyncWrite + Send + Sync + Unpin + 'static {}

impl<T> AsyncBufReadWrite for T where T: AsyncBufRead + AsyncWrite + Send + Sync + Unpin + 'static {}

#[doc(hidden)]
pub trait AsyncSeekRead: AsyncRead + AsyncSeek + Send + Sync + Unpin + 'static {}

impl<T> AsyncSeekRead for T where T: AsyncRead + AsyncSeek + Send + Sync + Unpin + 'static {}

#[doc(hidden)]
pub trait AsyncSeekBufRead: AsyncBufRead + AsyncSeek + Send + Sync + Unpin + 'static {}

impl<T> AsyncSeekBufRead for T where T: AsyncBufRead + AsyncSeek + Send + Sync + Unpin + 'static {}

#[doc(hidden)]
pub trait AsyncSeekWrite: AsyncWrite + AsyncSeek + Send + Sync + Unpin + 'static {}

impl<T> AsyncSeekWrite for T where T: AsyncWrite + AsyncSeek + Send + Sync + Unpin + 'static {}

#[doc(hidden)]
pub trait AsyncSeekReadWrite: AsyncReadWrite + AsyncSeek + Send + Sync + Unpin + 'static {}

impl<T> AsyncSeekReadWrite for T where T: AsyncReadWrite + AsyncSeek + Send + Sync + Unpin + 'static {}

#[doc(hidden)]
pub trait AsyncSeekBufReadWrite:
  AsyncBufReadWrite + AsyncSeek + Send + Sync + Unpin + 'static
{
}

impl<T> AsyncSeekBufReadWrite for T where
  T: AsyncBufReadWrite + AsyncSeek + Send + Sync + Unpin + 'static
{
}

#[doc(hidden)]
#[macro_export]
macro_rules! __close {
  ($this:ident.$future_into_py: ident($py:ident)) => {{
    let state = $this.0.clone();
    $future_into_py($py, async move {
      let mut state = state.lock().await;
      match &*state {
        $crate::__private::State::Ok(_) => {
          *state = $crate::__private::State::Closed;
          Ok(())
        }
        $crate::__private::State::Closed => Ok(()),
      }
    })
  }};
}

#[doc(hidden)]
#[macro_export]
macro_rules! __writer_close {
  ($this:ident.$future_into_py: ident($py:ident)) => {{
    use $crate::__private::futures::AsyncWriteExt;

    let state = $this.0.clone();
    $future_into_py($py, async move {
      let mut state = state.lock().await;
      match &mut *state {
        $crate::__private::State::Ok(writer) => {
          writer.close().await.map_err(|err| {
            $crate::__private::pyo3::exceptions::PyIOError::new_err(err.to_string())
          })?;
          *state = $crate::__private::State::Closed;
          Ok(())
        }
        $crate::__private::State::Closed => Ok(()),
      }
    })
  }};
}

#[doc(hidden)]
#[macro_export]
macro_rules! __read {
  ($this:ident.$future_into_py: ident($py:ident, $chunk_size: ident)) => {{
    use $crate::__private::futures::AsyncReadExt;

    let state = $this.0.clone();
    $future_into_py($py, async move {
      let mut state = state.lock().await;
      match &mut *state {
        $crate::__private::State::Ok(reader) => {
          let mut buf: $crate::__private::Bytes = $crate::__private::smallvec::smallvec![0; $chunk_size];
          match reader.read(&mut buf).await {
            ::std::result::Result::Ok(n) => {
              buf.truncate(n);

              $crate::__private::pyo3::Python::with_gil(|py| $crate::__private::Buffer::new(buf).into_memory_view(py))
            }
            ::std::result::Result::Err(e) => ::std::result::Result::Err($crate::__private::pyo3::exceptions::PyIOError::new_err(e.to_string())),
          }
        }
        $crate::__private::State::Closed => ::std::result::Result::Err($crate::__private::pyo3::exceptions::PyIOError::new_err("reader is closed")),
      }
    })
  }};
}

#[doc(hidden)]
#[macro_export]
macro_rules! __read_exact {
  ($this:ident.$future_into_py: ident($py:ident, $bytes: ident)) => {{
    use $crate::__private::futures::AsyncReadExt;

    let state = $this.0.clone();
    $future_into_py($py, async move {
      let mut state = state.lock().await;
      match &mut *state {
        $crate::__private::State::Ok(reader) => {
          let mut buf: $crate::__private::Bytes = $crate::__private::smallvec::smallvec![0; $bytes];
          match reader.read_exact(&mut buf).await {
            Ok(_) => $crate::__private::pyo3::Python::with_gil(|py| $crate::__private::Buffer::new(buf).into_memory_view(py)),
            ::std::result::Result::Err(e) => ::std::result::Result::Err($crate::__private::pyo3::exceptions::PyIOError::new_err(e.to_string())),
          }
        }
        $crate::__private::State::Closed => ::std::result::Result::Err($crate::__private::pyo3::exceptions::PyIOError::new_err("reader is closed")),
      }
    })
  }};
}

#[doc(hidden)]
#[macro_export]
macro_rules! __read_to_end {
  ($this:ident.$future_into_py: ident($py:ident, $chunk_size: ident)) => {{
    use $crate::__private::futures::AsyncReadExt;

    let state = $this.0.clone();
    $future_into_py($py, async move {
      let mut state = state.lock().await;
      match &mut *state {
        $crate::__private::State::Ok(reader) => {
          let mut buf = $crate::__private::Bytes::new();
          loop {
            // Resize buffer to accommodate new chunk
            let old_len = buf.len();
            buf.resize(old_len + $chunk_size, 0);

            match reader.read(&mut buf[old_len..]).await {
              Ok(0) => {
                buf.truncate(old_len); // Truncate buffer to actual data length
                break; // End of file
              }
              ::std::result::Result::Ok(n) => {
                buf.truncate(old_len + n); // Truncate buffer to actual data length
              }
              ::std::result::Result::Err(e) => {
                return ::std::result::Result::Err(
                  $crate::__private::pyo3::exceptions::PyIOError::new_err(e.to_string()),
                )
              }
            }
          }

          $crate::__private::pyo3::Python::with_gil(|py| {
            $crate::__private::Buffer::new(buf).into_memory_view(py)
          })
        }
        $crate::__private::State::Closed => ::std::result::Result::Err(
          $crate::__private::pyo3::exceptions::PyIOError::new_err("reader is closed"),
        ),
      }
    })
  }};
}

#[doc(hidden)]
#[macro_export]
macro_rules! __read_to_string {
  ($this:ident.$future_into_py: ident($py:ident)) => {{
    use $crate::__private::futures::AsyncReadExt;

    let state = $this.0.clone();
    $future_into_py($py, async move {
      let mut state = state.lock().await;
      match &mut *state {
        $crate::__private::State::Ok(reader) => {
          let mut buf = ::std::string::String::new();
          reader
            .read_to_string(&mut buf)
            .await
            .map(|_| buf)
            .map_err(|e| $crate::__private::pyo3::exceptions::PyIOError::new_err(e.to_string()))
        }
        $crate::__private::State::Closed => ::std::result::Result::Err(
          $crate::__private::pyo3::exceptions::PyIOError::new_err("reader is closed"),
        ),
      }
    })
  }};
}

#[doc(hidden)]
#[macro_export]
macro_rules! __write {
  ($this:ident.$future_into_py: ident($py:ident, $bytes: ident)) => {{
    use $crate::__private::futures::AsyncWriteExt;

    let state = $this.0.clone();
    let bytes = $crate::__private::Bytes::from($bytes);
    $future_into_py($py, async move {
      let mut state = state.lock().await;
      match &mut *state {
        $crate::__private::State::Ok(writer) => writer
          .write(&bytes)
          .await
          .map_err(|err| $crate::__private::pyo3::exceptions::PyIOError::new_err(err.to_string())),
        $crate::__private::State::Closed => ::std::result::Result::Err(
          $crate::__private::pyo3::exceptions::PyIOError::new_err("writer is closed"),
        ),
      }
    })
  }};
}

#[doc(hidden)]
#[macro_export]
macro_rules! __write_all {
  ($this:ident.$future_into_py: ident($py:ident, $bytes: ident)) => {{
    use $crate::__private::futures::AsyncWriteExt;

    let state = $this.0.clone();
    let bytes = $crate::__private::Bytes::from($bytes);
    $future_into_py($py, async move {
      let mut state = state.lock().await;
      match &mut *state {
        $crate::__private::State::Ok(writer) => writer
          .write_all(&bytes)
          .await
          .map_err(|err| $crate::__private::pyo3::exceptions::PyIOError::new_err(err.to_string())),
        $crate::__private::State::Closed => ::std::result::Result::Err(
          $crate::__private::pyo3::exceptions::PyIOError::new_err("writer is closed"),
        ),
      }
    })
  }};
}

#[doc(hidden)]
#[macro_export]
macro_rules! __flush {
  ($this:ident.$future_into_py: ident($py:ident)) => {{
    use $crate::__private::futures::AsyncWriteExt;

    let state = $this.0.clone();
    $future_into_py($py, async move {
      let mut state = state.lock().await;
      match &mut *state {
        $crate::__private::State::Ok(writer) => writer
          .flush()
          .await
          .map_err(|err| $crate::__private::pyo3::exceptions::PyIOError::new_err(err.to_string())),
        $crate::__private::State::Closed => ::std::result::Result::Err(
          $crate::__private::pyo3::exceptions::PyIOError::new_err("writer is closed"),
        ),
      }
    })
  }};
}

#[doc(hidden)]
#[macro_export]
macro_rules! __fill_buf {
  ($this:ident.$future_into_py: ident($py:ident)) => {{
    use $crate::__private::futures::AsyncBufReadExt;

    let state = $this.0.clone();
    $future_into_py($py, async move {
      let mut state = state.lock().await;
      match &mut *state {
        $crate::__private::State::Ok(reader) => {
          let buf = reader
            .fill_buf()
            .await
            .map(|buf| $crate::__private::Buffer::from(buf))
            .map_err(|err| {
              $crate::__private::pyo3::exceptions::PyIOError::new_err(err.to_string())
            })?;

          $crate::__private::pyo3::Python::with_gil(|py| buf.into_memory_view(py))
        }
        $crate::__private::State::Closed => ::std::result::Result::Err(
          $crate::__private::pyo3::exceptions::PyIOError::new_err("reader is closed"),
        ),
      }
    })
  }};
}

#[doc(hidden)]
#[macro_export]
macro_rules! __consume {
  ($this:ident.$future_into_py: ident($py:ident, $amt:ident)) => {{
    use $crate::__private::futures::AsyncBufReadExt;

    let state = $this.0.clone();
    $future_into_py($py, async move {
      let mut state = state.lock().await;
      match &mut *state {
        $crate::__private::State::Ok(reader) => Ok(reader.consume_unpin($amt)),
        $crate::__private::State::Closed => ::std::result::Result::Err(
          $crate::__private::pyo3::exceptions::PyIOError::new_err("reader is closed"),
        ),
      }
    })
  }};
}

#[doc(hidden)]
#[macro_export]
macro_rules! __read_until {
  ($this:ident.$future_into_py: ident($py:ident, $byte:ident)) => {{
    use $crate::__private::futures::AsyncBufReadExt;

    let state = $this.0.clone();
    $future_into_py($py, async move {
      let mut state = state.lock().await;
      match &mut *state {
        $crate::__private::State::Ok(reader) => {
          let mut buf = ::std::vec::Vec::new();
          let buf = reader
            .read_until($byte, &mut buf)
            .await
            .map(|_| $crate::__private::Buffer::from(buf))
            .map_err(|err| {
              $crate::__private::pyo3::exceptions::PyIOError::new_err(err.to_string())
            })?;

          $crate::__private::pyo3::Python::with_gil(|py| buf.into_memory_view(py))
        }
        $crate::__private::State::Closed => ::std::result::Result::Err(
          $crate::__private::pyo3::exceptions::PyIOError::new_err("reader is closed"),
        ),
      }
    })
  }};
}

#[doc(hidden)]
#[macro_export]
macro_rules! __read_line {
  ($this:ident.$future_into_py: ident($py:ident)) => {{
    use $crate::__private::futures::AsyncBufReadExt;

    let state = $this.0.clone();
    $future_into_py($py, async move {
      let mut state = state.lock().await;
      match &mut *state {
        $crate::__private::State::Ok(reader) => {
          let mut buf = ::std::string::String::new();
          reader
            .read_line(&mut buf)
            .await
            .map(|_| buf)
            .map_err(|err| $crate::__private::pyo3::exceptions::PyIOError::new_err(err.to_string()))
        }
        $crate::__private::State::Closed => ::std::result::Result::Err(
          $crate::__private::pyo3::exceptions::PyIOError::new_err("reader is closed"),
        ),
      }
    })
  }};
}

#[doc(hidden)]
#[macro_export]
macro_rules! __lines {
  ($this:ident.$future_into_py: ident($py:ident)) => {{
    use $crate::__private::futures::{AsyncBufReadExt, StreamExt};

    let state = $this.0.clone();
    $future_into_py($py, async move {
      let mut state = state.lock().await;
      match &mut *state {
        $crate::__private::State::Ok(reader) => {
          let mut lines = reader.lines();
          let mut buf = ::std::vec::Vec::new();
          while let ::std::option::Option::Some(line) = lines.next().await {
            buf.push(line.map_err(|err| {
              $crate::__private::pyo3::exceptions::PyIOError::new_err(err.to_string())
            })?);
          }
          Ok(buf)
        }
        $crate::__private::State::Closed => ::std::result::Result::Err(
          $crate::__private::pyo3::exceptions::PyIOError::new_err("reader is closed"),
        ),
      }
    })
  }};
}

#[doc(hidden)]
#[macro_export]
macro_rules! __seek {
  ($this:ident.$future_into_py: ident($py:ident, $seek_from:ident)) => {{
    use $crate::__private::futures::AsyncSeekExt;

    let state = $this.0.clone();
    $future_into_py($py, async move {
      let mut state = state.lock().await;
      match &mut *state {
        $crate::__private::State::Ok(reader) => reader
          .seek($seek_from.into())
          .await
          .map_err(|err| $crate::__private::pyo3::exceptions::PyIOError::new_err(err.to_string())),
        $crate::__private::State::Closed => ::std::result::Result::Err(
          $crate::__private::pyo3::exceptions::PyIOError::new_err("seeker is closed"),
        ),
      }
    })
  }};
}

#[doc(hidden)]
#[macro_export]
macro_rules! __position {
  ($this:ident.$future_into_py: ident($py:ident)) => {{
    use $crate::__private::futures::AsyncSeekExt;

    let state = $this.0.clone();
    $future_into_py($py, async move {
      let mut state = state.lock().await;
      match &mut *state {
        $crate::__private::State::Ok(reader) => reader
          .stream_position()
          .await
          .map_err(|err| $crate::__private::pyo3::exceptions::PyIOError::new_err(err.to_string())),
        $crate::__private::State::Closed => ::std::result::Result::Err(
          $crate::__private::pyo3::exceptions::PyIOError::new_err("seeker is closed"),
        ),
      }
    })
  }};
}

#[doc(hidden)]
#[macro_export]
macro_rules! __impl_async_read {
  ($ty:ty) => {
    impl $crate::__private::futures::AsyncRead for $ty {
      fn poll_read(
        self: ::std::pin::Pin<&mut Self>,
        cx: &mut ::std::task::Context<'_>,
        buf: &mut [u8],
      ) -> ::std::task::Poll<std::io::Result<usize>> {
        let state = self.0.lock();
        $crate::__private::futures::pin_mut!(state);
        match state.poll(cx) {
          ::std::task::Poll::Ready(mut state) => match &mut *state {
            $crate::__private::State::Ok(reader) => {
              let reader = ::std::pin::Pin::new(&mut *reader);
              reader.poll_read(cx, buf)
            }
            $crate::__private::State::Closed => {
              ::std::task::Poll::Ready(::std::result::Result::Err(std::io::Error::new(
                std::io::ErrorKind::BrokenPipe,
                "reader is closed",
              )))
            }
          },
          ::std::task::Poll::Pending => ::std::task::Poll::Pending,
        }
      }
    }
  };
}

#[doc(hidden)]
#[macro_export]
macro_rules! __impl_async_write {
  ($ty: ty) => {
    impl $crate::__private::futures::AsyncWrite for $ty {
      fn poll_write(
        self: ::std::pin::Pin<&mut Self>,
        cx: &mut ::std::task::Context<'_>,
        buf: &[u8],
      ) -> ::std::task::Poll<std::io::Result<usize>> {
        let state = self.0.lock();
        $crate::__private::futures::pin_mut!(state);
        match state.poll(cx) {
          ::std::task::Poll::Ready(mut state) => match &mut *state {
            $crate::__private::State::Ok(writer) => {
              let writer = ::std::pin::Pin::new(&mut *writer);
              writer.poll_write(cx, buf)
            }
            $crate::__private::State::Closed => {
              ::std::task::Poll::Ready(::std::result::Result::Err(std::io::Error::new(
                std::io::ErrorKind::BrokenPipe,
                "writer is closed",
              )))
            }
          },
          ::std::task::Poll::Pending => ::std::task::Poll::Pending,
        }
      }

      fn poll_flush(
        self: ::std::pin::Pin<&mut Self>,
        cx: &mut ::std::task::Context<'_>,
      ) -> ::std::task::Poll<std::io::Result<()>> {
        let state = self.0.lock();
        $crate::__private::futures::pin_mut!(state);
        match state.poll(cx) {
          ::std::task::Poll::Ready(mut state) => match &mut *state {
            $crate::__private::State::Ok(writer) => {
              let writer = ::std::pin::Pin::new(&mut *writer);
              writer.poll_flush(cx)
            }
            $crate::__private::State::Closed => {
              ::std::task::Poll::Ready(::std::result::Result::Err(std::io::Error::new(
                std::io::ErrorKind::BrokenPipe,
                "writer is closed",
              )))
            }
          },
          ::std::task::Poll::Pending => ::std::task::Poll::Pending,
        }
      }

      fn poll_close(
        self: ::std::pin::Pin<&mut Self>,
        cx: &mut ::std::task::Context<'_>,
      ) -> ::std::task::Poll<std::io::Result<()>> {
        let state = self.0.lock();
        $crate::__private::futures::pin_mut!(state);
        match state.poll(cx) {
          ::std::task::Poll::Ready(mut state) => match &mut *state {
            $crate::__private::State::Ok(writer) => {
              let writer = ::std::pin::Pin::new(&mut *writer);
              writer.poll_close(cx)
            }
            $crate::__private::State::Closed => {
              ::std::task::Poll::Ready(::std::result::Result::Err(std::io::Error::new(
                std::io::ErrorKind::BrokenPipe,
                "writer is closed",
              )))
            }
          },
          ::std::task::Poll::Pending => ::std::task::Poll::Pending,
        }
      }
    }
  };
}

#[doc(hidden)]
#[macro_export]
macro_rules! __impl_async_seek {
  ($ty:ident) => {
    impl $crate::__private::futures::AsyncSeek for $ty {
      fn poll_seek(
        self: ::std::pin::Pin<&mut Self>,
        cx: &mut ::std::task::Context<'_>,
        pos: std::io::SeekFrom,
      ) -> ::std::task::Poll<std::io::Result<u64>> {
        let state = self.0.lock();
        $crate::__private::futures::pin_mut!(state);
        match state.poll(cx) {
          ::std::task::Poll::Ready(mut state) => match &mut *state {
            $crate::__private::State::Ok(reader) => {
              let reader = ::std::pin::Pin::new(&mut *reader);
              reader.poll_seek(cx, pos)
            }
            $crate::__private::State::Closed => {
              ::std::task::Poll::Ready(::std::result::Result::Err(std::io::Error::new(
                std::io::ErrorKind::BrokenPipe,
                "reader is closed",
              )))
            }
          },
          ::std::task::Poll::Pending => ::std::task::Poll::Pending,
        }
      }
    }
  };
}

#[macro_export]
macro_rules! async_seekable_writer {
  ($future_into_py: ident($name:literal: $inner:ty $({
    $($tt:tt)*
  })?)) => {
    $crate::__private::paste::paste! {
      #[doc = concat!("`", $name, "` implements `AsyncWrite` and `AsyncSeek`.")]
      #[derive(Clone)]
      #[$crate::__private::pyo3::prelude::pyclass(name = $name, crate = "::pyo3io_macros::__private::pyo3")]
      pub struct [< $name:camel >](::std::sync::Arc<$crate::__private::Mutex<$crate::__private::State<$inner>>>);

      impl [< $name:camel >] {
        pub fn new(inner: $inner) -> Self {
          Self(::std::sync::Arc::new($crate::__private::Mutex::new($crate::__private::State::Ok(inner))))
        }
      }

      $crate::__impl_async_write!([< $name:camel >]);

      $crate::__impl_async_seek!([< $name:camel >]);

      #[$crate::__private::pyo3::prelude::pymethods(crate = "::pyo3io_macros::__private::pyo3")]
      impl [< $name:camel >] {

        $($($tt)*)?

        pub fn write<'a>(&self, py: $crate::__private::pyo3::Python<'a>, bytes: &'a [u8]) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__write!(self.$future_into_py(py, bytes))
        }

        pub fn write_all<'a>(&self, py: $crate::__private::pyo3::Python<'a>, bytes: &'a [u8]) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__write_all!(self.$future_into_py(py, bytes))
        }

        pub fn flush<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__flush!(self.$future_into_py(py))
        }

        pub fn seek<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>, seek_from: $crate::__private::SeekFrom) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__seek!(self.$future_into_py(py, seek_from))
        }

        pub fn position<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__position!(self.$future_into_py(py))
        }

        pub fn close<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__writer_close!(self.$future_into_py(py))
        }
      }
    }
  };
}

#[macro_export]
macro_rules! async_seekable_reader_writer {
  ($future_into_py: ident($name: literal: $inner:ty $({
    $($tt:tt)*
  })?)) => {
    $crate::__private::paste::paste! {
      #[doc = concat!("`", $name, "` implements `AsyncRead`, `AsyncWrite` and `AsyncSeek`.")]
      #[derive(Clone)]
      #[$crate::__private::pyo3::prelude::pyclass(name = $name, crate = "::pyo3io_macros::__private::pyo3")]
      pub struct [< $name:camel >] (::std::sync::Arc<$crate::__private::Mutex<$crate::__private::State<$inner>>>);

      impl [< $name:camel >] {
        pub fn new(inner: $inner) -> Self {
          Self(::std::sync::Arc::new($crate::__private::Mutex::new($crate::__private::State::Ok(inner))))
        }
      }

      $crate::__impl_async_read!([< $name:camel >]);

      $crate::__impl_async_write!([< $name:camel >]);

      $crate::__impl_async_seek!([< $name:camel >]);

      #[$crate::__private::pyo3::prelude::pymethods(crate = "::pyo3io_macros::__private::pyo3")]
      impl [< $name:camel >] {
        $($($tt)*)?

        #[pyo3(signature = (chunk_size = 1024))]
        pub fn read<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>, chunk_size: usize) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__read!(self.$future_into_py(py, chunk_size))
        }

        pub fn read_exact<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>, bytes: usize) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__read_exact!(self.$future_into_py(py, bytes))
        }

        #[pyo3(signature = (chunk_size = 1024))]
        pub fn read_to_end<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>, chunk_size: usize) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__read_to_end!(self.$future_into_py(py, chunk_size))
        }

        pub fn read_to_string<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__read_to_string!(self.$future_into_py(py))
        }

        pub fn write<'a>(&self, py: $crate::__private::pyo3::Python<'a>, bytes: &'a [u8]) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__write!(self.$future_into_py(py, bytes))
        }

        pub fn write_all<'a>(&self, py: $crate::__private::pyo3::Python<'a>, bytes: &'a [u8]) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__write_all!(self.$future_into_py(py, bytes))
        }

        pub fn flush<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__flush!(self.$future_into_py(py))
        }

        pub fn seek<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>, seek_from: $crate::__private::SeekFrom)
          -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
         $crate::__seek!(self.$future_into_py(py, seek_from))
        }

        pub fn position<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__position!(self.$future_into_py(py))
        }

        pub fn close<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__writer_close!(self.$future_into_py(py))
        }
      }
    }
  };
}

#[macro_export]
macro_rules! async_seekable_buf_reader_writer {
  ($future_into_py: ident($name: literal: $inner:ty $({
    $($tt:tt)*
  })?)) => {
    $crate::__private::paste::paste! {
      #[doc = concat!("`", $name, "` implements `AsyncBufRead`, `AsyncWrite` and `AsyncSeek`.")]
      #[derive(Clone)]
      #[$crate::__private::pyo3::prelude::pyclass(name = $name, crate = "::pyo3io_macros::__private::pyo3")]
      pub struct [< $name:camel >] (::std::sync::Arc<$crate::__private::Mutex<$crate::__private::State<$inner>>>);

      impl [< $name:camel >] {
        pub fn new(inner: $inner) -> Self {
          Self(::std::sync::Arc::new($crate::__private::Mutex::new($crate::__private::State::Ok(inner))))
        }
      }

      $crate::__impl_async_read!([< $name:camel >]);

      $crate::__impl_async_write!([< $name:camel >]);

      $crate::__impl_async_seek!([< $name:camel >]);

      #[$crate::__private::pyo3::prelude::pymethods(crate = "::pyo3io_macros::__private::pyo3")]
      impl [< $name:camel >] {
        $($($tt)*)?

        #[pyo3(signature = (chunk_size = 1024))]
        pub fn read<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>, chunk_size: usize) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__read!(self.$future_into_py(py, chunk_size))
        }

        pub fn read_exact<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>, bytes: usize) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__read_exact!(self.$future_into_py(py, bytes))
        }

        #[pyo3(signature = (chunk_size = 1024))]
        pub fn read_to_end<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>, chunk_size: usize) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__read_to_end!(self.$future_into_py(py, chunk_size))
        }

        pub fn read_to_string<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__read_to_string!(self.$future_into_py(py))
        }

        pub fn write<'a>(&self, py: $crate::__private::pyo3::Python<'a>, bytes: &'a [u8]) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__write!(self.$future_into_py(py, bytes))
        }

        pub fn write_all<'a>(&self, py: $crate::__private::pyo3::Python<'a>, bytes: &'a [u8]) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__write_all!(self.$future_into_py(py, bytes))
        }

        pub fn flush<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__flush!(self.$future_into_py(py))
        }

        pub fn seek<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>, seek_from: $crate::__private::SeekFrom)
          -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
         $crate::__seek!(self.$future_into_py(py, seek_from))
        }

        pub fn position<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__position!(self.$future_into_py(py))
        }

        pub fn fill_buf<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__fill_buf!(self.$future_into_py(py))
        }

        pub fn consume<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>, amt: usize) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__consume!(self.$future_into_py(py, amt))
        }

        pub fn read_until<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>, byte: u8) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__read_until!(self.$future_into_py(py, byte))
        }

        pub fn read_line<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__read_line!(self.$future_into_py(py))
        }

        pub fn lines<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__lines!(self.$future_into_py(py))
        }

        pub fn close<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__writer_close!(self.$future_into_py(py))
        }
      }
    }
  };
}

#[macro_export]
macro_rules! async_reader {
  ($future_into_py: ident($name: literal: $inner:ty $({
    $($tt:tt)*
  })?)) => {
    $crate::__private::paste::paste! {
      #[doc = concat!("`", $name, "` implements `AsyncRead`.")]
      #[derive(Clone)]
      #[$crate::__private::pyo3::prelude::pyclass(name = $name, crate = "::pyo3io_macros::__private::pyo3")]
      pub struct [< $name:camel >] (::std::sync::Arc<$crate::__private::Mutex<$crate::__private::State<$inner>>>);

      impl [< $name:camel >] {
        pub fn new(inner: $inner) -> Self {
          Self(::std::sync::Arc::new($crate::__private::Mutex::new($crate::__private::State::Ok(inner))))
        }
      }

      $crate::__impl_async_read!([< $name:camel >]);

      #[$crate::__private::pyo3::prelude::pymethods(crate = "::pyo3io_macros::__private::pyo3")]
      impl [< $name:camel >] {
        $($($tt)*)?

        #[pyo3(signature = (chunk_size = 1024))]
        pub fn read<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>, chunk_size: usize) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__read!(self.$future_into_py(py, chunk_size))
        }

        pub fn read_exact<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>, bytes: usize) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__read_exact!(self.$future_into_py(py, bytes))
        }

        #[pyo3(signature = (chunk_size = 1024))]
        pub fn read_to_end<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>, chunk_size: usize) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__read_to_end!(self.$future_into_py(py, chunk_size))
        }

        pub fn read_to_string<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__read_to_string!(self.$future_into_py(py))
        }

        pub fn close<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
         $crate::__close!(self.$future_into_py(py))
        }
      }
    }
  };
}

#[macro_export]
macro_rules! async_writer {
  ($future_into_py: ident($name: literal: $inner:ty $({
    $($tt:tt)*
  })?)) => {
    $crate::__private::paste::paste! {
      #[doc = concat!("`", $name, "` implements `AsyncWrite`.")]
      #[derive(Clone)]
      #[$crate::__private::pyo3::prelude::pyclass(name = $name, crate = "::pyo3io_macros::__private::pyo3")]
      pub struct [< $name:camel >] (::std::sync::Arc<$crate::__private::Mutex<$crate::__private::State<$inner>>>);

      impl [< $name:camel >] {
        pub fn new(inner: $inner) -> Self {
          Self(::std::sync::Arc::new($crate::__private::Mutex::new($crate::__private::State::Ok(inner))))
        }
      }

      $crate::__impl_async_write!([< $name:camel >]);

      #[$crate::__private::pyo3::prelude::pymethods(crate = "::pyo3io_macros::__private::pyo3")]
      impl [< $name:camel >] {
        $($($tt)*)?

        pub fn write<'a>(&self, py: $crate::__private::pyo3::Python<'a>, bytes: &'a [u8]) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__write!(self.$future_into_py(py, bytes))
        }

        pub fn write_all<'a>(&self, py: $crate::__private::pyo3::Python<'a>, bytes: &'a [u8]) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__write_all!(self.$future_into_py(py, bytes))
        }

        pub fn flush<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__flush!(self.$future_into_py(py))
        }

        pub fn close<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__writer_close!(self.$future_into_py(py))
        }
      }
    }
  };
}

#[macro_export]
macro_rules! async_reader_writer {
  ($future_into_py: ident($name: literal: $inner:ty $({
    $($tt:tt)*
  })?)) => {
    $crate::__private::paste::paste! {
      #[doc = concat!("`", $name, "` implements `AsyncRead` and `AsyncWrite`.")]
      #[derive(Clone)]
      #[$crate::__private::pyo3::prelude::pyclass(name = $name, crate = "::pyo3io_macros::__private::pyo3")]
      pub struct [< $name:camel >] (::std::sync::Arc<$crate::__private::Mutex<$crate::__private::State<$inner>>>);

      impl [< $name:camel >] {
        pub fn new(inner: $inner) -> Self {
          Self(::std::sync::Arc::new($crate::__private::Mutex::new($crate::__private::State::Ok(inner))))
        }
      }

      $crate::__impl_async_read!([< $name:camel >]);

      $crate::__impl_async_write!([< $name:camel >]);

      #[$crate::__private::pyo3::prelude::pymethods(crate = "::pyo3io_macros::__private::pyo3")]
      impl [< $name:camel >] {
        $($($tt)*)?

        #[pyo3(signature = (chunk_size = 1024))]
        pub fn read<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>, chunk_size: usize) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__read!(self.$future_into_py(py, chunk_size))
        }

        pub fn read_exact<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>, bytes: usize) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__read_exact!(self.$future_into_py(py, bytes))
        }

        #[pyo3(signature = (chunk_size = 1024))]
        pub fn read_to_end<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>, chunk_size: usize) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__read_to_end!(self.$future_into_py(py, chunk_size))
        }

        pub fn read_to_string<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__read_to_string!(self.$future_into_py(py))
        }

        pub fn write<'a>(&self, py: $crate::__private::pyo3::Python<'a>, bytes: &'a [u8]) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__write!(self.$future_into_py(py, bytes))
        }

        pub fn write_all<'a>(&self, py: $crate::__private::pyo3::Python<'a>, bytes: &'a [u8]) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__write_all!(self.$future_into_py(py, bytes))
        }

        pub fn flush<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__flush!(self.$future_into_py(py))
        }

        pub fn close<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__writer_close!(self.$future_into_py(py))
        }
      }
    }
  }
}

#[macro_export]
macro_rules! async_buf_reader {
  ($future_into_py: ident($name: literal: $inner:ty $({
    $($tt:tt)*
  })?)) => {
    $crate::__private::paste::paste! {
      #[doc = concat!("`", $name, "` implements `AsyncBufRead`.")]
      #[derive(Clone)]
      #[$crate::__private::pyo3::prelude::pyclass(name = $name, crate = "::pyo3io_macros::__private::pyo3")]
      pub struct [< $name:camel >] (::std::sync::Arc<$crate::__private::Mutex<$crate::__private::State<$inner>>>);

      impl [< $name:camel >] {
        pub fn new(inner: $inner) -> Self {
          Self(::std::sync::Arc::new($crate::__private::Mutex::new($crate::__private::State::Ok(inner))))
        }
      }

      $crate::__impl_async_read!([< $name:camel >]);

      #[$crate::__private::pyo3::prelude::pymethods(crate = "::pyo3io_macros::__private::pyo3")]
      impl [< $name:camel >] {
        $($($tt)*)?

        #[pyo3(signature = (chunk_size = 1024))]
        pub fn read<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>, chunk_size: usize) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__read!(self.$future_into_py(py, chunk_size))
        }

        pub fn read_exact<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>, bytes: usize) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__read_exact!(self.$future_into_py(py, bytes))
        }

        #[pyo3(signature = (chunk_size = 1024))]
        pub fn read_to_end<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>, chunk_size: usize) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__read_to_end!(self.$future_into_py(py, chunk_size))
        }

        pub fn read_to_string<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__read_to_string!(self.$future_into_py(py))
        }

        pub fn fill_buf<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__fill_buf!(self.$future_into_py(py))
        }

        pub fn consume<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>, amt: usize) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__consume!(self.$future_into_py(py, amt))
        }

        pub fn read_until<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>, byte: u8) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__read_until!(self.$future_into_py(py, byte))
        }

        pub fn read_line<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__read_line!(self.$future_into_py(py))
        }

        pub fn lines<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__lines!(self.$future_into_py(py))
        }

        pub fn close<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
         $crate::__close!(self.$future_into_py(py))
        }
      }
    }
  }
}

#[macro_export]
macro_rules! async_buf_reader_writer {
  ($future_into_py: ident($name: literal: $inner:ty $({
    $($tt:tt)*
  })?)) => {
    $crate::__private::paste::paste! {
      #[doc = concat!("`", $name, "` implements `AsyncBufRead` and `AsyncWrite`.")]
      #[derive(Clone)]
      #[$crate::__private::pyo3::prelude::pyclass(name = $name, crate = "::pyo3io_macros::__private::pyo3")]
      pub struct [< $name:camel >] (::std::sync::Arc<$crate::__private::Mutex<$crate::__private::State<$inner>>>);

      impl [< $name:camel >] {
        pub fn new(inner: $inner) -> Self {
          Self(::std::sync::Arc::new($crate::__private::Mutex::new($crate::__private::State::Ok(inner))))
        }
      }

      $crate::__impl_async_read!([< $name:camel >]);

      $crate::__impl_async_write!([< $name:camel >]);

      #[$crate::__private::pyo3::prelude::pymethods(crate = "::pyo3io_macros::__private::pyo3")]
      impl [< $name:camel >] {
        $($($tt)*)?

        #[pyo3(signature = (chunk_size = 1024))]
        pub fn read<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>, chunk_size: usize) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__read!(self.$future_into_py(py, chunk_size))
        }

        pub fn read_exact<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>, bytes: usize) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__read_exact!(self.$future_into_py(py, bytes))
        }

        #[pyo3(signature = (chunk_size = 1024))]
        pub fn read_to_end<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>, chunk_size: usize) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__read_to_end!(self.$future_into_py(py, chunk_size))
        }

        pub fn read_to_string<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__read_to_string!(self.$future_into_py(py))
        }

        pub fn write<'a>(&self, py: $crate::__private::pyo3::Python<'a>, bytes: &'a [u8]) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__write!(self.$future_into_py(py, bytes))
        }

        pub fn write_all<'a>(&self, py: $crate::__private::pyo3::Python<'a>, bytes: &'a [u8]) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__write_all!(self.$future_into_py(py, bytes))
        }

        pub fn flush<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__flush!(self.$future_into_py(py))
        }

        pub fn fill_buf<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__fill_buf!(self.$future_into_py(py))
        }

        pub fn consume<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>, amt: usize) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__consume!(self.$future_into_py(py, amt))
        }

        pub fn read_until<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>, byte: u8) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__read_until!(self.$future_into_py(py, byte))
        }

        pub fn read_line<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__read_line!(self.$future_into_py(py))
        }

        pub fn lines<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__lines!(self.$future_into_py(py))
        }

        pub fn close<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__writer_close!(self.$future_into_py(py))
        }
      }
    }
  }
}

#[macro_export]
macro_rules! async_seeker {
  ($future_into_py: ident($name: literal: $inner:ty $({
    $($tt:tt)*
  })?)) => {
    $crate::__private::paste::paste! {
      #[doc = concat!("`", $name, "` implements `AsyncSeek`.")]
      #[derive(Clone)]
      #[$crate::__private::pyo3::prelude::pyclass(name = $name, crate = "::pyo3io_macros::__private::pyo3")]
      pub struct [< $name:camel >] (::std::sync::Arc<$crate::__private::Mutex<$crate::__private::State<$inner>>>);

      impl [< $name:camel >] {
        pub fn new(inner: $inner) -> Self {
          Self(::std::sync::Arc::new($crate::__private::Mutex::new($crate::__private::State::Ok(inner))))
        }
      }

      $crate::__impl_async_seek!([< $name:camel >]);

      #[$crate::__private::pyo3::prelude::pymethods(crate = "::pyo3io_macros::__private::pyo3")]
      impl [< $name:camel >] {
        $($($tt)*)?

        pub fn seek<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>, seek_from: $crate::__private::SeekFrom)
          -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
         $crate::__seek!(self.$future_into_py(py, seek_from))
        }

        pub fn position<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__position!(self.$future_into_py(py))
        }

        pub fn close<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
         $crate::__close!(self.$future_into_py(py))
        }
      }
    }
  }
}

#[macro_export]
macro_rules! async_seekable_reader {
  ($future_into_py: ident($name: literal: $inner:ty $({
    $($tt:tt)*
  })?)) => {
    $crate::__private::paste::paste! {
      #[doc = concat!("`", $name, "` implements `AsyncRead` and `AsyncSeek`.")]
      #[derive(Clone)]
      #[$crate::__private::pyo3::prelude::pyclass(name = $name, crate = "::pyo3io_macros::__private::pyo3")]
      pub struct [< $name:camel >] (::std::sync::Arc<$crate::__private::Mutex<$crate::__private::State<$inner>>>);

      impl [< $name:camel >] {
        pub fn new(inner: $inner) -> Self {
          Self(::std::sync::Arc::new($crate::__private::Mutex::new($crate::__private::State::Ok(inner))))
        }
      }

      $crate::__impl_async_read!([< $name:camel >]);

      $crate::__impl_async_seek!([< $name:camel >]);

      #[$crate::__private::pyo3::prelude::pymethods(crate = "::pyo3io_macros::__private::pyo3")]
      impl [< $name:camel >] {
        $($($tt)*)?

        #[pyo3(signature = (chunk_size = 1024))]
        pub fn read<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>, chunk_size: usize) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__read!(self.$future_into_py(py, chunk_size))
        }

        pub fn read_exact<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>, bytes: usize) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__read_exact!(self.$future_into_py(py, bytes))
        }

        #[pyo3(signature = (chunk_size = 1024))]
        pub fn read_to_end<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>, chunk_size: usize) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__read_to_end!(self.$future_into_py(py, chunk_size))
        }

        pub fn read_to_string<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__read_to_string!(self.$future_into_py(py))
        }

        pub fn seek<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>, seek_from: $crate::__private::SeekFrom)
          -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
         $crate::__seek!(self.$future_into_py(py, seek_from))
        }

        pub fn position<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__position!(self.$future_into_py(py))
        }

        pub fn close<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
         $crate::__close!(self.$future_into_py(py))
        }
      }
    }
  }
}

#[macro_export]
macro_rules! async_seekable_buf_reader {
  ($future_into_py: ident($name: literal: $inner:ty $({
    $($tt:tt)*
  })?)) => {
    $crate::__private::paste::paste! {
      #[doc = concat!("`", $name, "` implements `AsyncBufRead` and `AsyncSeek`.")]
      #[derive(Clone)]
      #[$crate::__private::pyo3::prelude::pyclass(name = $name, crate = "::pyo3io_macros::__private::pyo3")]
      pub struct [< $name:camel >] (::std::sync::Arc<$crate::__private::Mutex<$crate::__private::State<$inner>>>);

      impl [< $name:camel >] {
        pub fn new(inner: $inner) -> Self {
          Self(::std::sync::Arc::new($crate::__private::Mutex::new($crate::__private::State::Ok(inner))))
        }
      }

      $crate::__impl_async_read!([< $name:camel >]);

      $crate::__impl_async_seek!([< $name:camel >]);

      #[$crate::__private::pyo3::prelude::pymethods(crate = "::pyo3io_macros::__private::pyo3")]
      impl [< $name:camel >] {
        $($($tt)*)?

        #[pyo3(signature = (chunk_size = 1024))]
        pub fn read<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>, chunk_size: usize) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__read!(self.$future_into_py(py, chunk_size))
        }

        pub fn read_exact<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>, bytes: usize) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__read_exact!(self.$future_into_py(py, bytes))
        }

        #[pyo3(signature = (chunk_size = 1024))]
        pub fn read_to_end<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>, chunk_size: usize) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__read_to_end!(self.$future_into_py(py, chunk_size))
        }

        pub fn read_to_string<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__read_to_string!(self.$future_into_py(py))
        }

        pub fn seek<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>, seek_from: $crate::__private::SeekFrom)
          -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
         $crate::__seek!(self.$future_into_py(py, seek_from))
        }

        pub fn position<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__position!(self.$future_into_py(py))
        }

        pub fn fill_buf<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__fill_buf!(self.$future_into_py(py))
        }

        pub fn consume<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>, amt: usize) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__consume!(self.$future_into_py(py, amt))
        }

        pub fn read_until<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>, byte: u8) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__read_until!(self.$future_into_py(py, byte))
        }

        pub fn read_line<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__read_line!(self.$future_into_py(py))
        }

        pub fn lines<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
          $crate::__lines!(self.$future_into_py(py))
        }

        pub fn close<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
         $crate::__close!(self.$future_into_py(py))
        }
      }
    }
  };
}

pub fn register_types(m: &PyModule) -> PyResult<()> {
  m.add_class::<Whence>()?;
  m.add_class::<SeekFrom>()?;
  Ok(())
}

/// Register an async runtime.
///
/// # Example
///
/// ```
/// use pyo3io_macros::register_async_runtime;
///
/// register_async_runtime!(
///  #[cfg(feature = "tokio")]
///  #[cfg_attr(docsrs, doc(cfg(feature = "tokio")))]
///  pub mod tokio(use pyo3_asyncio::tokio::future_into_py);
/// );
///
/// ```
#[macro_export]
macro_rules! register_async_runtime {
  (
    $(#[$outer:meta])*
    $vis:vis mod $name:ident(use $future_into_py: path) $({
      $($tt:tt)*
    })?
    $(;)?
  ) => {
    $vis mod $name {
      use $crate::__private::{futures::*, pyo3::*};
      use $future_into_py as future_into_py;
      $($($tt)*)?

      $crate::async_reader!(future_into_py("AsyncReader": ::std::boxed::Box<dyn $crate::__private::futures::AsyncRead + ::core::marker::Send + ::core::marker::Sync + ::core::marker::Unpin + 'static>));
      $crate::async_writer!(future_into_py("AsyncWriter": ::std::boxed::Box<dyn $crate::__private::futures::AsyncWrite + ::core::marker::Send + ::core::marker::Sync + ::core::marker::Unpin + 'static>));
      $crate::async_reader_writer!(future_into_py("AsyncReaderWriter": ::std::boxed::Box<dyn $crate::AsyncReadWrite>));
      $crate::async_buf_reader!(future_into_py("AsyncBufReader": ::std::boxed::Box<dyn $crate::__private::futures::AsyncBufRead + ::core::marker::Send + ::core::marker::Sync + ::core::marker::Unpin + 'static>));
      $crate::async_buf_reader_writer!(future_into_py("AsyncBufReaderWriter": ::std::boxed::Box<dyn $crate::AsyncBufReadWrite>));
      $crate::async_seeker!(future_into_py("AsyncSeeker": ::std::boxed::Box<dyn $crate::__private::futures::AsyncSeek + ::core::marker::Send + ::core::marker::Sync + ::core::marker::Unpin + 'static>));
      $crate::async_seekable_reader!(future_into_py("AsyncSeekableReader": ::std::boxed::Box<dyn $crate::AsyncSeekRead>));
      $crate::async_seekable_buf_reader!(future_into_py("AsyncSeekableBufReader": ::std::boxed::Box<dyn $crate::AsyncSeekBufRead>));
      $crate::async_seekable_writer!(future_into_py("AsyncSeekableWriter": ::std::boxed::Box<dyn $crate::AsyncSeekWrite>));
      $crate::async_seekable_reader_writer!(future_into_py("AsyncSeekableReaderWriter": ::std::boxed::Box<dyn $crate::AsyncSeekReadWrite>));
      $crate::async_seekable_buf_reader_writer!(future_into_py("AsyncSeekableBufReaderWriter": ::std::boxed::Box<dyn $crate::AsyncSeekBufReadWrite>));

      /// Register all ffi I/O structs in to Python module.
      pub fn register_types(m: &$crate::__private::pyo3::prelude::PyModule) -> $crate::__private::pyo3::PyResult<()> {
        m.add_class::<AsyncReader>()?;
        m.add_class::<AsyncWriter>()?;
        m.add_class::<AsyncReaderWriter>()?;
        m.add_class::<AsyncBufReader>()?;
        m.add_class::<AsyncBufReaderWriter>()?;
        m.add_class::<AsyncSeeker>()?;
        m.add_class::<AsyncSeekableReader>()?;
        m.add_class::<AsyncSeekableBufReader>()?;
        m.add_class::<AsyncSeekableWriter>()?;
        m.add_class::<AsyncSeekableReaderWriter>()?;
        m.add_class::<AsyncSeekableBufReaderWriter>()?;
        ::std::result::Result::Ok(())
      }
    }
  }
}