use serde::{ser::SerializeSeq, Serializer};
use std::time::Duration;

pub fn timeframe<S>(timeframe: &Duration, serializer: S) -> Result<S::Ok, S::Error>
where
    S: serde::Serializer,
{
    let mins = timeframe.as_secs() / 60;
    if mins < 60 {
        return serializer.serialize_str(&format!("{mins}Min"));
    }

    let hours = mins / 60;
    if hours < 24 {
        return serializer.serialize_str(&format!("{hours}Hour"));
    }

    let days = hours / 24;
    if days == 1 {
        return serializer.serialize_str("1Day");
    }

    let weeks = days / 7;
    if weeks == 1 {
        return serializer.serialize_str("1Week");
    }

    let months = days / 30;
    if [1, 2, 3, 4, 6, 12].contains(&months) {
        return serializer.serialize_str(&format!("{months}Month"));
    };

    Err(serde::ser::Error::custom("Invalid timeframe duration"))
}

fn remove_slash(pair: &str) -> String {
    pair.replace('/', "")
}

pub fn join_symbols<S>(symbols: &[String], serializer: S) -> Result<S::Ok, S::Error>
where
    S: Serializer,
{
    let string = symbols.join(",");
    serializer.serialize_str(&string)
}

pub fn join_symbols_option<S>(
    symbols: &Option<Vec<String>>,
    serializer: S,
) -> Result<S::Ok, S::Error>
where
    S: Serializer,
{
    match symbols {
        Some(symbols) => join_symbols(symbols, serializer),
        None => serializer.serialize_none(),
    }
}

pub fn remove_slash_from_symbols<'a, S, I>(symbols: I, serializer: S) -> Result<S::Ok, S::Error>
where
    S: Serializer,
    I: IntoIterator<Item = &'a String>,
{
    let symbols = symbols
        .into_iter()
        .map(|pair| remove_slash(pair))
        .collect::<Vec<_>>();

    let mut seq = serializer.serialize_seq(Some(symbols.len()))?;
    for symbol in symbols {
        seq.serialize_element(&symbol)?;
    }
    seq.end()
}

pub fn remove_slash_and_join_symbols<'a, S, I>(symbols: I, serializer: S) -> Result<S::Ok, S::Error>
where
    S: Serializer,
    I: IntoIterator<Item = &'a String>,
{
    let symbols = symbols
        .into_iter()
        .map(|symbol| remove_slash(symbol))
        .collect::<Vec<_>>();

    join_symbols(&symbols, serializer)
}