use crate::status::Status;

// We've seen how to declare modules in one of the earliest exercises, but
// we haven't seen how to extract them into separate files.
// Let's fix that now!
//
// In the simplest case, when the extracted module is a single file, it is enough to
// create a new file with the same name as the module and move the module content there.
// The module file should be placed in the same directory as the file that declares the module.
// In this case, `src/lib.rs`, thus `status.rs` should be placed in the `src` directory.
mod status;

// TODO: Add a new error variant to `TicketNewError` for when the status string is invalid.
// When calling `source` on an error of that variant, it should return a `ParseStatusError` rather than `None`.

#[derive(Debug, thiserror::Error)]
pub enum TicketNewError {
 #[error("Title cannot be empty")]
 TitleCannotBeEmpty,
 #[error("Title cannot be longer than 50 bytes")]
 TitleTooLong,
 #[error("Description cannot be empty")]
 DescriptionCannotBeEmpty,
 #[error("Description cannot be longer than 500 bytes")]
 DescriptionTooLong,
}

#[derive(Debug, PartialEq, Clone)]
pub struct Ticket {
 title: String,
 description: String,
 status: Status,
}

impl Ticket {
 pub fn new(title: String, description: String, status: String) -> Result<Self, TicketNewError> {
 if title.is_empty() {
 return Err(TicketNewError::TitleCannotBeEmpty);
 }
 if title.len() > 50 {
 return Err(TicketNewError::TitleTooLong);
 }
 if description.is_empty() {
 return Err(TicketNewError::DescriptionCannotBeEmpty);
 }
 if description.len() > 500 {
 return Err(TicketNewError::DescriptionTooLong);
 }

 // TODO: Parse the status string into a `Status` enum.

 Ok(Ticket {
 title,
 description,
 status,
 })
 }
}

#[cfg(test)]
mod tests {
 use common::{valid_description, valid_title};
 use std::error::Error;

 use super::*;

 #[test]
 fn invalid_status() {
 let err = Ticket::new(valid_title(), valid_description(), "invalid".into()).unwrap_err();
 assert_eq!(
 err.to_string(),
 "`invalid` is not a valid status. Use one of: ToDo, InProgress, Done"
 );
 assert!(err.source().is_some());
 }
}

// ...省略...

#[derive(Debug, thiserror::Error)]
pub enum TicketNewError {
 #[error("Title cannot be empty")]
 TitleCannotBeEmpty,
 #[error("Title cannot be longer than 50 bytes")]
 TitleTooLong,
 #[error("Description cannot be empty")]
 DescriptionCannotBeEmpty,
 #[error("Description cannot be longer than 500 bytes")]
 DescriptionTooLong,
+  #[error("{0}")]
+  InvalidStatusString(#[from] status::ParseStatusError),
}

// ...省略...

impl Ticket {
 pub fn new(title: String, description: String, status: String) -> Result<Self, TicketNewError> {
 // ...省略...

 // TODO: Parse the status string into a `Status` enum.
+  let status = status.try_into()?;

 Ok(Ticket {
 title,
 description,
 status,
 })
 }
}

// ...省略...

match status.try_into() {
 Ok(s) => s,
 Err(e) => return Err(TicketNewError::from(e)),
}

// TODO: you have something to do in each of the modules in this crate!
mod description;
mod status;
mod title;

// A common pattern in Rust is to split code into multiple (private) modules
// and then re-export the public parts of those modules at the root of the crate.
//
// This hides the internal structure of the crate from your users, while still
// allowing you to organize your code however you like.
pub use description::TicketDescription;
pub use status::Status;
pub use title::TicketTitle;

#[derive(Debug, PartialEq, Clone)]
// We no longer need to make the fields private!
// Since each field encapsulates its own validation logic, there is no risk of
// a user of `Ticket` modifying the fields in a way that would break the
// invariants of the struct.
//
// Careful though: if you had any invariants that spanned multiple fields, you
// would need to ensure that those invariants are still maintained and go back
// to making the fields private.
pub struct Ticket {
 pub title: TicketTitle,
 pub description: TicketDescription,
 pub status: Status,
}

cargo add thiserror

#[derive(Debug, PartialEq, Clone)]
pub struct TicketDescription(String);

#[derive(thiserror::Error, Debug)]
pub enum InvalidDescriptionError {
 #[error("The description cannot be empty")]
 Empty,
 #[error("The description cannot be longer than 500 bytes")]
 TooLong,
}

use InvalidDescriptionError::*;

fn str2description(value: &str) -> Result<TicketDescription, InvalidDescriptionError> {
 if value.is_empty() {
 return Err(Empty);
 }

 if value.len() > 500 {
 return Err(TooLong);
 }

 Ok(TicketDescription(value.to_string()))
}

impl TryFrom<String> for TicketDescription {
 type Error = InvalidDescriptionError;

 fn try_from(value: String) -> Result<Self, Self::Error> {
 str2description(&value)
 }
}

impl TryFrom<&str> for TicketDescription {
 type Error = InvalidDescriptionError;

 fn try_from(value: &str) -> Result<Self, Self::Error> {
 str2description(value)
 }
}

#[derive(Debug, Clone, Copy, PartialEq)]
pub enum Status {
 ToDo,
 InProgress,
 Done,
}

use Status::*;

#[derive(thiserror::Error, Debug)]
#[error("{0}")]
pub struct InvalidStatusError(String);

fn str2status(value: &str) -> Result<Status, InvalidStatusError> {
 match value.to_lowercase().as_str() {
 "todo" => Ok(ToDo),
 "inprogress" => Ok(InProgress),
 "done" => Ok(Done),
 s => Err(InvalidStatusError(s.to_string())),
 }
}

impl TryFrom<String> for Status {
 type Error = InvalidStatusError;

 fn try_from(value: String) -> Result<Self, Self::Error> {
 str2status(&value)
 }
}

impl TryFrom<&str> for Status {
 type Error = InvalidStatusError;

 fn try_from(value: &str) -> Result<Self, Self::Error> {
 str2status(value)
 }
}

#[derive(Debug, PartialEq, Clone)]
pub struct TicketTitle(String);

#[derive(thiserror::Error, Debug)]
pub enum InvalidTitleError {
 #[error("The title cannot be empty")]
 Empty,
 #[error("The title cannot be longer than 50 bytes")]
 TooLong,
}

use InvalidTitleError::*;

fn str2title(value: &str) -> Result<TicketTitle, InvalidTitleError> {
 if value.is_empty() {
 return Err(Empty);
 }

 if value.len() > 50 {
 return Err(TooLong);
 }

 Ok(TicketTitle(value.to_string()))
}

impl TryFrom<String> for TicketTitle {
 type Error = InvalidTitleError;

 fn try_from(value: String) -> Result<Self, Self::Error> {
 str2title(&value)
 }
}

impl TryFrom<&str> for TicketTitle {
 type Error = InvalidTitleError;

 fn try_from(value: &str) -> Result<Self, Self::Error> {
 str2title(value)
 }
}