use std::collections::HashMap;



#[derive(serde::Serialize, serde::Deserialize, Debug)]
pub struct VideosRequest {
    //"versionInstallDate":"2025-06-03T18:20:20Z","languageCode":"en","appInstallDate":"2025-06-03T18:20:20Z","server":"spacemoehre","sexu
    pub clientHash: Option<String>, // "a07b23c9b07813c65050e2a4041ca777",
    pub blockedKeywords: Option<String>, // "kittens",
    pub countryCode: Option<String>, // "DE",
    pub clientVersion: Option<String>, // "2.1.4-22b",
    pub timestamp: Option<String>, // "1748976686",
    pub blockedUploaders: Option<String>, // "",
    pub anonId: Option<String>, // "1AB8A060-A47D-47EF-B9CB-63980ED84C8A",
    pub debugTools: Option<bool>, // false,
    pub versionInstallDate: Option<String>, // "2025-06-03T18:20:20Z",
    pub languageCode: Option<String>, // "en",
    pub appInstallDate: Option<String>, // "2025-06-03T18:20:20Z",
    pub server: Option<String>, // "spacemoehre",
    pub sexuality: Option<String>, // "straight",
    pub channel: Option<String>, //"youtube",
    pub sort: Option<String>,    //"new",
    pub query: Option<String>,   //"kittens",
    pub page: Option<String>,    //1,
    pub perPage: Option<String>, //10,
                                 // Your server's global options will be sent in the videos request
                                 //   pub flavor: "mint chocolate chip"
    pub featured: Option<String>, // "featured",
    pub category: Option<String>, // "pmv"
    pub sites: Option<String>, // 
}

#[derive(serde::Serialize, serde::Deserialize, Debug, Clone)]
pub struct ServerOptions{
    pub featured: Option<String>, // "featured",
    pub category: Option<String>, // "pmv"
    pub sites: Option<String>, // 
}

#[derive(serde::Serialize, Debug)]
pub struct PageInfo {
    pub hasNextPage: bool,   // true,
    pub resultsPerPage: u32, // 10
}


#[derive(serde::Serialize, Debug, Clone)]
pub struct VideoEmbed{
    pub html: String,
    pub source: String,
}
impl VideoEmbed {
    pub fn new(html: String, source: String) -> Self {
        VideoEmbed {
            html,
            source,
        }
    }
}
#[derive(serde::Serialize, Debug, Clone)]
pub struct VideoItem {
    pub duration: u32,              // 110,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub views: Option<u32>,         // 14622653,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub rating: Option<f32>,        // 0.0,
    pub id: String, // "c85017ca87477168d648727753c4ded8a35f173e22ef93743e707b296becb299",
    pub title: String, // "20 Minutes of Adorable Kittens   BEST Compilation",
    pub url: String, // "https://www.youtube.com/watch?v=y0sF5xhGreA",
    pub channel: String, // "youtube",
    pub thumb: String, // "https://i.ytimg.com/vi/y0sF5xhGreA/hqdefault.jpg",
    #[serde(skip_serializing_if = "Option::is_none")]
    pub uploader: Option<String>, // "The Pet Collective",
    #[serde(skip_serializing_if = "Option::is_none")]
    pub uploaderUrl: Option<String>, // "https://www.youtube.com/@petcollective",
    #[serde(skip_serializing_if = "Option::is_none")]
    pub verified: Option<bool>, // false,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<String>>, // [],
    #[serde(skip_serializing_if = "Option::is_none")]
    pub uploadedAt: Option<u64>, // 1741142954
    #[serde(skip_serializing_if = "Option::is_none")]
    pub formats: Option<Vec<VideoFormat>>, // Additional HTTP headers if needed
    #[serde(skip_serializing_if = "Option::is_none")]
    pub embed: Option<VideoEmbed>, // Optional embed information
    #[serde(skip_serializing_if = "Option::is_none")]
    pub preview: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub aspectRation: Option<f32>
}
#[allow(dead_code)]
impl VideoItem {
    pub fn new(
        id: String,
        title: String,
        url: String,
        channel: String,
        thumb: String,
        duration: u32,
    ) -> Self {
        VideoItem {
            duration: duration,  // Placeholder, adjust as needed
            views: None,  // Placeholder, adjust as needed
            rating: None, // Placeholder, adjust as needed
            id,
            title,
            url,
            channel,
            thumb,
            uploader: None,
            uploaderUrl: None,
            verified: None,
            tags: None, // Placeholder, adjust as needed
            uploadedAt: None,
            formats: None, // Placeholder for formats
            embed: None, // Placeholder for embed information
            preview: None,
            aspectRation: None
        }
    }
    pub fn tags(mut self, tags: Vec<String>) -> Self {
        self.tags = Some(tags);
        self
    }
    pub fn uploader(mut self, uploader: String) -> Self {
        self.uploader = Some(uploader);
        self
    }
    pub fn uploader_url(mut self, uploader_url: String) -> Self {
        self.uploaderUrl = Some(uploader_url);
        self
    }
    pub fn verified(mut self, verified: bool) -> Self {
        self.verified = Some(verified);
        self
    }
    pub fn views(mut self, views: u32) -> Self {
        self.views = Some(views);
        self
    }
    pub fn rating(mut self, rating: f32) -> Self {
        self.rating = Some(rating);
        self
    }
    pub fn uploaded_at(mut self, uploaded_at: u64) -> Self {
        self.uploadedAt = Some(uploaded_at);
        self
    }
    pub fn formats(mut self, formats: Vec<VideoFormat>) -> Self {
        self.formats = Some(formats);
        self
    }
    pub fn add_format(mut self, format: VideoFormat){
        if let Some(formats) = self.formats.as_mut() {
            formats.push(format);
        } else {
            self.formats = Some(vec![format]);
        }
    }
    pub fn embed(mut self, embed: VideoEmbed) -> Self {
        self.embed = Some(embed);
        self
    }
    pub fn preview(mut self, preview: String) -> Self {
        self.preview = Some(preview);
        self
    }
    
    pub fn aspect_ratio(mut self, aspect_ratio: f32) -> Self {
        self.aspectRation = Some(aspect_ratio);
        self
    }
}

#[derive(serde::Serialize, Debug, Clone)]
pub struct VideoFormat {
    url: String,
    quality: String,
    format: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    format_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    format_note: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    filesize: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    asr: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    fps: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    width: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    height: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    tbr: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    language: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    language_preference: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    ext: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    vcodec: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    acodec: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    dynamic_range: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    abr: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    vbr: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    container: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    protocol: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    audio_ext: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    video_ext: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    resolution: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    http_headers: Option<HashMap<String, String>>,
    
}
impl VideoFormat {
    pub fn new(url: String, quality: String, format: String) -> Self {
        let _ = format;
        VideoFormat {
            url,
            quality,
            format: "mp4".to_string(), // Default format
            format_id: Some("mp4-1080".to_string()),
            format_note: None,
            filesize: None,
            asr: None,
            fps: None,
            width: None,
            height: None,
            tbr: None,
            language: None,
            language_preference: None,
            ext: Some("mp4".to_string()),
            vcodec: None,
            acodec: None,
            dynamic_range: None,
            abr: None,
            vbr: None,
            container: None,
            protocol: Some("m3u8_native".to_string()),
            audio_ext: Some("none".to_string()),
            video_ext: Some("mp4".to_string()),
            resolution: None,
            http_headers: None,
        }
    }
    pub fn add_http_header(&mut self, key: String, value: String) {
        if self.http_headers.is_none() {
            self.http_headers = Some(HashMap::new());
        }
        if let Some(headers) = &mut self.http_headers {
            headers.insert(key, value);
        }
    }

    pub fn protocol(mut self, protocol: String) -> Self {
        self.protocol = Some(protocol);
        self
    }
}
#[derive(serde::Serialize, Debug)]
pub struct Videos {
    pub pageInfo: PageInfo,
    pub items: Vec<VideoItem>,
}