第4章：数据建模 —— 结构体、枚举、模式匹配与方法

fn estimate_range(hours: u8) -> (u8, u8) {
    (hours.saturating_sub(1), hours.saturating_add(2))
}

fn main() {
    let range = estimate_range(5);
    println!("{}..={}", range.0, range.1);

    let (min, max) = range;
    println!("最少 {min} 小时，最多 {max} 小时");
}

struct EstimateRange {
    min: u8,
    max: u8,
}

struct WorkItemId(u64);

let id = WorkItemId(42);
println!("工作项编号：{}", id.0);

#[derive(Debug)]
struct WorkItem {
    id: u64,
    title: String,
    estimate_hours: u8,
    tags: [String; 2],
}

let item = WorkItem {
    id: 1,
    title: String::from("整理 Rust 学习笔记"),
    estimate_hours: 6,
    tags: [String::from("学习"), String::from("Rust")],
};

println!("{}: {}", item.id, item.title);
println!("{item:#?}");

fn build_item(id: u64, title: String) -> WorkItem {
    WorkItem {
        id,
        title,
        estimate_hours: 1,
        tags: [String::from("待分类"), String::from("默认")],
    }
}

let copied = WorkItem {
    id: 2,
    title: String::from("复核学习笔记"),
    ..item
};

match copied.tags.get(2) {
    Some(tag) => println!("第三个标签：{tag}"),
    None => println!("这个工作项只有两个标签"),
}

#[derive(Debug, Clone, Copy)]
enum Priority {
    Low,
    Medium,
    High,
}

#[derive(Debug)]
enum WorkItemStatus {
    Todo,
    Doing { assignee: String },
    Done { needs_review: bool },
}

let todo = WorkItemStatus::Todo;
let doing = WorkItemStatus::Doing {
    assignee: String::from("Lin"),
};
let done = WorkItemStatus::Done {
    needs_review: true,
};

#[derive(Debug)]
struct WorkItem {
    id: u64,
    title: String,
    priority: Priority,
    status: WorkItemStatus,
    estimate_hours: u8,
    tags: [String; 2],
}

fn status_text(status: &WorkItemStatus) -> String {
    match status {
        WorkItemStatus::Todo => String::from("待处理"),
        WorkItemStatus::Doing { assignee } => format!("进行中：{assignee}"),
        WorkItemStatus::Done { needs_review: true } => String::from("已完成，待复盘"),
        WorkItemStatus::Done { needs_review: false } => String::from("已完成"),
    }
}

fn print_status(item: &WorkItem) {
    match &item.status {
        WorkItemStatus::Todo => println!("{} 还没开始", item.title),
        WorkItemStatus::Doing { assignee } => println!("由 {assignee} 处理"),
        WorkItemStatus::Done { needs_review } => println!("复盘：{needs_review}"),
    }
}

match item {
    WorkItem { id, title, .. } => println!("#{id} {title}"),
}

fn urgency(item: &WorkItem) -> &'static str {
    match item {
        WorkItem {
            priority: Priority::High,
            estimate_hours: hours @ 8..=u8::MAX,
            ..
        } => {
            println!("大型高优工作项：{hours} 小时");
            "立即拆分并开始"
        }
        WorkItem { estimate_hours, .. } if *estimate_hours <= 1 => "快速完成",
        _ => "正常排期",
    }
}

if let WorkItemStatus::Doing { assignee } = &item.status {
    println!("当前负责人：{assignee}");
}

let is_high = matches!(item.priority, Priority::High);
let is_active = matches!(
    &item.status,
    WorkItemStatus::Todo | WorkItemStatus::Doing { .. }
);
let owned_by_lin = matches!(
    &item.status,
    WorkItemStatus::Doing { assignee } if assignee == "Lin"
);

impl WorkItem {
    fn new(
        id: u64,
        title: &str,
        priority: Priority,
        estimate_hours: u8,
        tags: [String; 2],
    ) -> Self {
        Self {
            id,
            title: title.to_string(),
            priority,
            status: WorkItemStatus::Todo,
            estimate_hours,
            tags,
        }
    }

    fn start(&mut self, assignee: &str) -> bool {
        match self.status {
            WorkItemStatus::Todo => {
                self.status = WorkItemStatus::Doing {
                    assignee: assignee.to_string(),
                };
                true
            }
            _ => false,
        }
    }

    fn finish(&mut self, needs_review: bool) -> bool {
        match self.status {
            WorkItemStatus::Doing { .. } => {
                self.status = WorkItemStatus::Done { needs_review };
                true
            }
            _ => false,
        }
    }

    fn status_text(&self) -> String {
        status_text(&self.status)
    }

    fn is_urgent(&self) -> bool {
        matches!(self.priority, Priority::High)
            && !matches!(&self.status, WorkItemStatus::Done { .. })
    }
}

fn main() {
    let mut item = WorkItem::new(
        1,
        "整理 Rust 学习笔记",
        Priority::High,
        6,
        [String::from("学习"), String::from("Rust")],
    );

    println!("{}", item.status_text());
    assert!(item.start("Lin"));
    assert!(!item.start("Kai"));
    assert!(item.finish(true));
    println!("{}", item.status_text());
}