use crate::models::*;
use crate::py::PyPagedSearchResult;
use crate::tokens::QueryToken;
use crate::SzurubooruClient;
use chrono::{DateTime, Utc};
use pyo3::exceptions::{PyRuntimeError, PyValueError};
use pyo3::prelude::*;
use std::path::PathBuf;

#[pyclass(name = "SzurubooruAsyncClient", module = "szurubooru_client")]
/// An asynchronous client for Szurubooru
///
/// :see: :class:`~szurubooru_client.SzurubooruSyncClient` for supported parameters
pub struct PythonAsyncClient {
    client: SzurubooruClient,
}

#[pymethods]
impl PythonAsyncClient {
    #[new]
    #[pyo3(signature = (host, username=None, token=None, password=None, allow_insecure=None))]
    /// Creates a new instance of the Asynchornous client
    ///
    /// :see: :class:`~szurubooru_client.SzurubooruSyncClient` for supported parameters
    pub fn new(
        host: String,
        username: Option<String>,
        token: Option<String>,
        password: Option<String>,
        allow_insecure: Option<bool>,
    ) -> PyResult<Self> {
        let allow_insecure = allow_insecure.unwrap_or(false);

        match (username, token, password) {
            (Some(u), Some(t), None) => {
                let client = SzurubooruClient::new_with_token(&host, &u, &t, allow_insecure)?;
                Ok(PythonAsyncClient { client })
            }
            (Some(u), None, Some(p)) => {
                let client = SzurubooruClient::new_with_basic_auth(&host, &u, &p, allow_insecure)?;
                Ok(PythonAsyncClient { client })
            }
            (None, None, None) => {
                let client = SzurubooruClient::new_anonymous(&host, allow_insecure)?;
                Ok(PythonAsyncClient { client })
            }
            _ => Err(PyRuntimeError::new_err(
                "(Username and Token) or (Username and Password) must be provided",
            )),
        }
    }

    #[pyo3(signature = (fields=None))]
    /// List the available tag categories (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.list_tag_categories` for parameters and return type
    pub async fn list_tag_categories(
        &self,
        fields: Option<Vec<String>>,
    ) -> PyResult<Vec<TagCategoryResource>> {
        let request = self.client.with_optional_fields(fields);
        request
            .list_tag_categories()
            .await
            .map(|ltc| ltc.results)
            .map_err(Into::into)
    }

    #[pyo3(signature = (name, color=None, order=None, fields=None))]
    /// Creates a new tag category using the specified parameters (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.create_tag_category` for parameters and return type
    pub async fn create_tag_category(
        &self,
        name: String,
        color: Option<String>,
        order: Option<u32>,
        fields: Option<Vec<String>>,
    ) -> PyResult<TagCategoryResource> {
        let mut cutagcat = CreateUpdateTagCategoryBuilder::default();
        cutagcat.name(name);
        if let Some(color) = color {
            cutagcat.color(color);
        }
        if let Some(order) = order {
            cutagcat.order(order);
        }
        let cutagcat = cutagcat.build()?;
        self.client
            .with_optional_fields(fields)
            .create_tag_category(&cutagcat)
            .await
            .map_err(Into::into)
    }

    #[pyo3(signature = (name, version, new_name=None, color=None, order=None, fields=None))]
    /// Updates an existing tag category (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.update_tag_category` for parameters and return type
    pub async fn update_tag_category(
        &self,
        name: String,
        version: String,
        new_name: Option<String>,
        color: Option<String>,
        order: Option<u32>,
        fields: Option<Vec<String>>,
    ) -> PyResult<TagCategoryResource> {
        let mut cutag = CreateUpdateTagCategoryBuilder::default();
        let mut cutag = cutag.version(version);

        if let Some(name) = new_name {
            cutag = cutag.name(name);
        }
        if let Some(color) = color {
            cutag = cutag.color(color);
        }
        if let Some(order) = order {
            cutag = cutag.order(order);
        }

        let cutag = cutag.build()?;
        let request = self.client.with_optional_fields(fields);
        request
            .update_tag_category(name, &cutag)
            .await
            .map_err(Into::into)
    }

    #[pyo3(signature = (name, fields=None))]
    /// Fetches a tag category by name (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.get_tag_category` for parameters and return type
    pub async fn get_tag_category(
        &self,
        name: String,
        fields: Option<Vec<String>>,
    ) -> PyResult<TagCategoryResource> {
        self.client
            .with_optional_fields(fields)
            .get_tag_category(name)
            .await
            .map_err(Into::into)
    }

    #[pyo3(signature = (name, version))]
    /// Deletes a tag category (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.delete_tag_category` for parameters and return type
    pub async fn delete_tag_category(&self, name: String, version: String) -> PyResult<()> {
        self.client
            .request()
            .delete_tag_category(name, version)
            .await
            .map_err(Into::into)
    }

    #[pyo3(signature = (name))]
    /// Sets the default tag category for the site (async version)
    pub async fn set_default_tag_category(&self, name: String) -> PyResult<()> {
        self.client
            .request()
            .set_default_tag_category(name)
            .await
            .map_err(Into::into)
    }

    #[pyo3(signature = (query=None, fields=None, limit=None, offset=None))]
    /// List the tags currently available on the site (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.list_tags` for parameters and return type
    pub async fn list_tags(
        &self,
        query: Option<Vec<QueryToken>>,
        fields: Option<Vec<String>>,
        limit: Option<u32>,
        offset: Option<u32>,
    ) -> PyResult<PyPagedSearchResult> {
        self.client
            .with_optional_fields(fields)
            .with_optional_limit(limit)
            .with_optional_offset(offset)
            .list_tags(query.as_ref())
            .await
            .map_err(Into::into)
            .map(Into::into)
    }

    #[pyo3(signature = (names, category=None, description=None, implications=None, suggestions=None, fields=None))]
    /// Creating a new tag (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.create_tag` for parameters and return type
    pub async fn create_tag(
        &self,
        names: Py<PyAny>,
        category: Option<String>,
        description: Option<String>,
        implications: Option<Vec<String>>,
        suggestions: Option<Vec<String>>,
        fields: Option<Vec<String>>,
    ) -> PyResult<TagResource> {
        let mut cubuild = CreateUpdateTagBuilder::default();
        Python::with_gil(|py| {
            if let Ok(name) = names.extract::<String>(py) {
                Ok(cubuild.names(vec![name]))
            } else {
                let list_res = names.extract::<Vec<String>>(py);
                if let Ok(names) = list_res {
                    Ok(cubuild.names(names))
                } else {
                    Err(list_res.err().unwrap())
                }
            }
        })?;
        //cubuild.names(names);
        if let Some(cat) = category {
            cubuild.category(cat);
        }
        if let Some(desc) = description {
            cubuild.description(desc);
        }
        if let Some(imps) = implications {
            cubuild.implications(imps);
        }
        if let Some(s) = suggestions {
            cubuild.suggestions(s);
        }
        let tag_build = cubuild.build()?;
        self.client
            .with_optional_fields(fields)
            .create_tag(&tag_build)
            .await
            .map_err(Into::into)
    }

    #[pyo3(signature = (name, version, names=None, category=None, description=None, implications=None, suggestions=None, fields=None))]
    #[allow(clippy::too_many_arguments)]
    /// Updates an existing tag (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.update_tag` for parameters and return type
    pub async fn update_tag(
        &self,
        name: String,
        version: String,
        names: Option<Py<PyAny>>,
        category: Option<String>,
        description: Option<String>,
        implications: Option<Vec<String>>,
        suggestions: Option<Vec<String>>,
        fields: Option<Vec<String>>,
    ) -> PyResult<TagResource> {
        let mut cubuild = CreateUpdateTagBuilder::default();
        cubuild.version(version);
        if let Some(names) = names {
            Python::with_gil(|py| {
                if let Ok(name) = names.extract::<String>(py) {
                    Ok(cubuild.names(vec![name]))
                } else {
                    let list_res = names.extract::<Vec<String>>(py);
                    if let Ok(names) = list_res {
                        Ok(cubuild.names(names))
                    } else {
                        Err(list_res.err().unwrap())
                    }
                }
            })?;
        }
        if let Some(cat) = category {
            cubuild.category(cat);
        }
        if let Some(desc) = description {
            cubuild.description(desc);
        }
        if let Some(imps) = implications {
            cubuild.implications(imps);
        }
        if let Some(s) = suggestions {
            cubuild.suggestions(s);
        }
        let tag_build = cubuild.build()?;
        self.client
            .with_optional_fields(fields)
            .update_tag(name, &tag_build)
            .await
            .map_err(Into::into)
    }

    #[pyo3(signature = (name, fields=None))]
    /// Fetches an existing tag (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.get_tag` for parameters and return type
    pub async fn get_tag(
        &self,
        name: String,
        fields: Option<Vec<String>>,
    ) -> PyResult<TagResource> {
        self.client
            .with_optional_fields(fields)
            .get_tag(name)
            .await
            .map_err(Into::into)
    }

    #[pyo3(signature = (name, version))]
    /// Deletes an existing tag (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.delete_tag` for parameters and return type
    pub async fn delete_tag(&self, name: String, version: String) -> PyResult<()> {
        self.client
            .request()
            .delete_tag(name, version)
            .await
            .map_err(Into::into)
    }

    #[pyo3(signature = (remove_tag, remove_tag_version, merge_to_tag, merge_to_version, fields=None))]
    /// Removes source tag and merges all of its usages, suggestions and implications to the
    /// target tag. (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.merge_tags` for parameters and return type
    pub async fn merge_tags(
        &self,
        remove_tag: String,
        remove_tag_version: String,
        merge_to_tag: String,
        merge_to_version: String,
        fields: Option<Vec<String>>,
    ) -> PyResult<TagResource> {
        let mtags = MergeTagsBuilder::default()
            .remove_tag_version(remove_tag_version)
            .remove_tag(remove_tag)
            .merge_to_version(merge_to_version)
            .merge_to_tag(merge_to_tag)
            .build()?;
        self.client
            .with_optional_fields(fields)
            .merge_tags(&mtags)
            .await
            .map_err(Into::into)
    }

    #[pyo3(signature = (name))]
    /// Lists siblings of given tag, e.g. tags that were used in the same posts as the given tag.
    /// (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.get_tag_siblings` for parameters and return type
    pub async fn get_tag_siblings(&self, name: String) -> PyResult<Vec<TagSibling>> {
        self.client
            .request()
            .get_tag_siblings(name)
            .await
            .map(|ts| ts.results)
            .map_err(Into::into)
    }

    #[pyo3(signature = (query=None, fields=None, limit=None, offset=None))]
    /// Lists the posts currently available on the site (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.list_posts` for parameters and return type
    pub async fn list_posts(
        &self,
        query: Option<Vec<QueryToken>>,
        fields: Option<Vec<String>>,
        limit: Option<u32>,
        offset: Option<u32>,
    ) -> PyResult<PyPagedSearchResult> {
        self.client
            .with_optional_fields(fields)
            .with_optional_limit(limit)
            .with_optional_offset(offset)
            .list_posts(query.as_ref())
            .await
            .map_err(Into::into)
            .map(Into::into)
    }

    #[pyo3(signature = (url=None, upload_token=None, file_path=None, thumbnail_path=None, tags=None, safety=None, source=None,
            relations=None, notes=None, flags=None, anonymous=None, fields=None))]
    #[allow(clippy::too_many_arguments)]
    /// Create a new post using one of three image sources (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.create_post` for parameters and return type
    pub async fn create_post(
        &self,
        url: Option<String>,
        upload_token: Option<String>,
        file_path: Option<PathBuf>,
        thumbnail_path: Option<PathBuf>,
        tags: Option<Vec<String>>,
        safety: Option<PostSafety>,
        source: Option<String>,
        relations: Option<Vec<u32>>,
        notes: Option<Vec<NoteResource>>,
        flags: Option<Vec<String>>,
        anonymous: Option<bool>,
        fields: Option<Vec<String>>,
    ) -> PyResult<PostResource> {
        let mut cupost = CreateUpdatePostBuilder::default();
        if let Some(source) = source {
            cupost.source(source);
        }
        if let Some(tags) = tags {
            cupost.tags(tags);
        }
        if let Some(safety) = safety {
            cupost.safety(safety);
        }
        if let Some(relations) = relations {
            cupost.relations(relations);
        }
        if let Some(notes) = notes {
            cupost.notes(notes);
        }
        if let Some(flags) = flags {
            cupost.flags(flags);
        }
        if let Some(anonymous) = anonymous {
            cupost.anonymous(anonymous);
        }

        if let Some(token) = upload_token {
            cupost.content_token(token);
            let cupost = cupost.build()?;
            self.client
                .with_optional_fields(fields)
                .create_post_from_token(&cupost)
                .await
                .map_err(Into::into)
        } else if let Some(url) = url {
            cupost.content_url(url);
            let cupost = cupost.build()?;
            self.client
                .with_optional_fields(fields)
                .create_post_from_url(&cupost)
                .await
                .map_err(Into::into)
        } else if let Some(file) = file_path {
            let cupost = cupost.build()?;
            self.client
                .with_optional_fields(fields)
                .create_post_from_file_path(file, thumbnail_path, &cupost)
                .await
                .map_err(Into::into)
        } else {
            Err(PyRuntimeError::new_err(
                "One of url, token or file must be specified",
            ))
        }
    }

    #[pyo3(signature = (post_id, post_version, url=None, token=None, file_path=None,
        thumbnail_path=None, tags=None, safety=None, source=None, relations=None, notes=None,
        flags=None, fields=None))]
    #[allow(clippy::too_many_arguments)]
    /// Updates an existing post (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.update_post` for parameters and return type
    pub async fn update_post(
        &self,
        post_id: u32,
        post_version: String,
        url: Option<String>,
        token: Option<String>,
        file_path: Option<PathBuf>,
        thumbnail_path: Option<PathBuf>,
        tags: Option<Vec<String>>,
        safety: Option<PostSafety>,
        source: Option<String>,
        relations: Option<Vec<u32>>,
        notes: Option<Vec<NoteResource>>,
        flags: Option<Vec<String>>,
        fields: Option<Vec<String>>,
    ) -> PyResult<PostResource> {
        let mut cupost = CreateUpdatePostBuilder::default();
        cupost.version(post_version);
        if let Some(source) = source {
            cupost.source(source);
        }
        if let Some(tags) = tags {
            cupost.tags(tags);
        }
        if let Some(safety) = safety {
            cupost.safety(safety);
        }
        if let Some(relations) = relations {
            cupost.relations(relations);
        }
        if let Some(notes) = notes {
            cupost.notes(notes);
        }
        if let Some(flags) = flags {
            cupost.flags(flags);
        }

        if let Some(token) = token {
            cupost.content_token(token);
            let cupost = cupost.build()?;
            self.client
                .with_optional_fields(fields)
                .update_post_from_token(post_id, &cupost)
                .await
                .map_err(Into::into)
        } else if let Some(url) = url {
            cupost.content_url(url);
            let cupost = cupost.build()?;
            self.client
                .with_optional_fields(fields)
                .update_post_from_url(post_id, &cupost)
                .await
                .map_err(Into::into)
        } else if file_path.is_some() || thumbnail_path.is_some() {
            let cupost = cupost.build()?;
            self.client
                .with_optional_fields(fields)
                .update_post_from_file_path(post_id, file_path, thumbnail_path, &cupost)
                .await
                .map_err(Into::into)
        } else {
            let cupost = cupost.build()?;
            self.client
                .with_optional_fields(fields)
                .update_post(post_id, &cupost)
                .await
                .map_err(Into::into)
        }
    }

    #[pyo3(signature = (post_id))]
    /// Downloads the given post's image as a byte array (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.get_image_bytes` for parameters and return type
    pub async fn get_image_bytes(&self, post_id: u32) -> PyResult<Vec<u8>> {
        let bytes = self
            .client
            .request()
            .get_image_bytes(post_id)
            .await?
            .to_vec();
        Ok(bytes)
    }

    #[pyo3(signature = (post_id, file_path))]
    /// Downloads the given post's image to a path on the filesystem
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.download_image_to_path` for parameters and return type
    pub async fn download_image_to_path(&self, post_id: u32, file_path: PathBuf) -> PyResult<()> {
        self.client
            .request()
            .download_image_to_path(post_id, file_path)
            .await
            .map_err(Into::into)
    }

    #[pyo3(signature = (post_id))]
    /// Downloads the given post's thumbnail as a byte array
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.get_thumbnail_bytes` for parameters and return type
    pub async fn get_thumbnail_bytes<'py>(&self, post_id: u32) -> PyResult<Vec<u8>> {
        let bytes = self
            .client
            .request()
            .get_thumbnail_bytes(post_id)
            .await?
            .to_vec();
        Ok(bytes)
    }

    #[pyo3(signature = (post_id, file_path))]
    /// Downloads the given post's thumbnail to a path on the filesystem
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.` for parameters and return type
    pub async fn download_thumbnail_to_path(
        &self,
        post_id: u32,
        file_path: PathBuf,
    ) -> PyResult<()> {
        self.client
            .request()
            .download_thumbnail_to_path(post_id, file_path)
            .await
            .map_err(Into::into)
    }

    #[pyo3(signature = (image_path))]
    /// Reverse image searches for an image from the filesystem (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.reverse_image_search` for parameters and return type
    pub async fn reverse_image_search(&self, image_path: PathBuf) -> PyResult<ImageSearchResult> {
        self.client
            .request()
            .reverse_search_file_path(image_path)
            .await
            .map_err(Into::into)
    }

    #[pyo3(signature = (image_path))]
    /// Searches for an *exact* image match of an image from the filesystem (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.post_for_image` for parameters and return type
    pub async fn post_for_image(&self, image_path: PathBuf) -> PyResult<Option<PostResource>> {
        self.client
            .request()
            .post_for_file_path(image_path)
            .await
            .map_err(Into::into)
    }

    #[pyo3(signature = (post_id, fields=None))]
    /// Fetches an individual post by its post ID (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.get_post` for parameters and return type
    pub async fn get_post(
        &self,
        post_id: u32,
        fields: Option<Vec<String>>,
    ) -> PyResult<PostResource> {
        self.client
            .with_optional_fields(fields)
            .get_post(post_id)
            .await
            .map_err(Into::into)
    }

    /// Fetches posts from *around* the given post ID. That means the post before and after,
    //  if they exist. (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.get_around_post` for parameters and return type
    pub async fn get_around_post(&self, post_id: u32) -> PyResult<AroundPostResult> {
        self.client
            .request()
            .get_around_post(post_id)
            .await
            .map_err(Into::into)
    }

    /// Deletes a post by its ID (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.delete_post` for parameters and return type
    pub async fn delete_post(&self, post_id: u32, version: String) -> PyResult<()> {
        self.client
            .request()
            .delete_post(post_id, version)
            .await
            .map_err(Into::into)
    }

    #[pyo3(signature = (remove_post, remove_post_version, merge_to_post,
        merge_to_version, replace_post_content=false, fields=None))]
    /// Removes source post and merges all of its tags, relations, scores, favorites and comments to
    /// the target post (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.merge_post` for parameters and return type
    pub async fn merge_post(
        &self,
        remove_post: u32,
        remove_post_version: String,
        merge_to_post: u32,
        merge_to_version: String,
        replace_post_content: bool,
        fields: Option<Vec<String>>,
    ) -> PyResult<PostResource> {
        let mpost = MergePostBuilder::default()
            .remove_post_version(remove_post_version)
            .remove_post(remove_post)
            .merge_to_version(merge_to_version)
            .merge_to_post(merge_to_post)
            .replace_post_content(replace_post_content)
            .build()?;
        self.client
            .with_optional_fields(fields)
            .merge_post(&mpost)
            .await
            .map_err(Into::into)
    }

    #[pyo3(signature = (post_id, rating, fields=None))]
    /// Updates score of authenticated user for given post. Valid scores are -1, 0 and 1.
    /// (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.rate_post` for parameters and return type
    pub async fn rate_post(
        &self,
        post_id: u32,
        rating: i8,
        fields: Option<Vec<String>>,
    ) -> PyResult<PostResource> {
        if !(-1..=1).contains(&rating) {
            Err(PyValueError::new_err("Rating must be -1, 0, or 1"))
        } else {
            self.client
                .with_optional_fields(fields)
                .rate_post(post_id, rating)
                .await
                .map_err(Into::into)
        }
    }

    #[pyo3(signature = (post_id, fields=None))]
    /// Marks the post as favorite for the current user (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.favorite_post` for parameters and return type
    pub async fn favorite_post(
        &self,
        post_id: u32,
        fields: Option<Vec<String>>,
    ) -> PyResult<PostResource> {
        self.client
            .with_optional_fields(fields)
            .favorite_post(post_id)
            .await
            .map_err(Into::into)
    }

    #[pyo3(signature = (post_id, fields=None))]
    /// Unmarks the post as favorite for the current user (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.unfavorite_post` for parameters and return type
    pub async fn unfavorite_post(
        &self,
        post_id: u32,
        fields: Option<Vec<String>>,
    ) -> PyResult<PostResource> {
        self.client
            .with_optional_fields(fields)
            .unfavorite_post(post_id)
            .await
            .map_err(Into::into)
    }

    #[pyo3(signature = (fields=None))]
    /// Retrieves the post that is currently featured on the main page (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.get_featured_post` for parameters and return type
    pub async fn get_featured_post(
        &self,
        fields: Option<Vec<String>>,
    ) -> PyResult<Option<PostResource>> {
        self.client
            .with_optional_fields(fields)
            .get_featured_post()
            .await
            .map_err(Into::into)
    }

    #[pyo3(signature = (post_id, fields=None))]
    /// Features a post on the main page (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.set_featured_post` for parameters and return type
    pub async fn set_featured_post(
        &self,
        post_id: u32,
        fields: Option<Vec<String>>,
    ) -> PyResult<PostResource> {
        self.client
            .with_optional_fields(fields)
            .set_featured_post(post_id)
            .await
            .map_err(Into::into)
    }

    #[pyo3(signature = (fields=None))]
    /// Lists all pool categories (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.list_pool_categories` for parameters and return type
    pub async fn list_pool_categories(
        &self,
        fields: Option<Vec<String>>,
    ) -> PyResult<Vec<PoolCategoryResource>> {
        self.client
            .with_optional_fields(fields)
            .list_pool_categories()
            .await
            .map_err(Into::into)
            .map(|pc| pc.results)
    }

    #[pyo3(signature = (name, color=None, fields=None))]
    /// Creates a new pool category using specified parameters (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.create_pool_category` for parameters and return type
    pub async fn create_pool_category(
        &self,
        name: String,
        color: Option<String>,
        fields: Option<Vec<String>>,
    ) -> PyResult<PoolCategoryResource> {
        let mut pc = CreateUpdatePoolCategoryBuilder::default();
        pc.name(name);
        if let Some(color) = color {
            pc.color(color);
        }
        let pc = pc.build()?;
        self.client
            .with_optional_fields(fields)
            .create_pool_category(&pc)
            .await
            .map_err(Into::into)
    }

    #[pyo3(signature = (name, version, new_name=None, color=None, fields=None))]
    /// Updates an existing tag category using specified parameters (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.update_pool_category` for parameters and return type
    pub async fn update_pool_category(
        &self,
        name: String,
        version: String,
        new_name: Option<String>,
        color: Option<String>,
        fields: Option<Vec<String>>,
    ) -> PyResult<PoolCategoryResource> {
        let mut pc = CreateUpdatePoolCategoryBuilder::default();
        pc.version(version);
        if let Some(name) = new_name {
            pc.name(name);
        }
        if let Some(color) = color {
            pc.color(color);
        }
        let pc = pc.build()?;
        self.client
            .with_optional_fields(fields)
            .update_pool_category(name, &pc)
            .await
            .map_err(Into::into)
    }

    #[pyo3(signature = (name, fields=None))]
    /// Fetches an existing pool category (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.get_pool_category` for parameters and return type
    pub async fn get_pool_category(
        &self,
        name: String,
        fields: Option<Vec<String>>,
    ) -> PyResult<PoolCategoryResource> {
        self.client
            .with_optional_fields(fields)
            .get_pool_category(name)
            .await
            .map_err(Into::into)
    }

    /// Deletes existing pool category (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.delete_pool_category` for parameters and return type
    pub async fn delete_pool_category(&self, name: String, version: String) -> PyResult<()> {
        self.client
            .request()
            .delete_pool_category(name, version)
            .await
            .map_err(Into::into)
    }

    #[pyo3(signature = (name, fields=None))]
    /// Sets given pool category as default (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.set_default_pool_category` for parameters and return type
    pub async fn set_default_pool_category(
        &self,
        name: String,
        fields: Option<Vec<String>>,
    ) -> PyResult<PoolCategoryResource> {
        self.client
            .with_optional_fields(fields)
            .set_default_pool_category(name)
            .await
            .map_err(Into::into)
    }

    #[pyo3(signature = (query=None, fields=None, limit=None, offset=None))]
    /// List the post pools currently available on the site (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.list_pools` for parameters and return type
    pub async fn list_pools(
        &self,
        query: Option<Vec<QueryToken>>,
        fields: Option<Vec<String>>,
        limit: Option<u32>,
        offset: Option<u32>,
    ) -> PyResult<PyPagedSearchResult> {
        self.client
            .with_optional_fields(fields)
            .with_optional_limit(limit)
            .with_optional_offset(offset)
            .list_pools(query.as_ref())
            .await
            .map_err(Into::into)
            .map(Into::into)
    }

    #[pyo3(signature = (names, category=None, description=None, posts=None, fields=None))]
    /// Creates a new pool using specified parameters (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.create_pool` for parameters and return type
    pub async fn create_pool<'py>(
        &self,
        names: Py<PyAny>,
        category: Option<String>,
        description: Option<String>,
        posts: Option<Vec<u32>>,
        fields: Option<Vec<String>>,
    ) -> PyResult<PoolResource> {
        let mut cupool = CreateUpdatePoolBuilder::default();
        Python::with_gil(|py| {
            if let Ok(name) = names.extract::<String>(py) {
                Ok(cupool.names(vec![name]))
            } else {
                let list_res = names.extract::<Vec<String>>(py);
                if let Ok(names) = list_res {
                    Ok(cupool.names(names))
                } else {
                    Err(list_res.err().unwrap())
                }
            }
        })?;
        //cupool.names(names);
        if let Some(cat) = category {
            cupool.category(cat);
        }
        if let Some(desc) = description {
            cupool.description(desc);
        }
        if let Some(posts) = posts {
            cupool.posts(posts);
        }
        let cupool = cupool.build()?;
        self.client
            .with_optional_fields(fields)
            .create_pool(&cupool)
            .await
            .map_err(Into::into)
    }

    #[pyo3(signature = (pool_id, version, new_names=None, category=None, description=None,
        posts=None, fields=None))]
    #[allow(clippy::too_many_arguments)]
    /// Updates an existing pool using specified parameters (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.update_pool` for parameters and return type
    pub async fn update_pool(
        &self,
        pool_id: u32,
        version: String,
        new_names: Option<Vec<String>>,
        category: Option<String>,
        description: Option<String>,
        posts: Option<Vec<u32>>,
        fields: Option<Vec<String>>,
    ) -> PyResult<PoolResource> {
        let mut cupool = CreateUpdatePoolBuilder::default();
        cupool.version(version);
        if let Some(names) = new_names {
            cupool.names(names);
        }

        if let Some(cat) = category {
            cupool.category(cat);
        }
        if let Some(desc) = description {
            cupool.description(desc);
        }
        if let Some(posts) = posts {
            cupool.posts(posts);
        }
        let cupool = cupool.build()?;
        self.client
            .with_optional_fields(fields)
            .update_pool(pool_id, &cupool)
            .await
            .map_err(Into::into)
    }

    #[pyo3(signature = (pool_id, fields=None))]
    /// Retrieves information about an existing pool (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.get_pool` for parameters and return type
    pub async fn get_pool(
        &self,
        pool_id: u32,
        fields: Option<Vec<String>>,
    ) -> PyResult<PoolResource> {
        self.client
            .with_optional_fields(fields)
            .get_pool(pool_id)
            .await
            .map_err(Into::into)
    }

    /// Deletes existing pool (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.delete_pool` for parameters and return type
    pub async fn delete_pool(&self, pool_id: u32, version: String) -> PyResult<()> {
        self.client
            .request()
            .delete_pool(pool_id, version)
            .await
            .map_err(Into::into)
    }

    #[pyo3(signature = (remove_pool, remove_pool_version, merge_to_pool, merge_to_version, fields=None))]
    /// Removes source pool and merges all of its posts with the target pool. (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.merge_pools` for parameters and return type
    pub async fn merge_pools(
        &self,
        remove_pool: u32,
        remove_pool_version: String,
        merge_to_pool: u32,
        merge_to_version: String,
        fields: Option<Vec<String>>,
    ) -> PyResult<PoolResource> {
        let mpool = MergePoolBuilder::default()
            .remove_pool_version(remove_pool_version)
            .remove_pool(remove_pool)
            .merge_to_version(merge_to_version)
            .merge_to_pool(merge_to_pool)
            .build()?;
        self.client
            .with_optional_fields(fields)
            .merge_pools(&mpool)
            .await
            .map_err(Into::into)
    }

    #[pyo3(signature = (query=None, fields=None, limit=None, offset=None))]
    /// List the comments currently available on the site (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.list_comments` for parameters and return type
    pub async fn list_comments(
        &self,
        query: Option<Vec<QueryToken>>,
        fields: Option<Vec<String>>,
        limit: Option<u32>,
        offset: Option<u32>,
    ) -> PyResult<PyPagedSearchResult> {
        self.client
            .with_optional_fields(fields)
            .with_optional_limit(limit)
            .with_optional_offset(offset)
            .list_comments(query.as_ref())
            .await
            .map_err(Into::into)
            .map(Into::into)
    }

    #[pyo3(signature = (text, post_id, fields=None))]
    /// Creates a new comment under a given post (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.create_comment` for parameters and return type
    pub async fn create_comment(
        &self,
        text: String,
        post_id: u32,
        fields: Option<Vec<String>>,
    ) -> PyResult<CommentResource> {
        let mut cucomment = CreateUpdateCommentBuilder::default();
        cucomment.post_id(post_id);
        cucomment.text(text);

        let cucomment = cucomment.build()?;
        self.client
            .with_optional_fields(fields)
            .create_comment(&cucomment)
            .await
            .map_err(Into::into)
    }

    #[pyo3(signature = (comment_id, version, text, fields=None))]
    /// Updates an existing comment with new text (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.update_comment` for parameters and return type
    pub async fn update_comment(
        &self,
        comment_id: u32,
        version: String,
        text: String,
        fields: Option<Vec<String>>,
    ) -> PyResult<CommentResource> {
        let mut cucomment = CreateUpdateCommentBuilder::default();
        cucomment.version(version);
        cucomment.text(text);

        let cucomment = cucomment.build()?;
        self.client
            .with_optional_fields(fields)
            .update_comment(comment_id, &cucomment)
            .await
            .map_err(Into::into)
    }

    #[pyo3(signature = (comment_id, fields=None))]
    /// Fetches an existing comment (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.get_comment` for parameters and return type
    pub async fn get_comment(
        &self,
        comment_id: u32,
        fields: Option<Vec<String>>,
    ) -> PyResult<CommentResource> {
        self.client
            .with_optional_fields(fields)
            .get_comment(comment_id)
            .await
            .map_err(Into::into)
    }

    /// Deletes an existing comment (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.delete_comment` for parameters and return type
    pub async fn delete_comment(&self, comment_id: u32, version: String) -> PyResult<()> {
        self.client
            .request()
            .delete_comment(comment_id, version)
            .await
            .map_err(Into::into)
    }

    #[pyo3(signature = (comment_id, rating, fields=None))]
    /// Updates score of authenticated user for given comment. Valid scores are -1, 0 and 1.
    /// (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.rate_comment` for parameters and return type
    pub async fn rate_comment(
        &self,
        comment_id: u32,
        rating: i8,
        fields: Option<Vec<String>>,
    ) -> PyResult<CommentResource> {
        self.client
            .with_optional_fields(fields)
            .rate_comment(comment_id, rating)
            .await
            .map_err(Into::into)
    }

    #[pyo3(signature = (query=None, fields=None, limit=None, offset=None))]
    /// List the users currently registered on the site (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.list_users` for parameters and return type
    pub async fn list_users(
        &self,
        query: Option<Vec<QueryToken>>,
        fields: Option<Vec<String>>,
        limit: Option<u32>,
        offset: Option<u32>,
    ) -> PyResult<PyPagedSearchResult> {
        self.client
            .with_optional_fields(fields)
            .with_optional_limit(limit)
            .with_optional_offset(offset)
            .list_users(query.as_ref())
            .await
            .map_err(Into::into)
            .map(Into::into)
    }

    #[pyo3(signature = (name, password, rank=None, avatar_path=None, fields=None))]
    /// Creates a new user using specified parameters (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.create_user` for parameters and return type
    pub async fn create_user(
        &self,
        name: String,
        password: String,
        rank: Option<UserRank>,
        avatar_path: Option<PathBuf>,
        fields: Option<Vec<String>>,
    ) -> PyResult<UserResource> {
        let mut cuser = CreateUpdateUserBuilder::default();
        cuser.name(name);
        cuser.password(password);
        if let Some(rank) = rank {
            cuser.rank(rank);
        }
        if let Some(avatar_path) = avatar_path {
            cuser.avatar_style(UserAvatarStyle::Manual);
            let cuser = cuser.build()?;
            self.client
                .with_optional_fields(fields)
                .create_user_with_avatar_path(avatar_path, &cuser)
                .await
                .map_err(Into::into)
        } else {
            cuser.avatar_style(UserAvatarStyle::Gravatar);
            let cuser = cuser.build()?;
            self.client
                .with_optional_fields(fields)
                .create_user(&cuser)
                .await
                .map_err(Into::into)
        }
    }

    #[pyo3(signature = (name, version, new_name=None, password=None, rank=None, avatar_path=None, fields=None))]
    #[allow(clippy::too_many_arguments)]
    /// Updates an existing user using specified parameters (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.update` for parameters and return type
    pub async fn update_user(
        &self,
        name: String,
        version: String,
        new_name: Option<String>,
        password: Option<String>,
        rank: Option<UserRank>,
        avatar_path: Option<PathBuf>,
        fields: Option<Vec<String>>,
    ) -> PyResult<UserResource> {
        let mut cuser = CreateUpdateUserBuilder::default();
        cuser.version(version);
        if let Some(new_name) = new_name {
            cuser.name(new_name);
        }
        if let Some(password) = password {
            cuser.password(password);
        }
        if let Some(rank) = rank {
            cuser.rank(rank);
        }
        if let Some(avatar_path) = avatar_path {
            cuser.avatar_style(UserAvatarStyle::Manual);
            let cuser = cuser.build()?;
            self.client
                .with_optional_fields(fields)
                .update_user_with_avatar_path(name, avatar_path, &cuser)
                .await
                .map_err(Into::into)
        } else {
            cuser.avatar_style(UserAvatarStyle::Gravatar);
            let cuser = cuser.build()?;
            self.client
                .with_optional_fields(fields)
                .update_user(name, &cuser)
                .await
                .map_err(Into::into)
        }
    }

    #[pyo3(signature = (user_name, fields=None))]
    /// Retrieves information about an existing user (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.get_user` for parameters and return type
    pub async fn get_user(
        &self,
        user_name: String,
        fields: Option<Vec<String>>,
    ) -> PyResult<UserResource> {
        self.client
            .with_optional_fields(fields)
            .get_user(user_name)
            .await
            .map_err(Into::into)
    }

    /// Deletes an existing user (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.delete_user` for parameters and return type
    pub async fn delete_user(&self, user_name: String, version: String) -> PyResult<()> {
        self.client
            .request()
            .delete_user(user_name, version)
            .await
            .map_err(Into::into)
    }

    #[pyo3(signature = (user_name, fields=None))]
    /// Fetches a list of the given user's auth tokens (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.list_user_tokens` for parameters and return type
    pub async fn list_user_tokens(
        &self,
        user_name: String,
        fields: Option<Vec<String>>,
    ) -> PyResult<Vec<UserAuthTokenResource>> {
        self.client
            .with_optional_fields(fields)
            .list_user_tokens(user_name)
            .await
            .map_err(Into::into)
            .map(|ur| ur.results)
    }

    #[pyo3(signature = (user_name, note=None, enabled=None, expiration_time=None, fields=None))]
    /// Creates an auth token for the given user (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.create_user_token` for parameters and return type
    pub async fn create_user_token(
        &self,
        user_name: String,
        note: Option<String>,
        enabled: Option<bool>,
        expiration_time: Option<DateTime<Utc>>,
        fields: Option<Vec<String>>,
    ) -> PyResult<UserAuthTokenResource> {
        let mut cutoken = CreateUpdateUserAuthTokenBuilder::default();
        if let Some(note) = note {
            cutoken.note(note);
        }
        if let Some(etime) = expiration_time {
            cutoken.expiration_time(etime);
        }
        if let Some(enabled) = enabled {
            cutoken.enabled(enabled);
        }
        let cutoken = cutoken.build()?;
        self.client
            .with_optional_fields(fields)
            .create_user_token(user_name, &cutoken)
            .await
            .map_err(Into::into)
    }

    #[pyo3(signature = (user_name, token, version, enabled=None, note=None, expiration_time=None, fields=None))]
    #[allow(clippy::too_many_arguments)]
    /// Update a user's existing auth token (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.update_user_token` for parameters and return type
    pub async fn update_user_token(
        &self,
        user_name: String,
        token: String,
        version: String,
        enabled: Option<bool>,
        note: Option<String>,
        expiration_time: Option<DateTime<Utc>>,
        fields: Option<Vec<String>>,
    ) -> PyResult<UserAuthTokenResource> {
        let mut cutoken = CreateUpdateUserAuthTokenBuilder::default();
        cutoken.version(version);
        if let Some(enabled) = enabled {
            cutoken.enabled(enabled);
        }
        if let Some(note) = note {
            cutoken.note(note);
        }
        if let Some(etime) = expiration_time {
            cutoken.expiration_time(etime);
        }
        let cutoken = cutoken.build()?;
        self.client
            .with_optional_fields(fields)
            .update_user_token(user_name, token, &cutoken)
            .await
            .map_err(Into::into)
    }

    /// Deletes an existing user auth token (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.delete_user_token` for parameters and return type
    pub async fn delete_user_token(
        &self,
        user_name: String,
        token: String,
        version: String,
    ) -> PyResult<()> {
        self.client
            .request()
            .delete_user_token(user_name, token, version)
            .await
            .map_err(Into::into)
    }

    /// Start a password reset request (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.password_reset_request` for parameters and return type
    pub async fn password_reset_request(&self, email_or_name: String) -> PyResult<()> {
        self.client
            .request()
            .password_reset_request(email_or_name)
            .await
            .map_err(Into::into)
    }

    /// Confirm a password reset request (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.password_reset_confirm` for parameters and return type
    pub async fn password_reset_confirm(
        &self,
        email_or_name: String,
        reset_token: String,
    ) -> PyResult<String> {
        self.client
            .request()
            .password_reset_confirm(email_or_name, reset_token)
            .await
            .map_err(Into::into)
            .map(|tp| tp.password)
    }

    #[pyo3(signature = (query=None, fields=None, limit=None, offset=None))]
    /// List the snapshots currently available on the site (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.list_snapshots` for parameters and return type
    pub async fn list_snapshots(
        &self,
        query: Option<Vec<QueryToken>>,
        fields: Option<Vec<String>>,
        limit: Option<u32>,
        offset: Option<u32>,
    ) -> PyResult<PyPagedSearchResult> {
        self.client
            .with_optional_fields(fields)
            .with_optional_limit(limit)
            .with_optional_offset(offset)
            .list_snapshots(query.as_ref())
            .await
            .map_err(Into::into)
            .map(Into::into)
    }

    /// Retrieves simple statistics. ``featured_post`` is ``None`` if there is no featured post yet.
    /// ``server_time`` is pretty much the same as the Date HTTP
    /// field, only formatted in a manner consistent with other dates. Values in config key are
    /// taken directly from the server config, with the exception of privilege array keys being
    /// converted to lower camel case to match the API convention.
    ///
    /// (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.global_info` for parameters and return type
    pub async fn global_info(&self) -> PyResult<GlobalInfo> {
        self.client
            .request()
            .get_global_info()
            .await
            .map_err(Into::into)
    }

    /// Puts a file from a given file path in temporary storage and assigns it a token that can be
    /// used in other requests. (async version)
    ///
    /// :see: :func:`~szurubooru_client.SzurubooruSyncClient.upload_temporary_file` for parameters and return type
    pub async fn upload_temporary_file(&self, file_path: PathBuf) -> PyResult<String> {
        self.client
            .request()
            .upload_temporary_file_from_path(file_path)
            .await
            .map_err(Into::into)
            .map(|t| t.token)
    }
}