//! Issue, comment, label and milestone types, and their validation. Stored shapes are in
//! migrations/0004_issues.sql; the store functions live in store/issues.rs and store/labels.rs.

use crate::error::{Error, Result};
use crate::model::Id;

/// Longest accepted issue title, in characters.
pub const MAX_TITLE: usize = 256;
/// Largest accepted issue, comment or edit body, in bytes.
pub const MAX_BODY: usize = 65536;
/// Longest accepted label name, in characters.
pub const MAX_LABEL_NAME: usize = 50;
/// Most assignees one issue can have.
pub const MAX_ASSIGNEES: usize = 10;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum IssueState {
    Open,
    Closed,
}

impl IssueState {
    pub fn as_str(&self) -> &'static str {
        match self {
            IssueState::Open => "open",
            IssueState::Closed => "closed",
        }
    }
}

impl std::str::FromStr for IssueState {
    type Err = Error;

    fn from_str(s: &str) -> Result<Self> {
        match s {
            "open" => Ok(IssueState::Open),
            "closed" => Ok(IssueState::Closed),
            other => Err(Error::Invalid(format!("issue state {other:?}"))),
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum StateReason {
    Completed,
    NotPlanned,
}

impl StateReason {
    pub fn as_str(&self) -> &'static str {
        match self {
            StateReason::Completed => "completed",
            StateReason::NotPlanned => "not_planned",
        }
    }
}

impl std::str::FromStr for StateReason {
    type Err = Error;

    fn from_str(s: &str) -> Result<Self> {
        match s {
            "completed" => Ok(StateReason::Completed),
            "not_planned" => Ok(StateReason::NotPlanned),
            other => Err(Error::Invalid(format!("state reason {other:?}"))),
        }
    }
}

#[derive(Debug, Clone, PartialEq)]
pub struct Issue {
    pub id: Id,
    pub repo_id: Id,
    pub number: i64,
    pub title: String,
    pub body: String,
    pub state: IssueState,
    pub state_reason: Option<StateReason>,
    pub author_id: Id,
    pub milestone_id: Option<Id>,
    pub comment_count: i64,
    pub created_at: String,
    pub updated_at: String,
    pub closed_at: Option<String>,
    /// Locked conversations accept writes only from collaborators with Triage or higher.
    pub locked: bool,
    /// One of `LOCK_REASONS`, or `None` when no reason was given.
    pub lock_reason: Option<String>,
}

/// Reasons accepted when locking a conversation.
pub const LOCK_REASONS: &[&str] = &["off_topic", "too_heated", "resolved", "spam"];

#[derive(Debug, Clone, PartialEq)]
pub struct Comment {
    pub id: Id,
    pub issue_id: Id,
    pub author_id: Id,
    pub body: String,
    pub created_at: String,
    pub updated_at: String,
    pub edited: bool,
}

#[derive(Debug, Clone, PartialEq)]
pub struct IssueEvent {
    pub id: Id,
    pub issue_id: Id,
    /// `None` for system events.
    pub actor_id: Option<Id>,
    pub kind: String,
    pub data: serde_json::Value,
    pub created_at: String,
}

#[derive(Debug, Clone, PartialEq)]
pub struct Label {
    pub id: Id,
    pub repo_id: Id,
    pub name: String,
    /// Lowercase `#rrggbb`.
    pub color: String,
    pub description: String,
}

#[derive(Debug, Clone, PartialEq)]
pub struct Milestone {
    pub id: Id,
    pub repo_id: Id,
    pub title: String,
    pub description: String,
    /// `YYYY-MM-DD` or `None`.
    pub due_on: Option<String>,
    pub state: IssueState,
    pub created_at: String,
    pub closed_at: Option<String>,
    /// Counts filled by list/get queries.
    pub open_issues: i64,
    pub closed_issues: i64,
}

#[derive(Debug, Clone, PartialEq)]
pub struct IssueFilter {
    pub state: Option<IssueState>,
    /// Label name.
    pub label: Option<String>,
    /// Milestone title.
    pub milestone: Option<String>,
    /// Author username.
    pub author: Option<String>,
    /// Assignee username.
    pub assignee: Option<String>,
    /// Substring of the title, case-insensitive.
    pub query: Option<String>,
    pub sort: IssueSort,
    /// 1-based.
    pub page: u32,
    pub per_page: u32,
}

impl Default for IssueFilter {
    fn default() -> Self {
        IssueFilter {
            state: Some(IssueState::Open),
            label: None,
            milestone: None,
            author: None,
            assignee: None,
            query: None,
            sort: IssueSort::Newest,
            page: 1,
            per_page: 25,
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum IssueSort {
    #[default]
    Newest,
    Oldest,
    RecentlyUpdated,
}

impl IssueSort {
    /// The value used in the `sort` query parameter.
    pub fn as_str(&self) -> &'static str {
        match self {
            IssueSort::Newest => "newest",
            IssueSort::Oldest => "oldest",
            IssueSort::RecentlyUpdated => "updated",
        }
    }
}

impl std::str::FromStr for IssueSort {
    type Err = Error;

    fn from_str(s: &str) -> Result<Self> {
        match s {
            "newest" => Ok(IssueSort::Newest),
            "oldest" => Ok(IssueSort::Oldest),
            "updated" => Ok(IssueSort::RecentlyUpdated),
            other => Err(Error::Invalid(format!("sort {other:?}"))),
        }
    }
}

#[derive(Debug, Clone, PartialEq)]
pub struct IssueListItem {
    pub issue: Issue,
    /// Display username of the author.
    pub author: String,
    pub labels: Vec<Label>,
    /// Display usernames of the assignees.
    pub assignees: Vec<String>,
}

/// Trimmed title: non-empty, at most `MAX_TITLE` characters, no control characters.
pub fn validate_title(t: &str) -> Result<String> {
    let title = t.trim();
    if title.is_empty() {
        return Err(Error::Invalid("title is empty".into()));
    }
    if title.chars().count() > MAX_TITLE {
        return Err(Error::Invalid(format!(
            "title is longer than {MAX_TITLE} characters"
        )));
    }
    if title.chars().any(char::is_control) {
        return Err(Error::Invalid("title contains control characters".into()));
    }
    Ok(title.to_string())
}

/// Body: at most `MAX_BODY` bytes. An empty body is allowed.
pub fn validate_body(b: &str) -> Result<()> {
    if b.len() > MAX_BODY {
        return Err(Error::Invalid(format!(
            "body is longer than {MAX_BODY} bytes"
        )));
    }
    Ok(())
}

/// Returns `(trimmed name, normalized color)`. The name is 1..=50 characters with no control
/// characters. The color is `#rgb` or `#rrggbb` in any case and comes back as lowercase `#rrggbb`.
pub fn validate_label(name: &str, color: &str) -> Result<(String, String)> {
    let name = name.trim();
    let len = name.chars().count();
    if len == 0 || len > MAX_LABEL_NAME {
        return Err(Error::Invalid(format!(
            "label name must be 1 to {MAX_LABEL_NAME} characters"
        )));
    }
    if name.chars().any(char::is_control) {
        return Err(Error::Invalid(
            "label name contains control characters".into(),
        ));
    }
    let color = normalize_color(color)
        .ok_or_else(|| Error::Invalid(format!("label color {color:?} is not #rgb or #rrggbb")))?;
    Ok((name.to_string(), color))
}

fn normalize_color(color: &str) -> Option<String> {
    let hex = color.strip_prefix('#')?;
    if !hex.chars().all(|c| c.is_ascii_hexdigit()) {
        return None;
    }
    let lower = hex.to_ascii_lowercase();
    match lower.len() {
        3 => {
            let mut out = String::with_capacity(7);
            out.push('#');
            for c in lower.chars() {
                out.push(c);
                out.push(c);
            }
            Some(out)
        }
        6 => Some(format!("#{lower}")),
        _ => None,
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn title_is_trimmed_and_checked() {
        assert_eq!(validate_title("  Fix it  ").unwrap(), "Fix it");
        assert!(validate_title("   ").is_err());
        assert!(validate_title("").is_err());
        assert!(validate_title("a\tb").is_err());
        assert!(validate_title("a\nb").is_err());
        assert!(validate_title(&"x".repeat(MAX_TITLE)).is_ok());
        assert!(validate_title(&"x".repeat(MAX_TITLE + 1)).is_err());
        // Counted in characters, not bytes.
        assert!(validate_title(&"é".repeat(MAX_TITLE)).is_ok());
        assert!(validate_title(&"é".repeat(MAX_TITLE + 1)).is_err());
    }

    #[test]
    fn body_is_checked_in_bytes() {
        assert!(validate_body("").is_ok());
        assert!(validate_body(&"x".repeat(MAX_BODY)).is_ok());
        assert!(validate_body(&"x".repeat(MAX_BODY + 1)).is_err());
        // 2 bytes per char: 32768 chars is exactly MAX_BODY bytes.
        assert!(validate_body(&"é".repeat(MAX_BODY / 2)).is_ok());
        assert!(validate_body(&"é".repeat(MAX_BODY / 2 + 1)).is_err());
    }

    #[test]
    fn label_name_and_color_are_normalized() {
        assert_eq!(
            validate_label("  bug ", "#FF0000").unwrap(),
            ("bug".to_string(), "#ff0000".to_string())
        );
        assert_eq!(
            validate_label("x", "#AbC").unwrap(),
            ("x".to_string(), "#aabbcc".to_string())
        );
        assert!(validate_label("", "#fff").is_err());
        assert!(validate_label("   ", "#fff").is_err());
        assert!(validate_label(&"a".repeat(MAX_LABEL_NAME), "#fff").is_ok());
        assert!(validate_label(&"a".repeat(MAX_LABEL_NAME + 1), "#fff").is_err());
        assert!(validate_label("a\u{7}", "#fff").is_err());
    }

    #[test]
    fn label_color_must_be_hex() {
        for bad in [
            "", "fff", "#ff", "#ffff", "#fffffff", "#gggggg", "red", "# fff", "#ff00 0",
        ] {
            assert!(validate_label("x", bad).is_err(), "{bad:?} accepted");
        }
    }

    #[test]
    fn enums_round_trip() {
        for s in [IssueState::Open, IssueState::Closed] {
            assert_eq!(s.as_str().parse::<IssueState>().ok(), Some(s));
        }
        assert!("Open".parse::<IssueState>().is_err());
        for r in [StateReason::Completed, StateReason::NotPlanned] {
            assert_eq!(r.as_str().parse::<StateReason>().ok(), Some(r));
        }
        assert!("duplicate".parse::<StateReason>().is_err());
        for s in [
            IssueSort::Newest,
            IssueSort::Oldest,
            IssueSort::RecentlyUpdated,
        ] {
            assert_eq!(s.as_str().parse::<IssueSort>().ok(), Some(s));
        }
        assert!("bogus".parse::<IssueSort>().is_err());
    }

    #[test]
    fn default_filter_is_open_first_page() {
        let f = IssueFilter::default();
        assert_eq!(f.state, Some(IssueState::Open));
        assert_eq!(f.page, 1);
        assert_eq!(f.per_page, 25);
        assert_eq!(f.sort, IssueSort::Newest);
    }
}