use crate::client::Bot;
use serde::Serialize;
/// Use this method to specify a URL and receive incoming updates via an outgoing webhook. Whenever there is an update for the bot, we will send an HTTPS POST request to the specified URL, containing a JSON-serialized Update. In case of an unsuccessful request (a request with response HTTP status code different from 2XY), we will repeat the request and give up after a reasonable amount of attempts. Returns `true` on success.
/// If you'd like to make sure that the webhook was set by you, you can specify secret data in the parameter `secret_token`. If specified, the request will contain a header `X-Telegram-Bot-Api-Secret-Token` with the secret token as content.
/// # Documentation
/// <https://core.telegram.org/bots/api#setwebhook>
/// # Returns
/// - `bool`
#[derive(Clone, Debug, Serialize)]
pub struct SetWebhook {
    /// HTTPS URL to send updates to. Use an empty string to remove webhook integration
    pub url: Box<str>,
    /// Upload your public key certificate so that the root certificate in use can be checked. See our self-signed guide for details.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub certificate: Option<crate::types::InputFile>,
    /// The fixed IP address which will be used to send webhook requests instead of the IP address resolved through DNS
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ip_address: Option<Box<str>>,
    /// The maximum allowed number of simultaneous HTTPS connections to the webhook for update delivery, 1-100. Defaults to 40. Use lower values to limit the load on your bot's server, and higher values to increase your bot's throughput.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_connections: Option<u8>,
    /// A JSON-serialized list of the update types you want your bot to receive. For example, specify `message`, `edited_channel_post`, `callback_query` to only receive updates of these types. See Update for a complete list of available update types. Specify an empty list to receive all update types except `chat_member`, `message_reaction`, and `message_reaction_count` (default). If not specified, the previous setting will be used. Please note that this parameter doesn't affect updates created before the call to the [`crate::methods::SetWebhook`], so unwanted updates may be received for a short period of time.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub allowed_updates: Option<Box<[Box<str>]>>,
    /// Pass `true` to drop all pending updates
    #[serde(skip_serializing_if = "Option::is_none")]
    pub drop_pending_updates: Option<bool>,
    /// A secret token to be sent in a header `X-Telegram-Bot-Api-Secret-Token` in every webhook request, 1-256 characters. Only characters A-Z, a-z, 0-9, `_` and - are allowed. The header is useful to ensure that the request comes from a webhook set by you.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub secret_token: Option<Box<str>>,
}
impl SetWebhook {
    /// Creates a new `SetWebhook`.
    ///
    /// # Arguments
    /// * `url` - HTTPS URL to send updates to. Use an empty string to remove webhook integration
    ///
    /// # Notes
    /// Use builder methods to set optional fields.
    #[must_use]
    pub fn new<T0: Into<Box<str>>>(url: T0) -> Self {
        Self {
            url: url.into(),
            certificate: None,
            ip_address: None,
            max_connections: None,
            allowed_updates: None,
            drop_pending_updates: None,
            secret_token: None,
        }
    }

    /// HTTPS URL to send updates to. Use an empty string to remove webhook integration
    #[must_use]
    pub fn url<T: Into<Box<str>>>(mut self, val: T) -> Self {
        self.url = val.into();
        self
    }

    /// Upload your public key certificate so that the root certificate in use can be checked. See our self-signed guide for details.
    #[must_use]
    pub fn certificate<T: Into<crate::types::InputFile>>(mut self, val: T) -> Self {
        self.certificate = Some(val.into());
        self
    }

    /// Upload your public key certificate so that the root certificate in use can be checked. See our self-signed guide for details.
    #[must_use]
    pub fn certificate_option<T: Into<crate::types::InputFile>>(mut self, val: Option<T>) -> Self {
        self.certificate = val.map(Into::into);
        self
    }

    /// The fixed IP address which will be used to send webhook requests instead of the IP address resolved through DNS
    #[must_use]
    pub fn ip_address<T: Into<Box<str>>>(mut self, val: T) -> Self {
        self.ip_address = Some(val.into());
        self
    }

    /// The fixed IP address which will be used to send webhook requests instead of the IP address resolved through DNS
    #[must_use]
    pub fn ip_address_option<T: Into<Box<str>>>(mut self, val: Option<T>) -> Self {
        self.ip_address = val.map(Into::into);
        self
    }

    /// The maximum allowed number of simultaneous HTTPS connections to the webhook for update delivery, 1-100. Defaults to 40. Use lower values to limit the load on your bot's server, and higher values to increase your bot's throughput.
    #[must_use]
    pub fn max_connections<T: Into<u8>>(mut self, val: T) -> Self {
        self.max_connections = Some(val.into());
        self
    }

    /// The maximum allowed number of simultaneous HTTPS connections to the webhook for update delivery, 1-100. Defaults to 40. Use lower values to limit the load on your bot's server, and higher values to increase your bot's throughput.
    #[must_use]
    pub fn max_connections_option<T: Into<u8>>(mut self, val: Option<T>) -> Self {
        self.max_connections = val.map(Into::into);
        self
    }

    /// A JSON-serialized list of the update types you want your bot to receive. For example, specify `message`, `edited_channel_post`, `callback_query` to only receive updates of these types. See Update for a complete list of available update types. Specify an empty list to receive all update types except `chat_member`, `message_reaction`, and `message_reaction_count` (default). If not specified, the previous setting will be used. Please note that this parameter doesn't affect updates created before the call to the [`crate::methods::SetWebhook`], so unwanted updates may be received for a short period of time.
    ///
    /// # Notes
    /// Adds multiple elements.
    #[must_use]
    pub fn allowed_updates<TItem: Into<Box<str>>, T: IntoIterator<Item = TItem>>(
        mut self,
        val: T,
    ) -> Self {
        self.allowed_updates = Some(
            self.allowed_updates
                .unwrap_or_default()
                .into_vec()
                .into_iter()
                .chain(val.into_iter().map(Into::into))
                .collect(),
        );
        self
    }

    /// A JSON-serialized list of the update types you want your bot to receive. For example, specify `message`, `edited_channel_post`, `callback_query` to only receive updates of these types. See Update for a complete list of available update types. Specify an empty list to receive all update types except `chat_member`, `message_reaction`, and `message_reaction_count` (default). If not specified, the previous setting will be used. Please note that this parameter doesn't affect updates created before the call to the [`crate::methods::SetWebhook`], so unwanted updates may be received for a short period of time.
    ///
    /// # Notes
    /// Adds a single element.
    #[must_use]
    pub fn allowed_update<T: Into<Box<str>>>(mut self, val: T) -> Self {
        self.allowed_updates = Some(
            self.allowed_updates
                .unwrap_or_default()
                .into_vec()
                .into_iter()
                .chain(Some(val.into()))
                .collect(),
        );
        self
    }

    /// A JSON-serialized list of the update types you want your bot to receive. For example, specify `message`, `edited_channel_post`, `callback_query` to only receive updates of these types. See Update for a complete list of available update types. Specify an empty list to receive all update types except `chat_member`, `message_reaction`, and `message_reaction_count` (default). If not specified, the previous setting will be used. Please note that this parameter doesn't affect updates created before the call to the [`crate::methods::SetWebhook`], so unwanted updates may be received for a short period of time.
    ///
    /// # Notes
    /// Adds multiple elements.
    #[must_use]
    pub fn allowed_updates_option<TItem: Into<Box<str>>, T: IntoIterator<Item = TItem>>(
        mut self,
        val: Option<T>,
    ) -> Self {
        self.allowed_updates = val.map(|v| v.into_iter().map(Into::into).collect());
        self
    }

    /// Pass `true` to drop all pending updates
    #[must_use]
    pub fn drop_pending_updates<T: Into<bool>>(mut self, val: T) -> Self {
        self.drop_pending_updates = Some(val.into());
        self
    }

    /// Pass `true` to drop all pending updates
    #[must_use]
    pub fn drop_pending_updates_option<T: Into<bool>>(mut self, val: Option<T>) -> Self {
        self.drop_pending_updates = val.map(Into::into);
        self
    }

    /// A secret token to be sent in a header `X-Telegram-Bot-Api-Secret-Token` in every webhook request, 1-256 characters. Only characters A-Z, a-z, 0-9, `_` and - are allowed. The header is useful to ensure that the request comes from a webhook set by you.
    #[must_use]
    pub fn secret_token<T: Into<Box<str>>>(mut self, val: T) -> Self {
        self.secret_token = Some(val.into());
        self
    }

    /// A secret token to be sent in a header `X-Telegram-Bot-Api-Secret-Token` in every webhook request, 1-256 characters. Only characters A-Z, a-z, 0-9, `_` and - are allowed. The header is useful to ensure that the request comes from a webhook set by you.
    #[must_use]
    pub fn secret_token_option<T: Into<Box<str>>>(mut self, val: Option<T>) -> Self {
        self.secret_token = val.map(Into::into);
        self
    }
}
impl super::TelegramMethod for SetWebhook {
    type Method = Self;
    type Return = bool;

    fn build_request<Client>(mut self, _bot: &Bot<Client>) -> super::Request<Self::Method> {
        let mut files = vec![];
        if let Some(file) = &mut self.certificate {
            super::prepare_file(&mut files, file);
        }
        super::Request::new("setWebhook", self, Some(files))
    }
}
