the-odds-api 0.1.1

//! The Odds API client implementation.

use crate::error::{Error, Result};
use crate::models::*;
use crate::types::*;
use chrono::{DateTime, Utc};
use reqwest::Client;
use url::Url;

const DEFAULT_BASE_URL: &str = "https://api.the-odds-api.com";
const IPV6_BASE_URL: &str = "https://ipv6-api.the-odds-api.com";

/// Builder for configuring the API client.
#[derive(Debug, Clone)]
pub struct TheOddsApiClientBuilder {
    api_key: String,
    base_url: String,
    client: Option<Client>,
}

impl TheOddsApiClientBuilder {
    /// Create a new builder with the given API key.
    pub fn new(api_key: impl Into<String>) -> Self {
        Self {
            api_key: api_key.into(),
            base_url: DEFAULT_BASE_URL.to_string(),
            client: None,
        }
    }

    /// Use a custom base URL.
    pub fn base_url(mut self, url: impl Into<String>) -> Self {
        self.base_url = url.into();
        self
    }

    /// Use the IPv6 endpoint.
    pub fn use_ipv6(mut self) -> Self {
        self.base_url = IPV6_BASE_URL.to_string();
        self
    }

    /// Use a custom reqwest client.
    pub fn client(mut self, client: Client) -> Self {
        self.client = Some(client);
        self
    }

    /// Build the API client.
    pub fn build(self) -> TheOddsApiClient {
        TheOddsApiClient {
            api_key: self.api_key,
            base_url: self.base_url,
            client: self.client.unwrap_or_default(),
        }
    }
}

/// The main client for interacting with The Odds API.
#[derive(Debug, Clone)]
pub struct TheOddsApiClient {
    api_key: String,
    base_url: String,
    client: Client,
}

impl TheOddsApiClient {
    /// Create a new client with the given API key.
    pub fn new(api_key: impl Into<String>) -> Self {
        TheOddsApiClientBuilder::new(api_key).build()
    }

    /// Create a builder for more advanced configuration.
    pub fn builder(api_key: impl Into<String>) -> TheOddsApiClientBuilder {
        TheOddsApiClientBuilder::new(api_key)
    }

    /// Build a URL with the given path and query parameters.
    fn build_url(&self, path: &str, params: &[(&str, String)]) -> Result<Url> {
        let mut url = Url::parse(&format!("{}{}", self.base_url, path))?;
        {
            let mut query = url.query_pairs_mut();
            query.append_pair("apiKey", &self.api_key);
            for (key, value) in params {
                if !value.is_empty() {
                    query.append_pair(key, value);
                }
            }
        }
        Ok(url)
    }

    /// Execute a GET request and parse the response.
    async fn get<T: serde::de::DeserializeOwned>(&self, url: Url) -> Result<Response<T>> {
        let response = self.client.get(url).send().await?;
        let usage = UsageInfo::from_headers(response.headers());
        let status = response.status();

        if status.is_success() {
            let data = response.json().await?;
            Ok(Response::new(data, usage))
        } else if status == reqwest::StatusCode::UNAUTHORIZED {
            Err(Error::Unauthorized)
        } else if status == reqwest::StatusCode::TOO_MANY_REQUESTS {
            Err(Error::RateLimited {
                requests_remaining: usage.requests_remaining,
            })
        } else {
            let message = response
                .text()
                .await
                .unwrap_or_else(|_| "Unknown error".to_string());
            Err(Error::Api {
                status: status.as_u16(),
                message,
            })
        }
    }

    // =========================================================================
    // Sports Endpoint
    // =========================================================================

    /// Get all in-season sports.
    ///
    /// This endpoint does not count against your usage quota.
    ///
    /// # Example
    ///
    /// ```no_run
    /// # async fn example() -> the_odds_api::Result<()> {
    /// let client = the_odds_api::TheOddsApiClient::new("your-api-key");
    /// let sports = client.get_sports().await?;
    /// for sport in sports.data {
    ///     println!("{}: {}", sport.key, sport.title);
    /// }
    /// # Ok(())
    /// # }
    /// ```
    pub async fn get_sports(&self) -> Result<Response<Vec<Sport>>> {
        let url = self.build_url("/v4/sports", &[])?;
        self.get(url).await
    }

    /// Get all sports, including out-of-season ones.
    ///
    /// This endpoint does not count against your usage quota.
    pub async fn get_all_sports(&self) -> Result<Response<Vec<Sport>>> {
        let url = self.build_url("/v4/sports", &[("all", "true".to_string())])?;
        self.get(url).await
    }

    // =========================================================================
    // Events Endpoint
    // =========================================================================

    /// Get events for a sport without odds.
    ///
    /// This endpoint does not count against your usage quota.
    pub fn get_events(&self, sport: impl Into<String>) -> GetEventsRequest<'_> {
        GetEventsRequest::new(self, sport.into())
    }

    // =========================================================================
    // Odds Endpoint
    // =========================================================================

    /// Get odds for a sport.
    ///
    /// # Quota Cost
    /// Cost = number of markets × number of regions
    ///
    /// # Example
    ///
    /// ```no_run
    /// # use the_odds_api::{Region, Market};
    /// # async fn example() -> the_odds_api::Result<()> {
    /// let client = the_odds_api::TheOddsApiClient::new("your-api-key");
    /// let odds = client
    ///     .get_odds("americanfootball_nfl")
    ///     .regions(&[Region::Us])
    ///     .markets(&[Market::H2h, Market::Spreads])
    ///     .send()
    ///     .await?;
    /// # Ok(())
    /// # }
    /// ```
    pub fn get_odds(&self, sport: impl Into<String>) -> GetOddsRequest<'_> {
        GetOddsRequest::new(self, sport.into())
    }

    /// Get odds for upcoming events across all sports.
    pub fn get_upcoming_odds(&self) -> GetOddsRequest<'_> {
        GetOddsRequest::new(self, "upcoming".to_string())
    }

    // =========================================================================
    // Scores Endpoint
    // =========================================================================

    /// Get scores for a sport.
    ///
    /// # Quota Cost
    /// 1 for live/upcoming scores, 2 when using `days_from`.
    pub fn get_scores(&self, sport: impl Into<String>) -> GetScoresRequest<'_> {
        GetScoresRequest::new(self, sport.into())
    }

    // =========================================================================
    // Event Odds Endpoint
    // =========================================================================

    /// Get detailed odds for a single event.
    ///
    /// This endpoint supports all available markets including player props.
    pub fn get_event_odds(
        &self,
        sport: impl Into<String>,
        event_id: impl Into<String>,
    ) -> GetEventOddsRequest<'_> {
        GetEventOddsRequest::new(self, sport.into(), event_id.into())
    }

    // =========================================================================
    // Event Markets Endpoint
    // =========================================================================

    /// Discover available markets for an event.
    ///
    /// # Quota Cost
    /// 1
    pub fn get_event_markets(
        &self,
        sport: impl Into<String>,
        event_id: impl Into<String>,
    ) -> GetEventMarketsRequest<'_> {
        GetEventMarketsRequest::new(self, sport.into(), event_id.into())
    }

    // =========================================================================
    // Participants Endpoint
    // =========================================================================

    /// Get all participants (teams/players) for a sport.
    ///
    /// # Quota Cost
    /// 1
    pub async fn get_participants(
        &self,
        sport: impl Into<String>,
    ) -> Result<Response<Vec<Participant>>> {
        let url = self.build_url(&format!("/v4/sports/{}/participants", sport.into()), &[])?;
        self.get(url).await
    }

    // =========================================================================
    // Historical Endpoints
    // =========================================================================

    /// Get historical odds for a sport at a specific timestamp.
    ///
    /// # Quota Cost
    /// 10 × number of markets × number of regions
    pub fn get_historical_odds(&self, sport: impl Into<String>) -> GetHistoricalOddsRequest<'_> {
        GetHistoricalOddsRequest::new(self, sport.into())
    }

    /// Get historical events for a sport at a specific timestamp.
    ///
    /// # Quota Cost
    /// 1 (0 if no events found)
    pub fn get_historical_events(&self, sport: impl Into<String>) -> GetHistoricalEventsRequest<'_> {
        GetHistoricalEventsRequest::new(self, sport.into())
    }

    /// Get historical odds for a single event at a specific timestamp.
    pub fn get_historical_event_odds(
        &self,
        sport: impl Into<String>,
        event_id: impl Into<String>,
    ) -> GetHistoricalEventOddsRequest<'_> {
        GetHistoricalEventOddsRequest::new(self, sport.into(), event_id.into())
    }
}

// =============================================================================
// Request Builders
// =============================================================================

/// Request builder for getting events.
#[derive(Debug)]
pub struct GetEventsRequest<'a> {
    client: &'a TheOddsApiClient,
    sport: String,
    date_format: Option<DateFormat>,
    event_ids: Option<Vec<String>>,
    commence_time_from: Option<DateTime<Utc>>,
    commence_time_to: Option<DateTime<Utc>>,
}

impl<'a> GetEventsRequest<'a> {
    fn new(client: &'a TheOddsApiClient, sport: String) -> Self {
        Self {
            client,
            sport,
            date_format: None,
            event_ids: None,
            commence_time_from: None,
            commence_time_to: None,
        }
    }

    /// Set the date format for the response.
    pub fn date_format(mut self, format: DateFormat) -> Self {
        self.date_format = Some(format);
        self
    }

    /// Filter by specific event IDs.
    pub fn event_ids(mut self, ids: impl IntoIterator<Item = impl Into<String>>) -> Self {
        self.event_ids = Some(ids.into_iter().map(Into::into).collect());
        self
    }

    /// Filter events starting from this time.
    pub fn commence_time_from(mut self, time: DateTime<Utc>) -> Self {
        self.commence_time_from = Some(time);
        self
    }

    /// Filter events starting until this time.
    pub fn commence_time_to(mut self, time: DateTime<Utc>) -> Self {
        self.commence_time_to = Some(time);
        self
    }

    /// Execute the request.
    pub async fn send(self) -> Result<Response<Vec<Event>>> {
        let mut params = Vec::new();

        if let Some(fmt) = self.date_format {
            params.push(("dateFormat", fmt.to_string()));
        }
        if let Some(ids) = self.event_ids {
            params.push(("eventIds", ids.join(",")));
        }
        if let Some(time) = self.commence_time_from {
            params.push(("commenceTimeFrom", time.to_rfc3339()));
        }
        if let Some(time) = self.commence_time_to {
            params.push(("commenceTimeTo", time.to_rfc3339()));
        }

        let url = self
            .client
            .build_url(&format!("/v4/sports/{}/events", self.sport), &params)?;
        self.client.get(url).await
    }
}

/// Request builder for getting odds.
#[derive(Debug)]
pub struct GetOddsRequest<'a> {
    client: &'a TheOddsApiClient,
    sport: String,
    regions: Vec<Region>,
    markets: Option<Vec<Market>>,
    date_format: Option<DateFormat>,
    odds_format: Option<OddsFormat>,
    event_ids: Option<Vec<String>>,
    bookmakers: Option<Vec<String>>,
    commence_time_from: Option<DateTime<Utc>>,
    commence_time_to: Option<DateTime<Utc>>,
    include_links: Option<bool>,
    include_sids: Option<bool>,
    include_bet_limits: Option<bool>,
}

impl<'a> GetOddsRequest<'a> {
    fn new(client: &'a TheOddsApiClient, sport: String) -> Self {
        Self {
            client,
            sport,
            regions: Vec::new(),
            markets: None,
            date_format: None,
            odds_format: None,
            event_ids: None,
            bookmakers: None,
            commence_time_from: None,
            commence_time_to: None,
            include_links: None,
            include_sids: None,
            include_bet_limits: None,
        }
    }

    /// Set the regions (required).
    pub fn regions(mut self, regions: &[Region]) -> Self {
        self.regions = regions.to_vec();
        self
    }

    /// Add a single region.
    pub fn region(mut self, region: Region) -> Self {
        self.regions.push(region);
        self
    }

    /// Set the markets to retrieve.
    pub fn markets(mut self, markets: &[Market]) -> Self {
        self.markets = Some(markets.to_vec());
        self
    }

    /// Add a single market.
    pub fn market(mut self, market: Market) -> Self {
        self.markets.get_or_insert_with(Vec::new).push(market);
        self
    }

    /// Set the date format.
    pub fn date_format(mut self, format: DateFormat) -> Self {
        self.date_format = Some(format);
        self
    }

    /// Set the odds format.
    pub fn odds_format(mut self, format: OddsFormat) -> Self {
        self.odds_format = Some(format);
        self
    }

    /// Filter by specific event IDs.
    pub fn event_ids(mut self, ids: impl IntoIterator<Item = impl Into<String>>) -> Self {
        self.event_ids = Some(ids.into_iter().map(Into::into).collect());
        self
    }

    /// Filter by specific bookmakers.
    pub fn bookmakers(mut self, bookmakers: impl IntoIterator<Item = impl Into<String>>) -> Self {
        self.bookmakers = Some(bookmakers.into_iter().map(Into::into).collect());
        self
    }

    /// Filter events starting from this time.
    pub fn commence_time_from(mut self, time: DateTime<Utc>) -> Self {
        self.commence_time_from = Some(time);
        self
    }

    /// Filter events starting until this time.
    pub fn commence_time_to(mut self, time: DateTime<Utc>) -> Self {
        self.commence_time_to = Some(time);
        self
    }

    /// Include deep links to bookmaker pages.
    pub fn include_links(mut self, include: bool) -> Self {
        self.include_links = Some(include);
        self
    }

    /// Include site IDs.
    pub fn include_sids(mut self, include: bool) -> Self {
        self.include_sids = Some(include);
        self
    }

    /// Include bet limits.
    pub fn include_bet_limits(mut self, include: bool) -> Self {
        self.include_bet_limits = Some(include);
        self
    }

    /// Execute the request.
    pub async fn send(self) -> Result<Response<Vec<EventOdds>>> {
        if self.regions.is_empty() {
            return Err(Error::MissingParameter("regions"));
        }

        let mut params = vec![("regions", format_csv(&self.regions))];

        if let Some(markets) = self.markets {
            params.push(("markets", format_csv(&markets)));
        }
        if let Some(fmt) = self.date_format {
            params.push(("dateFormat", fmt.to_string()));
        }
        if let Some(fmt) = self.odds_format {
            params.push(("oddsFormat", fmt.to_string()));
        }
        if let Some(ids) = self.event_ids {
            params.push(("eventIds", ids.join(",")));
        }
        if let Some(bookmakers) = self.bookmakers {
            params.push(("bookmakers", bookmakers.join(",")));
        }
        if let Some(time) = self.commence_time_from {
            params.push(("commenceTimeFrom", time.to_rfc3339()));
        }
        if let Some(time) = self.commence_time_to {
            params.push(("commenceTimeTo", time.to_rfc3339()));
        }
        if let Some(true) = self.include_links {
            params.push(("includeLinks", "true".to_string()));
        }
        if let Some(true) = self.include_sids {
            params.push(("includeSids", "true".to_string()));
        }
        if let Some(true) = self.include_bet_limits {
            params.push(("includeBetLimits", "true".to_string()));
        }

        let url = self
            .client
            .build_url(&format!("/v4/sports/{}/odds", self.sport), &params)?;
        self.client.get(url).await
    }
}

/// Request builder for getting scores.
#[derive(Debug)]
pub struct GetScoresRequest<'a> {
    client: &'a TheOddsApiClient,
    sport: String,
    days_from: Option<u8>,
    date_format: Option<DateFormat>,
    event_ids: Option<Vec<String>>,
}

impl<'a> GetScoresRequest<'a> {
    fn new(client: &'a TheOddsApiClient, sport: String) -> Self {
        Self {
            client,
            sport,
            days_from: None,
            date_format: None,
            event_ids: None,
        }
    }

    /// Include games from the past 1-3 days.
    pub fn days_from(mut self, days: u8) -> Self {
        self.days_from = Some(days.clamp(1, 3));
        self
    }

    /// Set the date format.
    pub fn date_format(mut self, format: DateFormat) -> Self {
        self.date_format = Some(format);
        self
    }

    /// Filter by specific event IDs.
    pub fn event_ids(mut self, ids: impl IntoIterator<Item = impl Into<String>>) -> Self {
        self.event_ids = Some(ids.into_iter().map(Into::into).collect());
        self
    }

    /// Execute the request.
    pub async fn send(self) -> Result<Response<Vec<EventScore>>> {
        let mut params = Vec::new();

        if let Some(days) = self.days_from {
            params.push(("daysFrom", days.to_string()));
        }
        if let Some(fmt) = self.date_format {
            params.push(("dateFormat", fmt.to_string()));
        }
        if let Some(ids) = self.event_ids {
            params.push(("eventIds", ids.join(",")));
        }

        let url = self
            .client
            .build_url(&format!("/v4/sports/{}/scores", self.sport), &params)?;
        self.client.get(url).await
    }
}

/// Request builder for getting event odds.
#[derive(Debug)]
pub struct GetEventOddsRequest<'a> {
    client: &'a TheOddsApiClient,
    sport: String,
    event_id: String,
    regions: Vec<Region>,
    markets: Option<Vec<Market>>,
    date_format: Option<DateFormat>,
    odds_format: Option<OddsFormat>,
    bookmakers: Option<Vec<String>>,
    include_links: Option<bool>,
    include_sids: Option<bool>,
    include_multipliers: Option<bool>,
}

impl<'a> GetEventOddsRequest<'a> {
    fn new(client: &'a TheOddsApiClient, sport: String, event_id: String) -> Self {
        Self {
            client,
            sport,
            event_id,
            regions: Vec::new(),
            markets: None,
            date_format: None,
            odds_format: None,
            bookmakers: None,
            include_links: None,
            include_sids: None,
            include_multipliers: None,
        }
    }

    /// Set the regions (required).
    pub fn regions(mut self, regions: &[Region]) -> Self {
        self.regions = regions.to_vec();
        self
    }

    /// Add a single region.
    pub fn region(mut self, region: Region) -> Self {
        self.regions.push(region);
        self
    }

    /// Set the markets to retrieve.
    pub fn markets(mut self, markets: &[Market]) -> Self {
        self.markets = Some(markets.to_vec());
        self
    }

    /// Add a single market.
    pub fn market(mut self, market: Market) -> Self {
        self.markets.get_or_insert_with(Vec::new).push(market);
        self
    }

    /// Add a custom market by key.
    pub fn custom_market(mut self, key: impl Into<String>) -> Self {
        self.markets
            .get_or_insert_with(Vec::new)
            .push(Market::Custom(key.into()));
        self
    }

    /// Set the date format.
    pub fn date_format(mut self, format: DateFormat) -> Self {
        self.date_format = Some(format);
        self
    }

    /// Set the odds format.
    pub fn odds_format(mut self, format: OddsFormat) -> Self {
        self.odds_format = Some(format);
        self
    }

    /// Filter by specific bookmakers.
    pub fn bookmakers(mut self, bookmakers: impl IntoIterator<Item = impl Into<String>>) -> Self {
        self.bookmakers = Some(bookmakers.into_iter().map(Into::into).collect());
        self
    }

    /// Include deep links.
    pub fn include_links(mut self, include: bool) -> Self {
        self.include_links = Some(include);
        self
    }

    /// Include site IDs.
    pub fn include_sids(mut self, include: bool) -> Self {
        self.include_sids = Some(include);
        self
    }

    /// Include DFS multipliers.
    pub fn include_multipliers(mut self, include: bool) -> Self {
        self.include_multipliers = Some(include);
        self
    }

    /// Execute the request.
    pub async fn send(self) -> Result<Response<EventOdds>> {
        if self.regions.is_empty() {
            return Err(Error::MissingParameter("regions"));
        }

        let mut params = vec![("regions", format_csv(&self.regions))];

        if let Some(markets) = self.markets {
            params.push(("markets", format_csv(&markets)));
        }
        if let Some(fmt) = self.date_format {
            params.push(("dateFormat", fmt.to_string()));
        }
        if let Some(fmt) = self.odds_format {
            params.push(("oddsFormat", fmt.to_string()));
        }
        if let Some(bookmakers) = self.bookmakers {
            params.push(("bookmakers", bookmakers.join(",")));
        }
        if let Some(true) = self.include_links {
            params.push(("includeLinks", "true".to_string()));
        }
        if let Some(true) = self.include_sids {
            params.push(("includeSids", "true".to_string()));
        }
        if let Some(true) = self.include_multipliers {
            params.push(("includeMultipliers", "true".to_string()));
        }

        let url = self.client.build_url(
            &format!("/v4/sports/{}/events/{}/odds", self.sport, self.event_id),
            &params,
        )?;
        self.client.get(url).await
    }
}

/// Request builder for getting event markets.
#[derive(Debug)]
pub struct GetEventMarketsRequest<'a> {
    client: &'a TheOddsApiClient,
    sport: String,
    event_id: String,
    regions: Vec<Region>,
    bookmakers: Option<Vec<String>>,
    date_format: Option<DateFormat>,
}

impl<'a> GetEventMarketsRequest<'a> {
    fn new(client: &'a TheOddsApiClient, sport: String, event_id: String) -> Self {
        Self {
            client,
            sport,
            event_id,
            regions: Vec::new(),
            bookmakers: None,
            date_format: None,
        }
    }

    /// Set the regions (required).
    pub fn regions(mut self, regions: &[Region]) -> Self {
        self.regions = regions.to_vec();
        self
    }

    /// Add a single region.
    pub fn region(mut self, region: Region) -> Self {
        self.regions.push(region);
        self
    }

    /// Filter by specific bookmakers.
    pub fn bookmakers(mut self, bookmakers: impl IntoIterator<Item = impl Into<String>>) -> Self {
        self.bookmakers = Some(bookmakers.into_iter().map(Into::into).collect());
        self
    }

    /// Set the date format.
    pub fn date_format(mut self, format: DateFormat) -> Self {
        self.date_format = Some(format);
        self
    }

    /// Execute the request.
    pub async fn send(self) -> Result<Response<EventMarkets>> {
        if self.regions.is_empty() {
            return Err(Error::MissingParameter("regions"));
        }

        let mut params = vec![("regions", format_csv(&self.regions))];

        if let Some(bookmakers) = self.bookmakers {
            params.push(("bookmakers", bookmakers.join(",")));
        }
        if let Some(fmt) = self.date_format {
            params.push(("dateFormat", fmt.to_string()));
        }

        let url = self.client.build_url(
            &format!(
                "/v4/sports/{}/events/{}/markets",
                self.sport, self.event_id
            ),
            &params,
        )?;
        self.client.get(url).await
    }
}

/// Request builder for historical odds.
#[derive(Debug)]
pub struct GetHistoricalOddsRequest<'a> {
    client: &'a TheOddsApiClient,
    sport: String,
    date: Option<DateTime<Utc>>,
    regions: Vec<Region>,
    markets: Option<Vec<Market>>,
    date_format: Option<DateFormat>,
    odds_format: Option<OddsFormat>,
    event_ids: Option<Vec<String>>,
    bookmakers: Option<Vec<String>>,
    commence_time_from: Option<DateTime<Utc>>,
    commence_time_to: Option<DateTime<Utc>>,
}

impl<'a> GetHistoricalOddsRequest<'a> {
    fn new(client: &'a TheOddsApiClient, sport: String) -> Self {
        Self {
            client,
            sport,
            date: None,
            regions: Vec::new(),
            markets: None,
            date_format: None,
            odds_format: None,
            event_ids: None,
            bookmakers: None,
            commence_time_from: None,
            commence_time_to: None,
        }
    }

    /// Set the historical snapshot date (required).
    pub fn date(mut self, date: DateTime<Utc>) -> Self {
        self.date = Some(date);
        self
    }

    /// Set the regions (required).
    pub fn regions(mut self, regions: &[Region]) -> Self {
        self.regions = regions.to_vec();
        self
    }

    /// Add a single region.
    pub fn region(mut self, region: Region) -> Self {
        self.regions.push(region);
        self
    }

    /// Set the markets to retrieve.
    pub fn markets(mut self, markets: &[Market]) -> Self {
        self.markets = Some(markets.to_vec());
        self
    }

    /// Set the date format.
    pub fn date_format(mut self, format: DateFormat) -> Self {
        self.date_format = Some(format);
        self
    }

    /// Set the odds format.
    pub fn odds_format(mut self, format: OddsFormat) -> Self {
        self.odds_format = Some(format);
        self
    }

    /// Filter by specific event IDs.
    pub fn event_ids(mut self, ids: impl IntoIterator<Item = impl Into<String>>) -> Self {
        self.event_ids = Some(ids.into_iter().map(Into::into).collect());
        self
    }

    /// Filter by specific bookmakers.
    pub fn bookmakers(mut self, bookmakers: impl IntoIterator<Item = impl Into<String>>) -> Self {
        self.bookmakers = Some(bookmakers.into_iter().map(Into::into).collect());
        self
    }

    /// Filter events starting from this time.
    pub fn commence_time_from(mut self, time: DateTime<Utc>) -> Self {
        self.commence_time_from = Some(time);
        self
    }

    /// Filter events starting until this time.
    pub fn commence_time_to(mut self, time: DateTime<Utc>) -> Self {
        self.commence_time_to = Some(time);
        self
    }

    /// Execute the request.
    pub async fn send(self) -> Result<Response<HistoricalResponse<Vec<EventOdds>>>> {
        let date = self.date.ok_or(Error::MissingParameter("date"))?;
        if self.regions.is_empty() {
            return Err(Error::MissingParameter("regions"));
        }

        let mut params = vec![
            ("date", date.to_rfc3339()),
            ("regions", format_csv(&self.regions)),
        ];

        if let Some(markets) = self.markets {
            params.push(("markets", format_csv(&markets)));
        }
        if let Some(fmt) = self.date_format {
            params.push(("dateFormat", fmt.to_string()));
        }
        if let Some(fmt) = self.odds_format {
            params.push(("oddsFormat", fmt.to_string()));
        }
        if let Some(ids) = self.event_ids {
            params.push(("eventIds", ids.join(",")));
        }
        if let Some(bookmakers) = self.bookmakers {
            params.push(("bookmakers", bookmakers.join(",")));
        }
        if let Some(time) = self.commence_time_from {
            params.push(("commenceTimeFrom", time.to_rfc3339()));
        }
        if let Some(time) = self.commence_time_to {
            params.push(("commenceTimeTo", time.to_rfc3339()));
        }

        let url = self
            .client
            .build_url(&format!("/v4/historical/sports/{}/odds", self.sport), &params)?;
        self.client.get(url).await
    }
}

/// Request builder for historical events.
#[derive(Debug)]
pub struct GetHistoricalEventsRequest<'a> {
    client: &'a TheOddsApiClient,
    sport: String,
    date: Option<DateTime<Utc>>,
    date_format: Option<DateFormat>,
    event_ids: Option<Vec<String>>,
    commence_time_from: Option<DateTime<Utc>>,
    commence_time_to: Option<DateTime<Utc>>,
}

impl<'a> GetHistoricalEventsRequest<'a> {
    fn new(client: &'a TheOddsApiClient, sport: String) -> Self {
        Self {
            client,
            sport,
            date: None,
            date_format: None,
            event_ids: None,
            commence_time_from: None,
            commence_time_to: None,
        }
    }

    /// Set the historical snapshot date (required).
    pub fn date(mut self, date: DateTime<Utc>) -> Self {
        self.date = Some(date);
        self
    }

    /// Set the date format.
    pub fn date_format(mut self, format: DateFormat) -> Self {
        self.date_format = Some(format);
        self
    }

    /// Filter by specific event IDs.
    pub fn event_ids(mut self, ids: impl IntoIterator<Item = impl Into<String>>) -> Self {
        self.event_ids = Some(ids.into_iter().map(Into::into).collect());
        self
    }

    /// Filter events starting from this time.
    pub fn commence_time_from(mut self, time: DateTime<Utc>) -> Self {
        self.commence_time_from = Some(time);
        self
    }

    /// Filter events starting until this time.
    pub fn commence_time_to(mut self, time: DateTime<Utc>) -> Self {
        self.commence_time_to = Some(time);
        self
    }

    /// Execute the request.
    pub async fn send(self) -> Result<Response<HistoricalResponse<Vec<Event>>>> {
        let date = self.date.ok_or(Error::MissingParameter("date"))?;

        let mut params = vec![("date", date.to_rfc3339())];

        if let Some(fmt) = self.date_format {
            params.push(("dateFormat", fmt.to_string()));
        }
        if let Some(ids) = self.event_ids {
            params.push(("eventIds", ids.join(",")));
        }
        if let Some(time) = self.commence_time_from {
            params.push(("commenceTimeFrom", time.to_rfc3339()));
        }
        if let Some(time) = self.commence_time_to {
            params.push(("commenceTimeTo", time.to_rfc3339()));
        }

        let url = self.client.build_url(
            &format!("/v4/historical/sports/{}/events", self.sport),
            &params,
        )?;
        self.client.get(url).await
    }
}

/// Request builder for historical event odds.
#[derive(Debug)]
pub struct GetHistoricalEventOddsRequest<'a> {
    client: &'a TheOddsApiClient,
    sport: String,
    event_id: String,
    date: Option<DateTime<Utc>>,
    regions: Vec<Region>,
    markets: Option<Vec<Market>>,
    date_format: Option<DateFormat>,
    odds_format: Option<OddsFormat>,
    include_multipliers: Option<bool>,
}

impl<'a> GetHistoricalEventOddsRequest<'a> {
    fn new(client: &'a TheOddsApiClient, sport: String, event_id: String) -> Self {
        Self {
            client,
            sport,
            event_id,
            date: None,
            regions: Vec::new(),
            markets: None,
            date_format: None,
            odds_format: None,
            include_multipliers: None,
        }
    }

    /// Set the historical snapshot date (required).
    pub fn date(mut self, date: DateTime<Utc>) -> Self {
        self.date = Some(date);
        self
    }

    /// Set the regions (required).
    pub fn regions(mut self, regions: &[Region]) -> Self {
        self.regions = regions.to_vec();
        self
    }

    /// Add a single region.
    pub fn region(mut self, region: Region) -> Self {
        self.regions.push(region);
        self
    }

    /// Set the markets to retrieve.
    pub fn markets(mut self, markets: &[Market]) -> Self {
        self.markets = Some(markets.to_vec());
        self
    }

    /// Set the date format.
    pub fn date_format(mut self, format: DateFormat) -> Self {
        self.date_format = Some(format);
        self
    }

    /// Set the odds format.
    pub fn odds_format(mut self, format: OddsFormat) -> Self {
        self.odds_format = Some(format);
        self
    }

    /// Include DFS multipliers.
    pub fn include_multipliers(mut self, include: bool) -> Self {
        self.include_multipliers = Some(include);
        self
    }

    /// Execute the request.
    pub async fn send(self) -> Result<Response<HistoricalResponse<EventOdds>>> {
        let date = self.date.ok_or(Error::MissingParameter("date"))?;
        if self.regions.is_empty() {
            return Err(Error::MissingParameter("regions"));
        }

        let mut params = vec![
            ("date", date.to_rfc3339()),
            ("regions", format_csv(&self.regions)),
        ];

        if let Some(markets) = self.markets {
            params.push(("markets", format_csv(&markets)));
        }
        if let Some(fmt) = self.date_format {
            params.push(("dateFormat", fmt.to_string()));
        }
        if let Some(fmt) = self.odds_format {
            params.push(("oddsFormat", fmt.to_string()));
        }
        if let Some(true) = self.include_multipliers {
            params.push(("includeMultipliers", "true".to_string()));
        }

        let url = self.client.build_url(
            &format!(
                "/v4/historical/sports/{}/events/{}/odds",
                self.sport, self.event_id
            ),
            &params,
        )?;
        self.client.get(url).await
    }
}