use std::collections::HashSet;

use chrono::{DateTime, Utc};
use serde::Serialize;

#[derive(Serialize, Debug)]
pub enum PostType {
    Article,
    Note,
}

pub trait Post {
    fn id(&self) -> &str;
    fn subject(&self) -> Option<&str>;
    fn published_at(&self) -> &DateTime<Utc>;
    fn updated_at(&self) -> Option<&DateTime<Utc>>;
    fn tags(&self) -> &Vec<String>;
    fn lang(&self) -> &str;
    fn post_type(&self) -> PostType;
    fn content(&self) -> &str;

    fn link(&self) -> String {
        "https://en.blos.sm/posts/".to_owned() + self.id()
    }

    fn get_tags<'a>(posts: &'a Vec<Self>) -> Vec<&'a String>
    where
        Self: Sized,
    {
        let mut tags = posts
            .into_iter()
            .fold(HashSet::new(), |mut acc, post| {
                let tags = post.tags();
                for tag in tags {
                    acc.insert(tag);
                }
                acc
            })
            .into_iter()
            .collect::<Vec<_>>();
        tags.sort();
        tags
    }

    fn filter_by_tags(posts: Vec<Self>, filter_tags: &HashSet<String>) -> Vec<Self>
    where
        Self: Sized,
    {
        posts
            .into_iter()
            .filter(|post| {
                for tag in post.tags() {
                    match filter_tags.contains(tag) {
                        true => return true,
                        false => continue,
                    }
                }
                false
            })
            .collect()
    }
}