ticketmaster-rs 0.0.9

use bon::bon;

use serde::{Deserialize, Serialize};

use crate::{
    error::Result,
    models::{event::Event, response::DiscoveryPagedData},
    request_builder::RequestBuilder,
    Discovery,
};

#[derive(Debug, Serialize, Deserialize)]
struct EventSearchResponse {
    pub events: Vec<Event>,
}

#[bon]
impl Discovery {
    #[builder]
    pub async fn search_event(
        &self,
        id: Option<&str>,
        keyword: Option<&str>,
        attraction_id: Option<&str>,
        venue_id: Option<&str>,
        postal_code: Option<&str>,
        latlong: Option<&str>,
        radius: Option<&str>,
        unit: Option<&str>,
        source: Option<&str>,
        locale: Option<&str>,
        market_id: Option<&str>,
        start_date_time: Option<&str>,
        end_date_time: Option<&str>,
        include_tba: Option<&str>,
        include_tbd: Option<&str>,
        include_test: Option<&str>,
        size: Option<&str>,
        page: Option<&str>,
        sort: Option<&str>,
        onsale_start_date_time: Option<&str>,
        onsale_end_date_time: Option<&str>,
        city: Option<&str>,
        country_code: Option<&str>,
        state_code: Option<&str>,
        classification_name: Option<&str>,
        classification_id: Option<&str>,
        dma_id: Option<&str>,
        onsale_on_start_date: Option<&str>,
        onsale_on_after_start_date: Option<&str>,
        segment_id: Option<&str>,
        segment_name: Option<&str>,
        promoter_id: Option<&str>,
        client_visibility: Option<&str>,
        nlp: Option<&str>,
        include_licensed_content: Option<&str>,
        geopoint: Option<&str>,
    ) -> Result<DiscoveryPagedData<Vec<Event>>> {
        let mut builder = RequestBuilder::new();
        builder.add_arg_opt("id", id);
        builder.add_arg_opt("keyword", keyword);
        builder.add_arg_opt("attractionId", attraction_id);
        builder.add_arg_opt("venueId", venue_id);
        builder.add_arg_opt("postalCode", postal_code);
        builder.add_arg_opt("latlong", latlong);
        builder.add_arg_opt("radius", radius);
        builder.add_arg_opt("unit", unit);
        builder.add_arg_opt("source", source);
        builder.add_arg_opt("locale", locale);
        builder.add_arg_opt("marketId", market_id);
        builder.add_arg_opt("startDateTime", start_date_time);
        builder.add_arg_opt("endDateTime", end_date_time);
        builder.add_arg_opt("includeTba", include_tba);
        builder.add_arg_opt("includeTbd", include_tbd);
        builder.add_arg_opt("includeTest", include_test);
        builder.add_arg_opt("size", size);
        builder.add_arg_opt("page", page);
        builder.add_arg_opt("sort", sort);
        builder.add_arg_opt("onsaleStartDateTime", onsale_start_date_time);
        builder.add_arg_opt("onsaleEndDateTime", onsale_end_date_time);
        builder.add_arg_opt("city", city);
        builder.add_arg_opt("countryCode", country_code);
        builder.add_arg_opt("stateCode", state_code);
        builder.add_arg_opt("classificationName", classification_name);
        builder.add_arg_opt("classificationId", classification_id);
        builder.add_arg_opt("dmaId", dma_id);
        builder.add_arg_opt("onsaleOnStartDate", onsale_on_start_date);
        builder.add_arg_opt("onsaleOnAfterStartDate", onsale_on_after_start_date);
        builder.add_arg_opt("segmentId", segment_id);
        builder.add_arg_opt("segmentName", segment_name);
        builder.add_arg_opt("promoterId", promoter_id);
        builder.add_arg_opt("clientVisibility", client_visibility);
        builder.add_arg_opt("nlp", nlp);
        builder.add_arg_opt("includeLicensedContent", include_licensed_content);
        builder.add_arg_opt("geoPoint", geopoint);

        let args = builder.build_request();

        tracing::info!(%args, "request built");

        let res = self
            .call_paged_request::<EventSearchResponse>("/events", args)
            .await?;

        let res = res.transform(|a| a.events);

        Ok(res)
    }

    #[builder]
    pub async fn event_details(&self, id: &str, locale: Option<&str>) -> Result<Event> {
        let mut builder = RequestBuilder::new();
        builder.add_arg_opt("locale", locale);

        let args = builder.build_request();

        tracing::info!(%args, "request built");

        let res = self
            .call_request::<Event>(&format!("/events/{id}"), args)
            .await?;

        Ok(res)
    }
}

#[cfg(test)]
mod tests {

    use crate::Discovery;

    #[tokio::test]
    async fn assert_serialization() {
        tracing_subscriber::fmt().init();
        let api = Discovery::new(std::env!("DISCOVERY_API_KEY"));

        let binding = api
            .search_event()
            .latlong("45.4685030,9.1824027")
            .locale("it")
            .sort("distance,date,asc")
            .keyword("will")
            .call()
            .await
            .unwrap()
            .data
            .unwrap_or_default();
        // binding.retain(|a| a.dates.end.is_some());
        let data = binding.into_iter().next().unwrap();

        tracing::info!(?data);
    }
}