//! Client library for the <https://www.scaleway.com/> API which
//! is documented at <https://www.scaleway.com/en/developers/api/>
//!
//! # Example blocking
//! It needs to have the feature "blocking" enabled.
//! ```toml
//! scaleway-rs = { version = "*", features = ["blocking"] }
//! ```
//! ```ignore
//! use scaleway_rs::ScalewayApi;
//! use scaleway_rs::ScalewayError;
//!
//! fn main() -> Result<(), ScalewayError> {
//!     let api = ScalewayApi::new("<KEY>", "fr-par-2");
//!     
//!     let types = api.get_server_types()?;
//!     println!("SERVERTYPES: {:#?}", types);
//!     
//!     let images = api.list_images().run()?;
//!     println!("IMAGES: {:#?}", images);
//!     
//!     let instances = api.list_instances().order("creation_date_asc").run()?;
//!     println!("INSTANCES: {:#?}", instances);
//!     Ok(())
//! }
//! ```
//!
//! # Example async
//! ```toml
//! scaleway-rs = { version = "*" }
//! ```
//! ```no_run
//! use scaleway_rs::ScalewayApi;
//! use scaleway_rs::ScalewayError;
//!
//! #[async_std::main]
//! async fn main() -> Result<(), ScalewayError> {
//!     let api = ScalewayApi::new("<KEY>", "fr-par-2");
//!     
//!     let types = api.get_server_types_async().await?;
//!     println!("SERVERTYPES: {:#?}", types);
//!     
//!     let images = api.list_images().run_async().await?;
//!     println!("IMAGES: {:#?}", images);
//!     
//!     let instances = api
//!         .list_instances()
//!         .order("creation_date_asc")
//!         .run_async()
//!         .await?;
//!     println!("INSTANCES: {:#?}", instances);
//!     Ok(())
//! }
//! ```
//! ## Features
//! * "default" - use nativetls
//! * "default-rustls" - use rusttls
//! * "blocking" - enable blocking api
//! * "rustls" - enable rustls for reqwest
//! * "nativetls" - add support for nativetls DEFAULT
//! * "gzip" - enable gzip in reqwest
//! * "brotli" - enable brotli in reqwest
//! * "deflate" - enable deflate in reqwest

mod api_error;
mod builder;
mod data;
mod scaleway_error;

use api_error::ScalewayApiError;
use data::instance::ScalewayInstanceRoot;
use data::server_type::ScalewayServerTypeRoot;
use serde::Serialize;
use serde_json::json;

pub use builder::{
    create_instance_builder::ScalewayCreateInstanceBuilder,
    list_instance_builder::ScalewayListInstanceBuilder,
    list_instance_images_builder::ScalewayListInstanceImagesBuilder,
};
pub use data::image::{
    ScalewayImage, ScalewayImageBootscript, ScalewayImageExtraVolume,
    ScalewayImageExtraVolumeServer, ScalewayImageExtraVolumes, ScalewayImageRootVolume,
};
pub use data::instance::{
    ScalewayInstance, ScalewayInstanceLocation, ScalewayIpv6, ScalewayMaintenance,
    ScalewayPlacementGroup, ScalewayPrivateNic, ScalewayPublicIP, ScalewaySecurityGroup,
};
pub use data::server_type::ServerType;
pub use scaleway_error::ScalewayError;

#[derive(Clone)]
pub struct ScalewayApi {
    secret_key: String,
    zone: String,
}

impl<'a> ScalewayApi {
    pub fn new<S, S2>(secret_key: S, zone: S2) -> ScalewayApi
    where
        S: Into<String>,
        S2: Into<String>,
    {
        ScalewayApi {
            secret_key: secret_key.into(),
            zone: zone.into(),
        }
    }

    async fn get_async(
        &self,
        url: &str,
        query: Vec<(&'static str, String)>,
    ) -> Result<reqwest::Response, ScalewayError> {
        let client = reqwest::Client::new();
        let resp = client
            .get(url)
            .header("X-Auth-Token", &self.secret_key)
            .query(&query)
            .send()
            .await
            .map_err(|e| ScalewayError::Reqwest(e))?;
        let status = resp.status();
        if status.is_client_error() {
            let result: ScalewayApiError = resp.json().await?;
            Err(ScalewayError::Api(result.error))
        } else {
            Ok(resp.error_for_status()?)
        }
    }

    #[cfg(feature = "blocking")]
    fn get(
        &self,
        url: &str,
        query: Vec<(&'static str, String)>,
    ) -> Result<reqwest::blocking::Response, ScalewayError> {
        let client = reqwest::blocking::Client::new();
        let resp = client
            .get(url)
            .header("X-Auth-Token", &self.secret_key)
            .query(&query)
            .send()?;
        let status = resp.status();
        if status.is_client_error() {
            let result: ScalewayApiError = resp.json()?;
            Err(ScalewayError::Api(result.error))
        } else {
            Ok(resp.error_for_status()?)
        }
    }

    async fn post_async<T>(&self, url: &str, json: T) -> Result<reqwest::Response, ScalewayError>
    where
        T: Serialize + Sized,
    {
        let client = reqwest::Client::new();
        let resp = client
            .post(url)
            .header("X-Auth-Token", &self.secret_key)
            .json(&json)
            .send()
            .await?;
        let status = resp.status();
        if status.is_client_error() {
            let result: ScalewayApiError = resp.json().await?;
            Err(ScalewayError::Api(result.error))
        } else {
            Ok(resp.error_for_status()?)
        }
    }

    #[cfg(feature = "blocking")]
    fn post<T>(&self, url: &str, json: T) -> Result<reqwest::blocking::Response, ScalewayError>
    where
        T: Serialize + Sized,
    {
        let client = reqwest::blocking::Client::new();
        let resp = client
            .post(url)
            .header("X-Auth-Token", &self.secret_key)
            .json(&json)
            .send()?;
        let status = resp.status();
        if status.is_client_error() {
            let result: ScalewayApiError = resp.json()?;
            Err(ScalewayError::Api(result.error))
        } else {
            Ok(resp.error_for_status()?)
        }
    }

    async fn delete_async(&self, url: &str) -> Result<reqwest::Response, ScalewayError> {
        let client = reqwest::Client::new();
        let resp = client
            .delete(url)
            .header("X-Auth-Token", &self.secret_key)
            .send()
            .await?;
        let status = resp.status();
        if status.is_client_error() {
            let result: ScalewayApiError = resp.json().await?;
            Err(ScalewayError::Api(result.error))
        } else {
            Ok(resp.error_for_status()?)
        }
    }

    #[cfg(feature = "blocking")]
    fn delete(&self, url: &str) -> Result<reqwest::blocking::Response, ScalewayError> {
        let client = reqwest::blocking::Client::new();
        let resp = client
            .delete(url)
            .header("X-Auth-Token", &self.secret_key)
            .send()?;
        let status = resp.status();
        if status.is_client_error() {
            let result: ScalewayApiError = resp.json()?;
            Err(ScalewayError::Api(result.error))
        } else {
            Ok(resp.error_for_status()?)
        }
    }

    pub fn az_list() -> Vec<&'static str> {
        vec![
            "fr-par-1", "fr-par-2", "fr-par-3", "nl-ams-1", "nl-ams-2", "pl-waw-1", "pl-waw-2",
        ]
    }

    #[cfg(feature = "blocking")]
    pub fn get_server_types(&self) -> Result<Vec<ServerType>, ScalewayError> {
        let types: Vec<ServerType> = self
            .get(
                &format!(
                    "https://api.scaleway.com/instance/v1/zones/{zone}/products/servers",
                    zone = self.zone
                ),
                vec![],
            )?
            .json::<ScalewayServerTypeRoot>()?
            .servers
            .servers
            .into_iter()
            .map(|(id, item)| ServerType {
                id,
                location: self.zone.to_string(),
                alt_names: item.alt_names,
                arch: item.arch,
                ncpus: item.ncpus,
                ram: item.ram,
                gpu: item.gpu,
                baremetal: item.baremetal,
                monthly_price: item.monthly_price,
                hourly_price: item.hourly_price,
                network: item.network,
            })
            .collect();
        Ok(types)
    }

    pub async fn get_server_types_async(&self) -> Result<Vec<ServerType>, ScalewayError> {
        let types: Vec<ServerType> = self
            .get_async(
                &format!(
                    "https://api.scaleway.com/instance/v1/zones/{zone}/products/servers",
                    zone = self.zone
                ),
                vec![],
            )
            .await?
            .json::<ScalewayServerTypeRoot>()
            .await?
            .servers
            .servers
            .into_iter()
            .map(|(id, item)| ServerType {
                id,
                location: self.zone.to_string(),
                alt_names: item.alt_names,
                arch: item.arch,
                ncpus: item.ncpus,
                ram: item.ram,
                gpu: item.gpu,
                baremetal: item.baremetal,
                monthly_price: item.monthly_price,
                hourly_price: item.hourly_price,
                network: item.network,
            })
            .collect();
        Ok(types)
    }

    pub fn list_images(&self) -> ScalewayListInstanceImagesBuilder {
        ScalewayListInstanceImagesBuilder::new(self.clone())
    }

    pub fn list_instances(&self) -> ScalewayListInstanceBuilder {
        ScalewayListInstanceBuilder::new(self.clone())
    }

    pub fn create_instance(
        &self,
        name: &str,
        commercial_type: &str,
    ) -> ScalewayCreateInstanceBuilder {
        ScalewayCreateInstanceBuilder::new(self.clone(), name, commercial_type)
    }

    #[cfg(feature = "blocking")]
    pub fn get_instance(&self, server_id: &str) -> Result<ScalewayInstance, ScalewayError> {
        Ok(self
            .get(
                &format!(
                    "https://api.scaleway.com/instance/v1/zones/{zone}/servers/{server_id}",
                    zone = self.zone,
                    server_id = server_id
                ),
                vec![],
            )?
            .json::<ScalewayInstanceRoot>()?
            .server)
    }

    pub async fn get_instance_async(
        &self,
        server_id: &str,
    ) -> Result<ScalewayInstance, ScalewayError> {
        Ok(self
            .get_async(
                &format!(
                    "https://api.scaleway.com/instance/v1/zones/{zone}/servers/{server_id}",
                    zone = self.zone,
                    server_id = server_id
                ),
                vec![],
            )
            .await?
            .json::<ScalewayInstanceRoot>()
            .await?
            .server)
    }

    #[cfg(feature = "blocking")]
    pub fn delete_instance(&self, server_id: &str) -> Result<(), ScalewayError> {
        self.delete(&format!(
            "https://api.scaleway.com/instance/v1/zones/{zone}/servers/{server_id}",
            zone = self.zone,
            server_id = server_id
        ))?
        .error_for_status()?;
        Ok(())
    }

    pub async fn delete_instance_async(&self, server_id: &str) -> Result<(), ScalewayError> {
        self.delete_async(&format!(
            "https://api.scaleway.com/instance/v1/zones/{zone}/servers/{server_id}",
            zone = self.zone,
            server_id = server_id
        ))
        .await?
        .error_for_status()?;
        Ok(())
    }

    #[cfg(feature = "blocking")]
    pub fn perform_instance_action(
        &self,
        server_id: &str,
        action: &str,
    ) -> Result<(), ScalewayError> {
        self.post(
            &format!(
                "https://api.scaleway.com/instance/v1/zones/{zone}/servers/{server_id}/action",
                zone = self.zone,
                server_id = server_id
            ),
            json!({"action": action}),
        )?
        .error_for_status()?;
        Ok(())
    }

    pub async fn perform_instance_action_async(
        &self,
        server_id: &str,
        action: &str,
    ) -> Result<(), ScalewayError> {
        self.post_async(
            &format!(
                "https://api.scaleway.com/instance/v1/zones/{zone}/servers/{server_id}/action",
                zone = self.zone,
                server_id = server_id
            ),
            json!({"action": action}),
        )
        .await?
        .error_for_status()?;
        Ok(())
    }
}