use serde::{Deserialize, Serialize};
use tetratto_shared::{snow::Snowflake, unix_epoch_timestamp};
use super::communities_permissions::CommunityPermission;

#[derive(Clone, Serialize, Deserialize)]
pub struct Community {
    pub id: usize,
    pub created: usize,
    pub title: String,
    pub context: CommunityContext,
    /// The ID of the owner of the community.
    pub owner: usize,
    /// Who can read the community.
    pub read_access: CommunityReadAccess,
    /// Who can write to the community (create posts belonging to it).
    ///
    /// The owner of the community (and moderators) are the ***only*** people
    /// capable of removing posts.
    pub write_access: CommunityWriteAccess,
    /// Who can join the community.
    pub join_access: CommunityJoinAccess,
    // likes
    pub likes: isize,
    pub dislikes: isize,
    // ...
    pub member_count: usize,
    pub is_forge: bool,
    pub post_count: usize,
}

impl Community {
    /// Create a new [`Community`].
    pub fn new(title: String, owner: usize) -> Self {
        Self {
            id: Snowflake::new().to_string().parse::<usize>().unwrap(),
            created: unix_epoch_timestamp() as usize,
            title: title.clone(),
            context: CommunityContext {
                display_name: title,
                ..Default::default()
            },
            owner,
            read_access: CommunityReadAccess::default(),
            write_access: CommunityWriteAccess::default(),
            join_access: CommunityJoinAccess::default(),
            likes: 0,
            dislikes: 0,
            member_count: 0,
            is_forge: false,
            post_count: 0,
        }
    }

    /// Create the "void" community. This is where all posts with a deleted community
    /// resolve to.
    pub fn void() -> Self {
        Self {
            id: 0,
            created: 0,
            title: "void".to_string(),
            context: CommunityContext::default(),
            owner: 0,
            read_access: CommunityReadAccess::Joined,
            write_access: CommunityWriteAccess::Owner,
            join_access: CommunityJoinAccess::Nobody,
            likes: 0,
            dislikes: 0,
            member_count: 0,
            is_forge: false,
            post_count: 0,
        }
    }
}

#[derive(Clone, Debug, Serialize, Deserialize, Default)]
pub struct CommunityContext {
    #[serde(default)]
    pub display_name: String,
    #[serde(default)]
    pub description: String,
    #[serde(default)]
    pub is_nsfw: bool,
    #[serde(default)]
    pub enable_questions: bool,
    /// If posts are allowed to set a `title` field.
    #[serde(default)]
    pub enable_titles: bool,
    /// If posts are required to set a `title` field.
    ///
    /// `enable_titles` is required for this setting to work.
    #[serde(default)]
    pub require_titles: bool,
}

/// Who can read a [`Community`].
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
pub enum CommunityReadAccess {
    /// Everybody can view the community.
    Everybody,
    /// Only people in the community can view the community.
    Joined,
}

impl Default for CommunityReadAccess {
    fn default() -> Self {
        Self::Everybody
    }
}

/// Who can write to a [`Community`].
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
pub enum CommunityWriteAccess {
    /// Everybody.
    Everybody,
    /// Only people who joined the community can write to it.
    ///
    /// Memberships can be managed by the owner of the community.
    Joined,
    /// Only the owner of the community.
    Owner,
}

impl Default for CommunityWriteAccess {
    fn default() -> Self {
        Self::Joined
    }
}

/// Who can join a [`Community`].
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
pub enum CommunityJoinAccess {
    /// Joins are closed. Nobody can join the community.
    Nobody,
    /// All authenticated users can join the community.
    Everybody,
    /// People must send a request to join.
    Request,
}

impl Default for CommunityJoinAccess {
    fn default() -> Self {
        Self::Everybody
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CommunityMembership {
    pub id: usize,
    pub created: usize,
    pub owner: usize,
    pub community: usize,
    pub role: CommunityPermission,
}

impl CommunityMembership {
    /// Create a new [`CommunityMembership`].
    pub fn new(owner: usize, community: usize, role: CommunityPermission) -> Self {
        Self {
            id: Snowflake::new().to_string().parse::<usize>().unwrap(),
            created: unix_epoch_timestamp() as usize,
            owner,
            community,
            role,
        }
    }
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct PostContext {
    #[serde(default = "default_comments_enabled")]
    pub comments_enabled: bool,
    #[serde(default)]
    pub is_pinned: bool,
    #[serde(default)]
    pub is_profile_pinned: bool,
    #[serde(default)]
    pub edited: usize,
    #[serde(default)]
    pub is_nsfw: bool,
    #[serde(default)]
    pub repost: Option<RepostContext>,
    #[serde(default = "default_reposts_enabled")]
    pub reposts_enabled: bool,
    /// The ID of the question this post is answering.
    #[serde(default)]
    pub answering: usize,
    #[serde(default = "default_reactions_enabled")]
    pub reactions_enabled: bool,
    #[serde(default)]
    pub content_warning: String,
    #[serde(default)]
    pub tags: Vec<String>,
}

fn default_comments_enabled() -> bool {
    true
}

fn default_reposts_enabled() -> bool {
    true
}

fn default_reactions_enabled() -> bool {
    true
}

impl Default for PostContext {
    fn default() -> Self {
        Self {
            comments_enabled: default_comments_enabled(),
            reposts_enabled: default_reposts_enabled(),
            is_pinned: false,
            is_profile_pinned: false,
            edited: 0,
            is_nsfw: false,
            repost: None,
            answering: 0,
            reactions_enabled: default_reactions_enabled(),
            content_warning: String::new(),
            tags: Vec::new(),
        }
    }
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct RepostContext {
    /// Should be `false` is `reposting` is `Some`.
    ///
    /// Declares the post to be a repost of another post.
    pub is_repost: bool,
    /// Should be `None` if `is_repost` is true.
    ///
    /// Sets the ID of the other post to load.
    pub reposting: Option<usize>,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct Post {
    pub id: usize,
    pub created: usize,
    pub content: String,
    /// The ID of the owner of this post.
    pub owner: usize,
    /// The ID of the [`Community`] this post belongs to.
    pub community: usize,
    /// Extra information about the post.
    pub context: PostContext,
    /// The ID of the post this post is a comment on.
    pub replying_to: Option<usize>,
    pub likes: isize,
    pub dislikes: isize,
    pub comment_count: usize,
    /// IDs of all uploads linked to this post.
    pub uploads: Vec<usize>,
    /// If the post was deleted.
    pub is_deleted: bool,
    /// The ID of the poll associated with this post. 0 means no poll is connected.
    pub poll_id: usize,
    /// The title of the post (in communities where titles are enabled).
    pub title: String,
    /// If the post is "open". Posts can act as tickets in a forge community.
    pub is_open: bool,
}

impl Post {
    /// Create a new [`Post`].
    pub fn new(
        content: String,
        community: usize,
        replying_to: Option<usize>,
        owner: usize,
        poll_id: usize,
    ) -> Self {
        Self {
            id: Snowflake::new().to_string().parse::<usize>().unwrap(),
            created: unix_epoch_timestamp() as usize,
            content,
            owner,
            community,
            context: PostContext::default(),
            replying_to,
            likes: 0,
            dislikes: 0,
            comment_count: 0,
            uploads: Vec::new(),
            is_deleted: false,
            poll_id,
            title: String::new(),
            is_open: true,
        }
    }

    /// Create a new [`Post`] (as a repost of the given `post_id`).
    pub fn repost(content: String, community: usize, owner: usize, post_id: usize) -> Self {
        let mut post = Self::new(content, community, None, owner, 0);

        post.context.repost = Some(RepostContext {
            is_repost: false,
            reposting: Some(post_id),
        });

        post
    }

    /// Make the given post a reposted post.
    pub fn mark_as_repost(&mut self) {
        self.context.repost = Some(RepostContext {
            is_repost: true,
            reposting: None,
        });
    }
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct Question {
    pub id: usize,
    pub created: usize,
    pub owner: usize,
    pub receiver: usize,
    pub content: String,
    /// The `is_global` flag allows any (authenticated) user to respond
    /// to the question. Normally, only the `receiver` can do so.
    ///
    /// If `is_global` is true, `receiver` should be 0 (and vice versa).
    pub is_global: bool,
    /// The number of answers the question has. Should never really be changed
    /// unless the question has `is_global` set to true.
    pub answer_count: usize,
    /// The ID of the community this question is asked to. This should only be > 0
    /// if `is_global` is set to true.
    pub community: usize,
    // likes
    #[serde(default)]
    pub likes: isize,
    #[serde(default)]
    pub dislikes: isize,
    // ...
    #[serde(default)]
    pub context: QuestionContext,
    /// The IP of the question creator for IP blocking and identifying anonymous users.
    #[serde(default)]
    pub ip: String,
}

impl Question {
    /// Create a new [`Question`].
    pub fn new(
        owner: usize,
        receiver: usize,
        content: String,
        is_global: bool,
        ip: String,
    ) -> Self {
        Self {
            id: Snowflake::new().to_string().parse::<usize>().unwrap(),
            created: unix_epoch_timestamp() as usize,
            owner,
            receiver,
            content,
            is_global,
            answer_count: 0,
            community: 0,
            likes: 0,
            dislikes: 0,
            context: QuestionContext::default(),
            ip,
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct QuestionContext {
    #[serde(default)]
    pub is_nsfw: bool,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct PostDraft {
    pub id: usize,
    pub created: usize,
    pub content: String,
    pub owner: usize,
}

impl PostDraft {
    /// Create a new [`PostDraft`].
    pub fn new(content: String, owner: usize) -> Self {
        Self {
            id: Snowflake::new().to_string().parse::<usize>().unwrap(),
            created: unix_epoch_timestamp() as usize,
            content,
            owner,
        }
    }
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct Poll {
    pub id: usize,
    pub owner: usize,
    pub created: usize,
    /// The number of milliseconds until this poll can no longer receive votes.
    pub expires: usize,
    // options
    pub option_a: String,
    pub option_b: String,
    pub option_c: String,
    pub option_d: String,
    // votes
    pub votes_a: usize,
    pub votes_b: usize,
    pub votes_c: usize,
    pub votes_d: usize,
}

impl Poll {
    /// Create a new [`Poll`].
    pub fn new(
        owner: usize,
        expires: usize,
        option_a: String,
        option_b: String,
        option_c: String,
        option_d: String,
    ) -> Self {
        Self {
            id: Snowflake::new().to_string().parse::<usize>().unwrap(),
            owner,
            created: unix_epoch_timestamp() as usize,
            expires,
            // options
            option_a,
            option_b,
            option_c,
            option_d,
            // votes
            votes_a: 0,
            votes_b: 0,
            votes_c: 0,
            votes_d: 0,
        }
    }
}

/// Poll option (selectors) are stored in the database as numbers 0 to 3.
///
/// This enum allows us to convert from these numbers into letters.
#[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
pub enum PollOption {
    A,
    B,
    C,
    D,
}

impl From<u8> for PollOption {
    fn from(value: u8) -> Self {
        match value {
            0 => Self::A,
            1 => Self::B,
            2 => Self::C,
            3 => Self::D,
            _ => Self::A,
        }
    }
}

impl Into<u8> for PollOption {
    fn into(self) -> u8 {
        match self {
            Self::A => 0,
            Self::B => 1,
            Self::C => 2,
            Self::D => 3,
        }
    }
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct PollVote {
    pub id: usize,
    pub owner: usize,
    pub created: usize,
    pub poll_id: usize,
    pub vote: PollOption,
}

impl PollVote {
    /// Create a new [`PollVote`].
    pub fn new(owner: usize, poll_id: usize, vote: PollOption) -> Self {
        Self {
            id: Snowflake::new().to_string().parse::<usize>().unwrap(),
            owner,
            created: unix_epoch_timestamp() as usize,
            poll_id,
            vote,
        }
    }
}