#![deny(warnings)]
#![deny(unused)]
#![deny(clippy::expect_used)]
#![deny(clippy::get_unwrap)]
#![deny(clippy::exit)]
#![deny(clippy::indexing_slicing)]
#![deny(clippy::panic)]
#![deny(clippy::panic_in_result_fn)]
#![deny(clippy::unreachable)]
#![deny(clippy::unwrap_used)]
#![deny(clippy::unwrap_in_result)]
// #![deny(clippy::print_stdout)]
#![allow(clippy::upper_case_acronyms)]

//! # Valorant API
//! This crate is a wrapper for the In-Game Valorant API.
//!
//! ## Usage
//!
//! ### 1. Authenticate
//!
//! To use this crate, you need to authenticate with your Riot Games account.
//! Currently, the only way to do this is by using a username and password (no 2FA).
//!
//! ```rust no_run
//! use valorant_api::utils::credentials_manager::CredentialsManager;
//! use valorant_api::utils::network::http_client::SimpleHttpClient;
//!
//! #[tokio::main]
//! async fn main() {
//!     let http_client = SimpleHttpClient::new();
//!     let mut credentials_manager = valorant_api::utils::credentials_manager::CredentialsManager::new();
//!     let result = credentials_manager
//!         .authenticate(&http_client, "username", "password")
//!         .await;
//!     match result {
//!         Ok(_) => println!("Authenticated"),
//!         Err(_) => println!("Error while authenticating"),
//!     }
//! }
//! ```
//!
//! ### 2. Use the API
//!
//! ```rust no_run
//! use valorant_api::enums::region::Region;
//! use uuid::Uuid;
//! use std::collections::HashMap;
//!
//! let puuid = Uuid::parse_str("ee89b4d9-13d0-5832-8dd7-eb5d8806d918").expect("Invalid UUID");
//! let region = Region::EU;
//! let queries = HashMap::new();
//! let result = valorant_api::get_competitve_updates_v1(credentials_manager, &http_client, region, &puuid, queries).await;
//! println!("Result: {:#?}", result);
//! ```
//!
//! ## Endpoints
//!
//! ### Competitive Updates V1
//!
//! Function: [`get_competitive_updates_v1`]
//!
//! Result Type: [`CompetitveUpdatesV1`]
//!
//! ### Match Details V1
//!
//! Function: [`get_match_details_v1`]
//!
//! Result Type: [`MatchDetailsV1`]
//!
//! ### Match History V1
//!
//! Function: [`get_match_history_v1`]
//!
//! Result Type: [`MatchHistoryV1`]
//!
//! ### MMRV1
//!
//! Function: [`get_mmr_details_v1`]
//!
//! Result Type: [`MMRDetailsV1`]
//!
//! ### Leaderboard V1
//!
//! Function: [`get_leaderboard_v1`]
//!
//! Result Type: [`LeaderboardV1`]
//!
//! ### Content V3
//!
//! Function: [`get_content_v3`]
//!
//! Result Type: [`ContentV3`]
//!
//! ### Store Offers V1
//!
//! Function: [`get_store_offers_v1`]
//!
//! Result Type: [`StoreOffersV1`]
//!
//! ### Store Front V2
//!
//! Function: [`get_store_front_v2`]
//!
//! Result Type: [`StoreFrontV2`]
//!

use crate::enums::query_arg::{
    CompetitiveUpdateQueryArg, LeaderboardQueryArg, MatchHistoryQueryArg,
};
use crate::enums::region::Region;
use crate::errors::response_error::RequestError;
use crate::response_types::account_aliases_v1::AccountAliasesV1;
use crate::response_types::competitve_updates_v1::CompetitveUpdatesV1;
use crate::response_types::content_v3::ContentV3;
use crate::response_types::leaderboard_v1::LeaderboardV1;
use crate::response_types::matchdetails_v1::MatchDetailsV1;
use crate::response_types::matchhistory_v1::MatchHistoryV1;
use crate::response_types::mmrdetails_v1::MMRDetailsV1;
use crate::response_types::store_front_v2::StoreFrontV2;
use crate::response_types::store_offers_v1::StoreOffersV1;
use crate::utils::credentials_manager::CredentialsManager;
use crate::utils::fetch::fetch_endpoint;
use crate::utils::functions::set_query_args;
use crate::utils::network::http_client::HttpClient;
use reqwest::Method;
use std::collections::HashMap;
use std::str::FromStr;
use url::Url;
use uuid::Uuid;

pub mod enums;
pub mod errors;
pub mod puuid_fetcher;
pub mod response_types;
pub mod utils;

#[cfg(feature = "puuid")]
pub use puuid_fetcher::PuuidFetcher;

pub async fn get_match_history_v1<T: HttpClient>(
    credentials_manager: &CredentialsManager,
    http_client: &T,
    region: Region,
    puuid: &Uuid,
    query_args: HashMap<MatchHistoryQueryArg, String>,
) -> Result<MatchHistoryV1, RequestError> {
    //! Get the match history of a player
    //! # Arguments
    //! * `credentials_manager` - The credentials manager
    //! * `region` - The region of the player
    //! * `puuid` - The puuid of the player
    //! * `query_args` - The query arguments
    //! # Example
    //! ```rust no_run
    //! let puuid = Uuid::parse_str("ee89b4d9-13d0-5832-8dd7-eb5d8806d918").expect("Invalid UUID");
    //! let region = Region::EU;
    //! let queries = HashMap::new();
    //! let result = valorant_api::get_match_history_v1(credentials_manager, &http_client, region, &puuid, queries).await;
    //! println!("Result: {:#?}", result);
    //! ```

    let mut url = Url::from_str(
        format!(
            "https://pd.{}.a.pvp.net/match-history/v1/history/{}",
            region.to_shard(),
            puuid
        )
        .as_str(),
    )?;
    set_query_args(&mut url, query_args.into_iter());

    fetch_endpoint(
        credentials_manager,
        http_client,
        url,
        Method::GET,
        "",
        &HashMap::new(),
    )
    .await
}

pub async fn get_match_details_v1<T: HttpClient>(
    credentials_manager: &CredentialsManager,
    http_client: &T,
    region: Region,
    match_id: &Uuid,
) -> Result<MatchDetailsV1, RequestError> {
    //! Get the match details of a match
    //! # Arguments
    //! * `credentials_manager` - The credentials manager
    //! * `region` - The region of the match
    //! * `match_id` - The match id of the match
    //! # Example
    //! ```rust no_run
    //! let match_id = Uuid::parse_str("3100c02b-17d2-4adb-97b5-e45dee67d292").expect("Invalid UUID");
    //! let region = Region::EU;
    //! let result = valorant_api::get_match_details_v1(credentials_manager, &http_client, region, &match_id).await;
    //! println!("Result: {:#?}", result);
    //! ```

    let url = Url::from_str(
        format!(
            "https://pd.{}.a.pvp.net/match-details/v1/matches/{}",
            region.to_shard(),
            match_id
        )
        .as_str(),
    )?;

    fetch_endpoint(
        credentials_manager,
        http_client,
        url,
        Method::GET,
        "",
        &HashMap::new(),
    )
    .await
}

pub async fn get_mmr_details_v1<T: HttpClient>(
    credentials_manager: &CredentialsManager,
    http_client: &T,
    region: Region,
    puuid: &Uuid,
) -> Result<MMRDetailsV1, RequestError> {
    //! Get the mmr of a player
    //! # Arguments
    //! * `credentials_manager` - The credentials manager
    //! * `region` - The region of the player
    //! * `puuid` - The puuid of the player
    //! # Example
    //! ```rust no_run
    //! let puuid = Uuid::parse_str("ee89b4d9-13d0-5832-8dd7-eb5d8806d918").expect("Invalid UUID");
    //! let region = Region::EU;
    //! let result = valorant_api::get_mmr_details_v1(credentials_manager, &http_client, region, &puuid).await;
    //! println!("Result: {:#?}", result);
    //! ```

    let url = Url::from_str(
        format!(
            "https://pd.{}.a.pvp.net/mmr/v1/players/{}",
            region.to_shard(),
            puuid
        )
        .as_str(),
    )?;

    fetch_endpoint(
        credentials_manager,
        http_client,
        url,
        Method::GET,
        "",
        &HashMap::new(),
    )
    .await
}

pub async fn get_competitive_updates_v1<T: HttpClient>(
    credentials_manager: &CredentialsManager,
    http_client: &T,
    region: Region,
    puuid: &Uuid,
    query_args: HashMap<CompetitiveUpdateQueryArg, String>,
) -> Result<CompetitveUpdatesV1, RequestError> {
    //! Get the competitve updates of a player
    //! # Arguments
    //! * `credentials_manager` - The credentials manager
    //! * `region` - The region of the player
    //! * `puuid` - The puuid of the player
    //! * `query_args` - The query arguments
    //! # Example
    //! ```rust no_run
    //! let puuid = Uuid::parse_str("ee89b4d9-13d0-5832-8dd7-eb5d8806d918").expect("Invalid UUID");
    //! let region = Region::EU;
    //! let queries = HashMap::new();
    //! let result = valorant_api::get_competitve_updates_v1(credentials_manager, &http_client, region, &puuid, queries).await;
    //! println!("Result: {:#?}", result);
    //! ```

    let mut url = Url::from_str(
        format!(
            "https://pd.{}.a.pvp.net/mmr/v1/players/{}/competitiveupdates",
            region.to_shard(),
            puuid
        )
        .as_str(),
    )?;
    set_query_args(&mut url, query_args.into_iter());

    fetch_endpoint(
        credentials_manager,
        http_client,
        url,
        Method::GET,
        "",
        &HashMap::new(),
    )
    .await
}

pub async fn get_content_v3<T: HttpClient>(
    credentials_manager: &CredentialsManager,
    http_client: &T,
    region: Region,
) -> Result<ContentV3, RequestError> {
    //! Get the content of the game
    //! # Arguments
    //! * `credentials_manager` - The credentials manager
    //! * `region` - The region of the player
    //! # Example
    //! ```rust no_run
    //! let region = Region::EU;
    //! let result = valorant_api::get_content_v1(credentials_manager, &http_client, region).await;
    //! println!("Result: {:#?}", result);
    //! ```

    let url = Url::from_str(
        format!(
            "https://shared.{}.a.pvp.net/content-service/v3/content",
            region.to_shard(),
        )
        .as_str(),
    )?;

    fetch_endpoint(
        credentials_manager,
        http_client,
        url,
        Method::GET,
        "",
        &HashMap::new(),
    )
    .await
}

pub async fn get_leaderboard_v1<T: HttpClient>(
    credentials_manager: &CredentialsManager,
    http_client: &T,
    region: Region,
    season: &Uuid,
    query_args: HashMap<LeaderboardQueryArg, String>,
) -> Result<LeaderboardV1, RequestError> {
    //! Get the leaderboard of a region
    //! # Arguments
    //! * `credentials_manager` - The credentials manager
    //! * `region` - The region of the leaderboard
    //! * `season` - The season of the leaderboard
    //! * `query_args` - The query arguments
    //! # Errors
    //! `RequestError` - If the request failed
    //! # Example
    //! ```rust no_run
    //! let season = Uuid::parse_str("34093c29-4306-43de-452f-3f944bde22be").expect("Invalid UUID");
    //! let region = Region::EU;
    //! let queries = HashMap::new();
    //! let result = valorant_api::get_leaderboard_v1(credentials_manager, &http_client, region, &season, queries).await;
    //! println!("Result: {:#?}", result);
    //! ```

    let mut url = Url::from_str(
        format!(
            "https://pd.{}.a.pvp.net/mmr/v1/leaderboards/affinity/{}/queue/competitive/season/{}",
            region.to_shard(),
            region,
            season
        )
        .as_str(),
    )?;
    set_query_args(&mut url, query_args.into_iter());

    fetch_endpoint(
        credentials_manager,
        http_client,
        url,
        Method::GET,
        "",
        &HashMap::new(),
    )
    .await
}

pub async fn get_store_offers_v1<T: HttpClient>(
    credentials_manager: &CredentialsManager,
    http_client: &T,
    region: Region,
) -> Result<StoreOffersV1, RequestError> {
    //! Get the store offers of a region
    //! # Arguments
    //! * `credentials_manager` - The credentials manager
    //! * `region` - The region of the leaderboard
    //! # Errors
    //! `RequestError` - If the request failed
    //! # Example
    //! ```rust no_run
    //! let season = Uuid::parse_str("34093c29-4306-43de-452f-3f944bde22be").expect("Invalid UUID");
    //! let region = Region::EU;
    //! let result = valorant_api::get_store_offers_v1(credentials_manager, &http_client, region).await;
    //! println!("Result: {:#?}", result);
    //! ```

    let url = Url::from_str(
        format!(
            "https://pd.{}.a.pvp.net/store/v1/offers/",
            region.to_shard(),
        )
        .as_str(),
    )?;

    fetch_endpoint(
        credentials_manager,
        http_client,
        url,
        Method::GET,
        "",
        &HashMap::new(),
    )
    .await
}

pub async fn get_store_front_v2<T: HttpClient>(
    credentials_manager: &CredentialsManager,
    http_client: &T,
    region: Region,
    puuid: Uuid,
) -> Result<StoreFrontV2, RequestError> {
    //! Get the store front of a player
    //! # Arguments
    //! * `credentials_manager` - The credentials manager
    //! * `region` - The region of the leaderboard
    //! * `puuid` - The puuid of the player
    //! # Errors
    //! `RequestError` - If the request failed
    //! # Example
    //! ```rust no_run
    //! let puuid = Uuid::parse_str("34093c29-4306-43de-452f-3f944bde22be").expect("Invalid UUID");
    //! let region = Region::EU;
    //! let result = valorant_api::get_store_front_v1(credentials_manager, &http_client, region, puuid).await;
    //! println!("Result: {:#?}", result);
    //! ```

    let url = Url::from_str(
        format!(
            "https://pd.{}.a.pvp.net/store/v2/storefront/{}",
            region.to_shard(),
            puuid,
        )
        .as_str(),
    )?;

    fetch_endpoint(
        credentials_manager,
        http_client,
        url,
        Method::GET,
        "",
        &HashMap::new(),
    )
    .await
}

pub async fn get_account_aliases<T: HttpClient>(
    credentials_manager: &CredentialsManager,
    http_client: &T,
    cluster: &str,
    game_name: Option<&str>,
    tag_line: Option<&str>,
) -> Result<AccountAliasesV1, RequestError> {
    //! Get the account aliases of a player.
    //! This can be used to search for an account by game name and/or tag_line and get their puuid.
    //! # Arguments
    //! * `credentials_manager` - The credentials manager
    //! * `http_client` - The http client
    //! * `cluster` - The cluster of the player
    //! * `game_name` - The game name of the player
    //! * `tag_line` - The tag line of the player
    //! # Errors
    //! `RequestError` - If the request failed
    //! # Example
    //! ```rust no_run
    //! let result = valorant_api::get_account_aliases(credentials_manager, &http_client, "eu", None, None).await;
    //! println!("Result: {:#?}", result);
    //! ```
    let mut url = Url::from_str(
        format!(
            "https://{}.api.account.riotgames.com/aliases/v1/aliases",
            cluster
        )
        .to_string()
        .as_str(),
    )?;
    if let Some(game_name) = game_name {
        url.query_pairs_mut().append_pair("gameName", game_name);
    }
    if let Some(tag_line) = tag_line {
        url.query_pairs_mut().append_pair("tagLine", tag_line);
    }

    fetch_endpoint(
        credentials_manager,
        http_client,
        url,
        Method::GET,
        "",
        &HashMap::new(),
    )
    .await
}