// TODO: Rework the signature of `TicketStore::add_ticket` to use a generic type parameter rather
// than `impl Trait` syntax.

use ticket_fields::{TicketDescription, TicketTitle};

#[derive(Clone)]
pub struct TicketStore {
 tickets: Vec<Ticket>,
}

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

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

impl TicketStore {
 pub fn new() -> Self {
 Self {
 tickets: Vec::new(),
 }
 }

 // Using `Into<Ticket>` as the type parameter for `ticket` allows the method to accept any type
 // that can be infallibly converted into a `Ticket`.
 // This can make it nicer to use the method, as it removes the syntax noise of `.into()`
 // from the calling site. It can worsen the quality of the compiler error messages, though.
 pub fn add_ticket(&mut self, ticket: impl Into<Ticket>) {
 self.tickets.push(ticket.into());
 }
}

impl TicketStore {
 pub fn add_ticket<T>(&mut self, ticket: T)
 where
 T: Into<Ticket>,
 {
 self.tickets.push(ticket.into());
 }
}

// TODO: Define a function named `sum` that takes a reference to a slice of `u32` and returns the sum of all
// elements in the slice.

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

 #[test]
 fn empty() {
 let v = vec![];
 assert_eq!(sum(&v), 0);
 }

 #[test]
 fn one_element() {
 let v = vec![1];
 assert_eq!(sum(&v), 1);
 }

 #[test]
 fn multiple_elements() {
 let v = vec![1, 2, 3, 4, 5];
 assert_eq!(sum(&v), 15);
 }

 #[test]
 fn array_slice() {
 let v = [1, 2, 3, 4, 5];
 assert_eq!(sum(&v), 15);
 }
}

fn sum(array: &[u32]) -> u32 {
 array.iter().sum()
}

fn main() {
 println!("{}", sum(vec![0, 1, 2, 3].as_slice()));
 println!("{}", sum( [4, 5, 6, 7].as_slice()));
}