capitol 0.6.3

use crate::constants::{CDG_BASE_URL, GOVINFO_BASE_URL};
use crate::error::Error;
use crate::legislation::{Chamber, CommitteeDocumentType, Congress, MeasureType};
use crate::parser;
use crate::utils::{DisplayOption, Result};
use std::fmt::Display;
use std::str::FromStr;

/// Represents a Citation for a legislative document.
///
/// A `Citation` can represent a `Measure` (bill or resolution), an `Amendment`, a (public) `Law`, a `Statute`,
/// or a `CommitteeDocument` (congressional report or committee print).
#[derive(Clone, Debug, PartialEq)]
pub enum Citation {
    /// A `Measure` represents a bill or resolution.
    Measure {
        /// The Congress in which the measure was introduced.
        congress: Option<Congress>,
        /// The Congressional chamber of introduction.
        chamber: Chamber,
        /// The type of the Measure; `Bill`, `Resolution`, `ConcurrentResolution`, or `JointResolution`
        measure_type: MeasureType,
        /// The bill number
        number: usize,
        /// An optional suffix representing the text version of the measure.
        version: Option<String>,
    },
    /// An `Amendment` represents a change to a `Measure`.
    Amendment {
        /// The Congress in which the amendment was introduced.
        congress: Option<Congress>,
        /// The Congressional chamber of introduction.
        chamber: Chamber,
        /// The amendment number
        number: usize,
    },
    /// A `Law` represents public slip laws.
    Law {
        /// The Congress in which the measure was introduced.
        congress: Option<Congress>,
        /// The law number.
        number: usize,
    },
    /// A `Statute` represents a federal statute at large.
    Statute {
        /// The statute volume number.
        volume: usize,
        /// The statute page number.
        page: usize,
    },
    /// A `CommitteeDocument` represents a committee publication.
    CommitteeDocument {
        /// The Congress during which the document was published.
        congress: Option<Congress>,
        /// The chamber of the committee.
        chamber: Chamber,
        /// A congressional report or committee print.
        document_type: CommitteeDocumentType,
        /// The number of the document.
        number: usize,
    },
}

impl Display for Citation {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self {
            Self::Measure {
                chamber,
                congress,
                measure_type,
                number,
                version,
            } => {
                let mut measure = measure_type.to_string();
                if (chamber, measure_type) == (&Chamber::House, &MeasureType::Bill) {
                    measure.push('r');
                }
                write!(
                    f,
                    "{}{chamber}{measure}{number}{}",
                    DisplayOption(*congress),
                    DisplayOption(version.to_owned())
                )
            }
            Self::Amendment {
                congress,
                chamber,
                number,
            } => write!(f, "{}{chamber}amdt{number}", DisplayOption(*congress)),
            Self::Law { congress, number } => {
                write!(f, "{}pl{number}", DisplayOption(*congress))
            }
            Self::Statute { volume, page } => write!(f, "{volume}stat{page}"),
            Self::CommitteeDocument {
                congress,
                chamber,
                document_type,
                number,
            } => {
                write!(
                    f,
                    "{}{chamber}{document_type}{number}",
                    DisplayOption(*congress)
                )
            }
        }
    }
}

impl Citation {
    /// Parse a legislative citation.
    ///
    /// The method first breaks up the citation into its constituent parts, then parses each of the
    /// parts, validating that the given Congress does not exceed the current Congress.
    ///
    /// Example
    ///
    /// ```rust
    /// use capitol::Citation;
    ///
    /// let citation = Citation::parse("118hr815");
    /// ```
    ///
    /// # Errors
    ///
    /// Will result in an error if the legislative document type is unrecognized or if an integer can't be
    /// parsed from the document number.
    pub fn parse(input: &str) -> Result<Self> {
        Ok(parser::parse(input)?)
    }

    /// Render a URL for the document represented by the citation.
    /// Measures, committee documents, and laws go to Congress.gov.
    /// Statutes go to Govinfo.
    ///
    /// Example
    ///
    /// ```rust
    /// use capitol::Citation;
    ///
    /// let citation = Citation::parse("118hr815").unwrap();
    /// let url = citation.to_url();
    /// assert_eq!("https://www.congress.gov/bill/118/hr/815", url.unwrap());
    /// ```
    #[must_use]
    pub fn to_url(&self) -> Option<String> {
        match self {
            Self::Measure {
                congress,
                chamber,
                measure_type,
                number,
                version,
            } => {
                if let Some(congress) = congress {
                    let mut measure_string = measure_type.to_string();
                    if (chamber, measure_type) == (&Chamber::House, &MeasureType::Bill) {
                        measure_string.push('r');
                    }
                    let mut url = format!(
                        "{CDG_BASE_URL}/bill/{congress}/{chamber}{measure_string}/{number}"
                    );

                    if let Some(ver) = version {
                        url.push_str("/text/");
                        url.push_str(ver);
                    }
                    Some(url)
                } else {
                    None
                }
            }
            Self::Amendment {
                congress,
                chamber,
                number,
            } => congress.as_ref().map(|congress| {
                format!("{CDG_BASE_URL}/amendment/{congress}/{chamber}amdt/{number}")
            }),
            Self::CommitteeDocument {
                congress,
                chamber,
                document_type,
                number,
            } => {
                if let Some(congress) = congress {
                    let collection = match document_type {
                        CommitteeDocumentType::Report => "congressional-report",
                        CommitteeDocumentType::Print => "committee-print",
                    };
                    let url = format!(
                        "{CDG_BASE_URL}/{collection}/{congress}/{chamber}{document_type}/{number}"
                    );
                    Some(url)
                } else {
                    None
                }
            }
            Self::Statute { volume, page } => Some(format!(
                "{GOVINFO_BASE_URL}/app/details/STATUTE-{volume}/STATUTE-{volume}-Pg{page}"
            )),
            Self::Law { congress, number } => {
                if let Some(Congress(congress)) = congress {
                    Some(format!(
                        "{CDG_BASE_URL}/{congress}/plaws/publ{number}/PLAW-{congress}publ{number}.pdf"
                    ))
                } else {
                    None
                }
            }
        }
    }

    /// Returns the version of the document if it is a measure, None, otherwise.
    ///
    /// Example
    ///
    /// ```rust
    /// use capitol::Citation;
    ///
    /// let citation = Citation::parse("118hr815ih").unwrap();
    /// let version = citation.version();
    /// assert_eq!(Some("ih"), version.as_deref());
    /// ```
    #[must_use]
    pub fn version(&self) -> Option<String> {
        match self {
            Self::Measure { version, .. } => version.as_ref().map(String::from),
            _ => None,
        }
    }

    /// Returns the congress of the document if it has one, None, otherwise.
    ///
    /// Example
    ///
    /// ```rust
    /// use capitol::Citation;
    ///
    /// let citation = Citation::parse("118hr815ih").unwrap();
    /// let congress = citation.congress();
    /// assert_eq!(Some(118), congress);
    /// ```
    #[must_use]
    pub fn congress(&self) -> Option<usize> {
        match self {
            Self::Statute { .. } => None,
            Self::Measure { congress, .. }
            | Self::Amendment { congress, .. }
            | Self::Law { congress, .. }
            | Self::CommitteeDocument { congress, .. } => congress.map(|c| c.0),
        }
    }

    /// Returns the chamber of the document if it has one, None, otherwise.
    ///
    /// Example
    ///
    /// ```rust
    /// use capitol::Citation;
    ///
    /// let citation = Citation::parse("118hr815ih").unwrap();
    /// let chamber = citation.chamber();
    /// assert_eq!(Some("H"), chamber.as_deref());
    /// ```
    #[must_use]
    pub fn chamber(&self) -> Option<String> {
        match self {
            Self::Measure { chamber, .. } | Self::CommitteeDocument { chamber, .. } => {
                Some(chamber.to_string().to_uppercase())
            }
            _ => None,
        }
    }

    /// Returns the number of the document if it has one, None, otherwise.
    ///
    /// Example
    ///
    /// ```rust
    /// use capitol::Citation;
    ///
    /// let citation = Citation::parse("118hr815ih").unwrap();
    /// let number = citation.number();
    /// assert_eq!(815, number);
    /// ```
    #[must_use]
    pub fn number(&self) -> usize {
        match *self {
            Self::Statute { page, .. } => page,
            Self::Measure { number, .. }
            | Self::Amendment { number, .. }
            | Self::Law { number, .. }
            | Self::CommitteeDocument { number, .. } => number,
        }
    }

    /// Returns the volume number of the document if it is a Statute, otherwise, None.
    ///
    /// Example
    ///
    /// ```rust
    /// use capitol::Citation;
    ///
    /// let citation = Citation::parse("130stat2103").unwrap();
    /// let volume = citation.volume();
    /// assert_eq!(Some(130), volume);
    /// ```
    #[must_use]
    pub fn volume(&self) -> Option<usize> {
        if let Self::Statute { volume, .. } = *self {
            Some(volume)
        } else {
            None
        }
    }

    /// Returns the page number of the document if it is a Statute, otherwise, None.
    ///
    /// Example
    ///
    /// ```rust
    /// use capitol::Citation;
    ///
    /// let citation = Citation::parse("130stat2103").unwrap();
    /// let page = citation.page();
    /// assert_eq!(Some(2103), page);
    /// ```
    #[must_use]
    pub fn page(&self) -> Option<usize> {
        if let Self::Statute { page, .. } = *self {
            Some(page)
        } else {
            None
        }
    }

    /// Returns the citation's document type as a string.
    ///
    /// Example
    ///
    /// ```rust
    /// use capitol::Citation;
    ///
    /// let citation = Citation::parse("118hr815ih").unwrap();
    /// let document_type = citation.document_type();
    /// assert_eq!("hr", document_type);
    /// ```
    #[must_use]
    pub fn document_type(&self) -> String {
        match self {
            Self::Statute { .. } => String::from("stat"),
            Self::Amendment { .. } => String::from("amdt"),
            Self::Measure {
                chamber,
                measure_type,
                ..
            } => {
                let mut measure_string = measure_type.to_string();
                if measure_string.is_empty() {
                    measure_string.push_str(&chamber.to_string());
                    if (chamber, measure_type) == (&Chamber::House, &MeasureType::Bill) {
                        measure_string.push('r');
                    }
                }
                measure_string
            }
            Self::Law { .. } => String::from("publ"),
            Self::CommitteeDocument { document_type, .. } => document_type.to_string(),
        }
    }

    /// Returns a citation without it's version tag if a `Measure`.
    ///
    /// Example
    ///
    /// ```rust
    /// use capitol::Citation;
    ///
    /// let citation = Citation::parse("118hr815ih").unwrap();
    /// let result = citation.without_version().to_string();
    /// assert_eq!("118hr815", result);
    /// ```
    #[must_use]
    pub fn without_version(&self) -> Self {
        match self {
            Self::Measure {
                congress,
                chamber,
                measure_type,
                number,
                ..
            } => Self::Measure {
                congress: *congress,
                chamber: chamber.clone(),
                measure_type: measure_type.clone(),
                number: *number,
                version: None,
            },
            _ => self.clone(),
        }
    }

    /// Returns a citation without it's version tag if a `Law`.
    ///
    /// Example
    ///
    /// ```rust
    /// use capitol::Citation;
    ///
    /// let citation = Citation::parse("Public Law No: 119-68").unwrap();
    /// let result = citation.without_congress().to_string();
    /// assert_eq!("pl68", result);
    /// ```
    #[must_use]
    pub fn without_congress(&self) -> Self {
        match self {
            Self::Law { number, .. } => Self::Law {
                congress: None,
                number: *number,
            },
            _ => self.clone(),
        }
    }

    /// Returns true if the citation is for a `Measure`.
    ///
    /// Example
    ///
    /// ```rust
    /// use capitol::Citation;
    ///
    /// let citation = Citation::parse("118hr815ih").unwrap();
    /// assert!(citation.is_measure());
    /// ```
    #[must_use]
    pub fn is_measure(&self) -> bool {
        matches!(self, Self::Measure { .. })
    }

    /// Returns true if the citation is for a `Law`.
    ///
    /// Example
    ///
    /// ```rust
    /// use capitol::Citation;
    ///
    /// let citation = Citation::parse("Public Law No: 119-68").unwrap();
    /// assert!(citation.is_law());
    /// ```
    #[must_use]
    pub fn is_law(&self) -> bool {
        matches!(self, Self::Law { .. })
    }

    /// Returns true if the citation is for a `Statute`.
    ///
    /// Example
    ///
    /// ```rust
    /// use capitol::Citation;
    ///
    /// let citation = Citation::parse("86 Stat. 2343").unwrap();
    /// assert!(citation.is_statute());
    /// ```
    #[must_use]
    pub fn is_statute(&self) -> bool {
        matches!(self, Self::Statute { .. })
    }

    /// Returns true if the citation is for a `CommitteeDocument`.
    ///
    /// Example
    ///
    /// ```rust
    /// use capitol::Citation;
    ///
    /// let citation = Citation::parse("119hprt58246").unwrap();
    /// assert!(citation.is_committee_document());
    /// ```
    #[must_use]
    pub fn is_committee_document(&self) -> bool {
        matches!(self, Self::CommitteeDocument { .. })
    }
}

impl FromStr for Citation {
    type Err = Error;
    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        Self::parse(s)
    }
}

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

    #[test]
    fn test_parse_no_ver_house_bill() {
        let input = "118hr8070";
        let expected = Citation::Measure {
            congress: Some(Congress(118)),
            chamber: Chamber::House,
            measure_type: MeasureType::Bill,
            number: 8070,
            version: None,
        };
        let result = input.parse();
        assert_eq!(expected, result.unwrap());
    }

    #[test]
    fn test_parse_house_report() {
        let input = "118hrpt529";
        let expected = Citation::CommitteeDocument {
            congress: Some(Congress(118)),
            chamber: Chamber::House,
            document_type: CommitteeDocumentType::Report,
            number: 529,
        };
        let result = input.parse();
        assert_eq!(expected, result.unwrap());
    }

    #[test]
    fn test_parse_house_print() {
        let input = "119HPRT58246";
        let expected = Citation::CommitteeDocument {
            congress: Some(Congress(119)),
            chamber: Chamber::House,
            document_type: CommitteeDocumentType::Print,
            number: 58246,
        };
        let result = input.parse();
        assert_eq!(expected, result.unwrap());
    }

    #[test]
    fn test_parse_senate_print() {
        let input = "119sprt57246";
        let expected = Citation::CommitteeDocument {
            congress: Some(Congress(119)),
            chamber: Chamber::Senate,
            document_type: CommitteeDocumentType::Print,
            number: 57246,
        };
        let result = input.parse();
        assert_eq!(expected, result.unwrap());
    }

    #[test]
    fn test_parse_senate_report() {
        let input = "118srpt17";
        let expected = Citation::CommitteeDocument {
            congress: Some(Congress(118)),
            chamber: Chamber::Senate,
            document_type: CommitteeDocumentType::Report,
            number: 17,
        };
        let result = input.parse();
        assert_eq!(expected, result.unwrap());
    }

    #[test]
    fn test_house_bill_to_url() {
        let input = "118hr529";
        let expected = Some("https://www.congress.gov/bill/118/hr/529".to_string());
        let citation = input.parse::<Citation>().unwrap();
        let result = citation.to_url();
        assert_eq!(expected, result);
    }

    #[test]
    fn test_house_resolution_to_url() {
        let input = "118hres529";
        let expected = Some("https://www.congress.gov/bill/118/hres/529".to_string());
        let citation = input.parse::<Citation>().unwrap();
        let result = citation.to_url();
        assert_eq!(expected, result);
    }

    #[test]
    fn test_house_bill_with_ver_to_url() {
        let input = "118hr529ih";
        let expected = Some("https://www.congress.gov/bill/118/hr/529/text/ih".to_string());
        let citation = input.parse::<Citation>().unwrap();
        let result = citation.to_url();
        assert_eq!(expected, result);
    }

    #[test]
    fn test_house_report_to_url() {
        let input = "118hrpt529";
        let expected =
            Some("https://www.congress.gov/congressional-report/118/hrpt/529".to_string());
        let citation = input.parse::<Citation>().unwrap();
        let result = citation.to_url();
        assert_eq!(expected, result);
    }

    #[test]
    fn test_house_print_to_url() {
        let input = "119hprt58246";
        let expected = Some("https://www.congress.gov/committee-print/119/hprt/58246".to_string());
        let citation = input.parse::<Citation>().unwrap();
        let result = citation.to_url();
        assert_eq!(expected, result);
    }

    #[test]
    fn test_senate_print_to_url() {
        let input = "119sprt57246";
        let expected = Some("https://www.congress.gov/committee-print/119/sprt/57246".to_string());
        let citation = input.parse::<Citation>().unwrap();
        let result = citation.to_url();
        assert_eq!(expected, result);
    }

    #[test]
    fn test_get_version() {
        let input = "118hr529ih";
        let expected = Some("ih");
        let citation = input.parse::<Citation>().unwrap();
        let result = citation.version();
        assert_eq!(expected, result.as_deref());
    }

    #[test]
    fn test_no_congress_to_url_returns_none() {
        let input = "hr529";
        let expected = None;
        let citation = input.parse::<Citation>().unwrap();
        let result = citation.to_url();
        assert_eq!(expected, result);
    }

    #[test]
    fn test_uppercase_input() {
        let input = "118HR529IH";
        let expected = Some("https://www.congress.gov/bill/118/hr/529/text/ih".to_string());
        let citation = input.parse::<Citation>().unwrap();
        let result = citation.to_url();
        assert_eq!(expected, result);
    }

    #[test]
    fn test_parse_house_bill_with_dots() {
        let input = "118h.r.529";
        let expected = Citation::Measure {
            congress: Some(Congress(118)),
            chamber: Chamber::House,
            measure_type: MeasureType::Bill,
            number: 529,
            version: None,
        };
        let result = input.parse();
        assert_eq!(expected, result.unwrap());
    }

    #[test]
    fn test_parse_house_bill_with_version_no_congress() {
        let input = "hr529ih";
        let expected = Citation::Measure {
            congress: None,
            chamber: Chamber::House,
            measure_type: MeasureType::Bill,
            number: 529,
            version: Some("ih".to_string()),
        };
        let result = input.parse();
        assert_eq!(expected, result.unwrap());
    }

    #[test]
    fn test_print_citation_without_version() {
        let input = "118hr529ih";
        let citation: Citation = input.parse().unwrap();
        let expected = "118hr529";
        let result = citation.without_version().to_string();
        assert_eq!(expected, result);
    }

    #[test]
    fn test_print_no_congress_citation_without_version() {
        let input = "H.R.529.IH";
        let citation: Citation = input.parse().unwrap();
        let expected = "hr529".to_string();
        let result = citation.without_version().to_string();
        assert_eq!(expected, result);
    }

    #[test]
    fn test_public_law_to_string() {
        let input = "Public Law No: 119-68";
        let citation: Citation = input.parse().unwrap();
        let expected = "119pl68";
        let result = citation.to_string();
        assert_eq!(expected, result);
    }

    #[test]
    fn test_parse_public_law() {
        let input = "Public Law No: 119-68";
        let result: Citation = input.parse().unwrap();
        let expected = Citation::Law {
            congress: Some(Congress(119)),
            number: 68,
        };
        assert_eq!(expected, result);
    }

    #[test]
    fn test_statute_to_string() {
        let input = "86Stat1326";
        let citation: Citation = input.parse().unwrap();
        let expected = "86stat1326";
        let result = citation.to_string();
        assert_eq!(expected, result);
    }

    #[test]
    fn test_house_report_to_string() {
        let input = "119.H.Rpt.23";
        let citation: Citation = input.parse().unwrap();
        let expected = "119hrpt23";
        let result = citation.to_string();
        assert_eq!(expected, result);
    }

    #[test]
    fn test_normalize_senate_print() {
        let input = "119.S.Prt.23";
        let citation: Citation = input.parse().unwrap();
        let expected = "119sprt23";
        let result = citation.to_string();
        assert_eq!(expected, result);
    }

    #[test]
    fn test_statute_to_url() {
        let input = "135stat2454";
        let citation: Citation = input.parse().unwrap();
        let expected =
            Some("https://www.govinfo.gov/app/details/STATUTE-135/STATUTE-135-Pg2454".to_string());
        let result = citation.to_url();
        assert_eq!(expected, result);
    }

    #[test]
    fn test_law_to_url() {
        let input = "119pl68";
        let citation: Citation = input.parse().unwrap();
        let expected =
            Some("https://www.congress.gov/119/plaws/publ68/PLAW-119publ68.pdf".to_string());
        let result = citation.to_url();
        assert_eq!(expected, result);
        let input = "119publ68";
        let citation: Citation = input.parse().unwrap();
        let result = citation.to_url();
        assert_eq!(expected, result);
    }

    #[test]
    fn test_citations_with_spaces() {
        let input = "135 Stat. 2454";
        let citation: Citation = input.parse().unwrap();
        let expected = "135stat2454";
        let result = citation.to_string();
        assert_eq!(expected, result);
    }

    #[test]
    fn test_parse_amendment() {
        let input = "118samdt23";
        let expected = Citation::Amendment {
            congress: Some(Congress(118)),
            chamber: Chamber::Senate,
            number: 23,
        };
        let result = Citation::parse(input).unwrap();
        assert_eq!(expected, result);
    }

    #[test]
    fn test_amendment_to_url() {
        let input = "119 H.Amdt.2";
        let expected = "https://www.congress.gov/amendment/119/hamdt/2";
        let result = Citation::parse(input).unwrap().to_url().unwrap();
        assert_eq!(expected, result);
    }

    #[test]
    fn join_print_to_url() {
        let input = "118JPRT55649";
        let expected = "https://www.congress.gov/committee-print/118/jprt/55649";
        let result = Citation::parse(input).unwrap().to_url().unwrap();
        assert_eq!(expected, result);
    }
}