//! Dynasty reader's directory.

pub mod sample;

use std::collections::HashMap;

use serde::{Deserialize, Serialize};

use crate::{Tag, TagKind};

/// Dynasty reader's directory listing.
#[derive(Debug, Serialize, PartialEq, Eq)]
pub struct DirectoryListing {
    /// The directory's tags.
    pub tags: Vec<Tag>,
    /// The directory's current page.
    pub current_page: u16,
    /// The directory's total pages.
    pub total_pages: u16,
}

impl DirectoryListing {
    pub(crate) fn from_raw(raw: DirectoryRaw, kind: TagKind) -> DirectoryListing {
        let DirectoryRaw {
            tags,
            current_page,
            total_pages,
        } = raw;

        let tags = tags
            .into_iter()
            .flat_map(|tag| tag.into_values())
            .flatten()
            .map(|directory_tag| directory_tag.into_tag(kind))
            .collect();

        DirectoryListing {
            tags,
            current_page,
            total_pages,
        }
    }

    /// Helper method to extend [`DirectoryListing`] `tags` with another [`DirectoryListing`] `tags`.
    pub fn extend(&mut self, other: DirectoryListing) {
        let DirectoryListing { tags, .. } = other;
        self.tags.extend(tags)
    }

    /// Helper method to get the next page number.
    pub fn next_page(&self) -> Option<u16> {
        if self.total_pages > self.current_page {
            Some(self.current_page + 1)
        } else {
            None
        }
    }
}

#[derive(Debug, Deserialize)]
pub(crate) struct DirectoryRaw {
    tags: Vec<HashMap<String, Vec<DirectoryTag>>>,
    current_page: u16,
    total_pages: u16,
}

#[derive(Debug, Deserialize)]
pub(crate) struct DirectoryTag {
    #[serde(rename(deserialize = "name"))]
    title: String,
    permalink: String,
}

impl DirectoryTag {
    pub fn into_tag(self, kind: TagKind) -> Tag {
        let DirectoryTag { title, permalink } = self;
        Tag {
            kind,
            title,
            permalink,
        }
    }
}