//! # effin - Rust client for Fuck Off As A Service
//!
//! https://www.foaas.com/
//!
//! A very non-idiomatic Rust implementation of a client of an
//! API that no one uses so I can waste more time in my life.
//!
//! # Example
//! ```rust
//! use effin::FoaasClient;
//! let fc = effin::FoaasClient::new();
//! let res_awesome = fc.awesome("John");
//! assert_eq!(res_awesome.unwrap().message, "This is Fucking Awesome.")
//! ```

#[allow(unused_imports)]
#[macro_use]
extern crate serde_json;
extern crate serde;

#[macro_use]
mod api;

use crate::api::{Operation, OperationResult};
use serde_json::Result;

/// Not sure why but this is defined here
/// maybe TODO for later
static API: &str = "http://www.foaas.com";

/// A FOAAS Client type
pub struct FoaasClient();

impl FoaasClient {
    /// Returns a client object to perform operations
    ///
    /// # Arguments
    /// None
    ///
    /// # Example
    /// ```rust
    /// use effin::FoaasClient;
    /// let fc = effin::FoaasClient::new();
    /// ```
    pub fn new() -> Self {
        Self {}
    }

    fn get_fq_url(&self, segment: &str) -> String {
        let fq: String = "".to_string();
        fq + &API + segment
    }

    fn call(&self, segment: &str) -> String {
        let client = reqwest::Client::new();
        let mut response = client
            .get(&self.get_fq_url(segment))
            .header(reqwest::header::ACCEPT, "application/json")
            .send()
            .expect("Failed to send request.");
        response.text().expect("Failed to read the response.")
    }

    fn operations(&self) -> Result<Vec<Operation>> {
        let resp = self.call("/operations");
        serde_json::from_str(&resp)
    }

    caller!(version);
    caller!(anyway, company: &str, from: &str);
    caller!(asshole, from: &str);
    caller!(awesome, from: &str);
    caller!(back, name: &str, from: &str);
    caller!(bag, from: &str);
    caller!(ballmer, name: &str, company: &str, from: &str);
    caller!(bday, name: &str, from: &str);
    caller!(because, from: &str);
    caller!(blackadder, name: &str, from: &str);
    caller!(bm, name: &str, from: &str);
    caller!(bucket, from: &str);
    caller!(bus, name: &str, from: &str);
    caller!(bye, from: &str);
    caller!(caniuse, tool: &str, from: &str);
    caller!(chainsaw, name: &str, from: &str);
    //TODO add more endpoints here
}

#[cfg(test)]
mod tests {
    #[test]
    fn uri_building() {
        let f = crate::FoaasClient::new();
        assert_eq!(f.get_fq_url("/version"), "http://www.foaas.com/version")
    }

    #[test]
    fn api_call() {
        // mocks/stubs for api checks?
        // what to use for real api calls, like some kind of integration checks?
        let f = crate::FoaasClient::new();
        let resp = f.call("/version");
        assert_eq!(resp.contains("2.0.0"), true)
    }

    #[test]
    fn ops() {
        let ops = crate::FoaasClient::new();
        let p = ops.operations();
        assert_eq!(p.is_ok(), true)
    }

    #[test]
    fn ops_with_endpoint() {
        let ops = crate::FoaasClient::new();
        let p = ops.operations().unwrap();
        assert_eq!(
            "/anyway/:company/:from",
            p.into_iter()
                .find(|x| x.name == "Who the fuck are you anyway")
                .unwrap()
                .url
        )
    }

    #[test]
    fn ballmer() {
        let b = crate::FoaasClient::new();
        let res = b.ballmer("John", "Apple", "Seed");
        assert_eq!(res.unwrap().message, "Fucking John is a fucking pussy. I\'m going to fucking bury that guy, I have done it before, and I will do it again. I\'m going to fucking kill Apple.")
    }

    #[test]
    fn ballmer_subtitle() {
        let b = crate::FoaasClient::new();
        let res = b.ballmer("John", "Apple", "Seed");
        assert_eq!(res.unwrap().subtitle, Some("- Seed".to_string()))
    }

    #[test]
    fn anyway() {
        let fc = crate::FoaasClient::new();
        let res_anyway = fc.anyway("Apple", "John");
        assert_eq!(res_anyway.unwrap().message, "Who the fuck are you anyway, Apple, why are you stirring up so much trouble, and, who pays you?")
    }

    #[test]
    fn asshole() {
        let fc = crate::FoaasClient::new();
        let res_asshole = fc.asshole("John");
        assert_eq!(res_asshole.unwrap().message, "Fuck you, asshole.")
    }

    #[test]
    fn awesome() {
        let fc = crate::FoaasClient::new();
        let res_awesome = fc.awesome("John");
        assert_eq!(res_awesome.unwrap().message, "This is Fucking Awesome.")
    }

    #[test]
    fn back() {
        let fc = crate::FoaasClient::new();
        let res_back = fc.back("Apple", "John");
        assert_eq!(res_back.unwrap().message, "Apple, back the fuck off.")
    }
}