aob-lemmy-bot/src/fetchers/jnovel.rs

use crate::{HTTP_CLIENT, lemmy};
use chrono::{DateTime, Duration, Utc};
use serde_derive::{Deserialize, Serialize};
use std::cmp::Ordering;
use std::collections::HashMap;
use std::ops::Sub;
use async_trait::async_trait;
use url::Url;
use crate::fetchers::Fetcher;
use crate::fetchers::jnovel::JPostInfo::{Chapter, Volume};
use crate::fetchers::jnovel::PartInfo::{NoParts, Part};
use crate::lemmy::{PostInfo, PostInfoInner};
use systemd_journal_logger::connected_to_journal;

macro_rules! error {
    ($msg:tt) => {
        match connected_to_journal() {
            true => log::error!("[ERROR] {}", $msg),
            false => eprintln!("[ERROR] {}", $msg),
        }
    };
}

macro_rules! info {
    ($msg:tt) => {
        match connected_to_journal() {
            true => log::info!("[INFO] {}", $msg),
            false => println!("[INFO] {}", $msg),
        }
    };
}

static PAST_DAYS_ELIGIBLE: u8 = 4;

macro_rules! api_url {
    () => {
        "https://labs.j-novel.club/app/v1".to_owned()
    };
}

macro_rules! jnc_base_url {
    () => {
        "https://j-novel.club".to_owned()
    };
}

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
struct VolumesWrapper {
    volumes: Vec<VolumeDetail>,
    pagination: PaginationInfo,
}

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
struct ChapterWrapper {
    parts: Vec<ChapterDetail>,
    pagination: PaginationInfo,
}

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
struct PaginationInfo {
    limit: usize,
    skip: usize,
    #[serde(alias = "lastPage")]
    last_page: bool,
}

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
pub(crate) struct Cover {
    #[serde(alias = "coverUrl")]
    pub(crate) cover: String,
    #[serde(alias = "thumbnailUrl")]
    pub(crate) thumbnail: String,
}

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
pub(crate) struct VolumeDetail {
    pub(crate) title: String,
    pub(crate) slug: String,
    number: u8,
    publishing: String,
    #[serde(alias = "shortDescription")]
    short_description: String,
    cover: Cover,
}

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
pub(crate) struct ChapterDetail {
    pub(crate) title: String,
    pub(crate) slug: String,
    launch: String,
    pub(crate) cover: Option<Cover>,
}

#[derive(Debug, Copy, Clone)]
pub(crate) enum PartInfo {
    NoParts,
    Part(u8),
}

impl PartInfo {
    pub(crate) fn as_u8(&self) -> u8 {
        match self {
            Part(number) => *number,
            NoParts => 0,
        }
    }

    pub(crate) fn as_string(&self) -> String {
        self.as_u8().to_string()
    }
}

impl PartialEq for PartInfo {
    fn eq(&self, other: &Self) -> bool {
        let self_numeric = self.as_u8();
        let other_numeric = other.as_u8();
        self_numeric == other_numeric
    }
}

impl PartialOrd for PartInfo {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        if self.gt(other) {
            Some(Ordering::Greater)
        } else if self.eq(other) {
            Some(Ordering::Equal)
        } else {
            Some(Ordering::Less)
        }
    }

    fn lt(&self, other: &Self) -> bool {
        let self_numeric = self.as_u8();
        let other_numeric = other.as_u8();

        self_numeric < other_numeric
    }

    fn le(&self, other: &Self) -> bool {
        !self.gt(other)
    }

    fn gt(&self, other: &Self) -> bool {
        let self_numeric = self.as_u8();
        let other_numeric = other.as_u8();

        self_numeric > other_numeric
    }

    fn ge(&self, other: &Self) -> bool {
        !self.lt(other)
    }
}

#[derive(Debug, Clone)]
pub(crate) enum JPostInfo {
    Chapter {
        part: PartInfo,
        lemmy_info: PostInfoInner,
    },
    Volume {
        part: PartInfo,
        description: String,
        lemmy_info: PostInfoInner,
    },
}

impl JPostInfo {
    pub(crate) fn get_part_info(&self) -> PartInfo {
        match self {
            Chapter {
                part: part_info, ..
            } => *part_info,
            Volume {
                part: part_info, ..
            } => *part_info,
        }
    }
}

impl PostInfo for JPostInfo {
    fn get_info(&self) -> PostInfoInner {
        match self {
            Chapter { lemmy_info, .. } => lemmy_info.clone(),
            Volume { lemmy_info, .. } => lemmy_info.clone(),
        }
    }

    fn get_description(&self) -> Option<String> {
        match self {
            Chapter { .. } => None,
            Volume { description, .. } => Some(description.clone()),
        }
    }
}

impl PartialEq for JPostInfo {
    fn eq(&self, other: &Self) -> bool {
        let self_part = match self {
            Chapter { part, .. } => part,
            Volume { part, .. } => part,
        };

        let other_part = match other {
            Chapter { part, .. } => part,
            Volume { part, .. } => part,
        };

        self_part.eq(other_part)
    }
}

impl PartialOrd for JPostInfo {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        if self.gt(other) {
            Some(Ordering::Greater)
        } else if self.eq(other) {
            Some(Ordering::Equal)
        } else {
            Some(Ordering::Less)
        }
    }

    fn lt(&self, other: &Self) -> bool {
        let self_part = match self {
            Chapter { part, .. } => part,
            Volume { part, .. } => part,
        };

        let other_part = match other {
            Chapter { part, .. } => part,
            Volume { part, .. } => part,
        };

        self_part < other_part
    }

    fn le(&self, other: &Self) -> bool {
        !self.gt(other)
    }

    fn gt(&self, other: &Self) -> bool {
        let self_part = match self {
            Chapter { part, .. } => part,
            Volume { part, .. } => part,
        };

        let other_part = match other {
            Chapter { part, .. } => part,
            Volume { part, .. } => part,
        };

        self_part > other_part
    }

    fn ge(&self, other: &Self) -> bool {
        !self.lt(other)
    }
}

pub(crate) struct JFetcherOptions {
    series_slug: String,
    series_has_parts: bool
}

impl JFetcherOptions {
    pub(crate) fn new(series_slug: String, series_has_parts: bool) -> Self {
        JFetcherOptions {
            series_slug,
            series_has_parts
        }
    }
}

#[async_trait]
impl Fetcher for JFetcherOptions {
    type Return = JPostInfo;
    async fn check_feed(&self) -> Result<Vec<Self::Return>, ()> {
        let response = match HTTP_CLIENT
            .get(api_url!() + "/series/" + self.series_slug.as_str() + "/volumes?format=json")
            .send()
            .await
        {
            Ok(data) => match data.text().await {
                Ok(data) => data,
                Err(e) => {
                    let err_msg = format!("While checking feed: {e}");
                    error!(err_msg);
                    return Err(());
                }
            },
            Err(e) => {
                let err_msg = format!("{e}");
                error!(err_msg);
                return Err(());
            }
        };

        let mut volume_brief_data: VolumesWrapper = match serde_json::from_str(&response) {
            Ok(data) => data,
            Err(e) => {
                let err_msg = format!("{e}");
                error!(err_msg);
                return Err(());
            }
        };
        volume_brief_data.volumes.reverse(); // Makes breaking out of the volume loop easier

        // If no parts just use 0 as Part indicator as no Series with Parts has a Part 0
        let mut volume_map: HashMap<u8, JPostInfo> = HashMap::new();
        let mut prepub_map: HashMap<u8, JPostInfo> = HashMap::new();

        for volume in volume_brief_data.volumes.iter() {
            let publishing_date = DateTime::parse_from_rfc3339(&volume.publishing).unwrap();
            if publishing_date < Utc::now().sub(Duration::days(PAST_DAYS_ELIGIBLE as i64)) {
                match self.series_has_parts {
                    true => continue,
                    false => break,
                }
            }
            let new_part_info: PartInfo;

            if self.series_has_parts {
                let mut part_number: Option<u8> = None;
                let splits: Vec<&str> = volume.slug.split('-').collect();
                for (index, split) in splits.clone().into_iter().enumerate() {
                    if split == "part" {
                        part_number = Some(
                            splits[index + 1]
                                .parse::<u8>()
                                .expect("Split Element after 'Part' should always be a number"),
                        );
                        break;
                    }
                }

                match part_number {
                    Some(number) => new_part_info = Part(number),
                    None => {
                        info!("No Part found, assuming 1");
                        new_part_info = Part(1);
                    }
                }
            } else {
                new_part_info = NoParts;
            }

            let post_url = format!(
                "{}/series/{}#volume-{}",
                jnc_base_url!(),
                self.series_slug.as_str(),
                volume.number
            );
            let post_details = lemmy::PostInfoInner {
                title: volume.title.clone(),
                url: Url::parse(&post_url).unwrap(),
            };

            let new_post_info = Volume {
                part: new_part_info,
                description: volume.short_description.clone(),
                lemmy_info: post_details,
            };

            let part_id = new_part_info.as_u8();

            if publishing_date <= Utc::now() {
                volume_map
                    .entry(part_id)
                    .and_modify(|val| {
                        if *val < new_post_info {
                            *val = new_post_info.clone()
                        }
                    })
                    .or_insert(new_post_info);
            }

            if let Some(prepub_info) = get_latest_prepub(&volume.slug).await? {
                let prepub_post_info = Chapter {
                    part: new_part_info,
                    lemmy_info: prepub_info,
                };

                prepub_map
                    .entry(part_id)
                    .and_modify(|val| {
                        if *val < prepub_post_info {
                            *val = prepub_post_info.clone()
                        }
                    })
                    .or_insert(prepub_post_info);
            }
        }

        let mut result_vec: Vec<JPostInfo> = volume_map.values().cloned().collect();
        let mut prepub_vec: Vec<JPostInfo> = prepub_map.values().cloned().collect();
        result_vec.append(&mut prepub_vec);

        Ok(result_vec)
    }
}


async fn get_latest_prepub(volume_slug: &str) -> Result<Option<lemmy::PostInfoInner>, ()> {
    let response = match HTTP_CLIENT
        .get(api_url!() + "/volumes/" + volume_slug + "/parts?format=json")
        .send()
        .await
    {
        Ok(data) => match data.text().await {
            Ok(data) => data,
            Err(e) => {
                let err_msg = format!("While getting latest PrePub: {e}");
                error!(err_msg);
                return Err(());
            }
        },
        Err(e) => {
            let err_msg = format!("{e}");
            error!(err_msg);
            return Err(());
        }
    };

    let mut volume_prepub_parts_data: ChapterWrapper = match serde_json::from_str(&response) {
        Ok(data) => data,
        Err(e) => {
            let err_msg = format!("{e}");
            error!(err_msg);
            return Err(());
        }
    };
    volume_prepub_parts_data.parts.reverse(); // Makes breaking out of the parts loop easier

    let mut post_details: Option<lemmy::PostInfoInner> = None;

    for prepub_part in volume_prepub_parts_data.parts.iter() {
        let publishing_date = DateTime::parse_from_rfc3339(&prepub_part.launch).unwrap();
        if publishing_date > Utc::now() {
            break;
        } else if publishing_date < Utc::now().sub(Duration::days(PAST_DAYS_ELIGIBLE as i64)) {
            continue;
        }

        let post_url = format!("{}/read/{}", jnc_base_url!(), prepub_part.slug);
        post_details = Some(lemmy::PostInfoInner {
            title: prepub_part.title.clone(),
            url: Url::parse(&post_url).unwrap(),
        });
    }

    Ok(post_details)
}