// Copyright 2019 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

use {
    anyhow::{Context as _, Error},
    fuchsia_async::{self as fasync, futures::StreamExt},
    fuchsia_component::server::ServiceFs,
    fuchsia_inspect::{self as inspect, Property},
};

/// A task represents something that needs to be done. It consists of a bug
/// number for each tracking as well as a human-readable name.
/// It also contains a completion ratio of 1.0 that can be set dynamically.
#[derive(Debug)]
struct Task {
    /// The bug number of the task.
    _bug_number: String,

    /// The name of the task.
    _name: String,

    /// The completion ratio of the task (between 0 and 1).
    completion: f64,

    // Inspect values
    // They are set as the Task is created. Not really used in the program, but
    // recorded in Inspect. When the struct is dropped, the inspect values will
    // be cleared.

    // Node for this task
    _node: inspect::Node,

    // Inspect properties for the bug number and name.
    _bug_number_property: inspect::StringProperty,
    _name_property: inspect::StringProperty,

    // The completion of the task.
    completion_metric: inspect::DoubleProperty,
}

impl Task {
    /// Constructs a new |Task|.
    /// The given |Node| is provided by the parent to allow linking into the
    /// inspect hierarchy.
    fn new(bug_number: &str, name: &str, node: inspect::Node) -> Self {
        let _bug_number_property = node.create_string("bug", bug_number);
        let _name_property = node.create_string("name", name);
        let completion_metric = node.create_double("completion", 0.0);
        Task {
            _bug_number: bug_number.to_string(),
            completion: 0.0,
            _name: name.to_string(),
            _node: node,
            _bug_number_property,
            _name_property,
            completion_metric,
        }
    }

    /// Sets the completion ratio of the task.
    fn set_completion(&mut self, completion: f64) {
        self.completion = 0.0_f64.max(completion.min(1.0));
        self.completion_metric.set(self.completion);
    }
}

/// Represents an individual employee of the company.
struct Employee {
    _name: String,
    _email: String,

    // Tasks assigned to this |Employee|.
    tasks: Vec<Task>,

    // |Employee|s reporting to this |Employee|.
    reports: Vec<Employee>,

    // Inspect values
    // They are set as the Task is created. Not really used in the program, but
    // recorded in Inspect. When the struct is dropped, the inspect values will
    // be cleared.

    // Node under which this |Employee| can expose information.
    _node: inspect::Node,

    // Node under which this |Employee| nests |Task|s.
    task_node: inspect::Node,

    // Node under which this |Employee| nests reporting |Employee|s.
    report_node: inspect::Node,
}

impl Employee {
    pub fn new(name: &str, email: &str, node: inspect::Node) -> Self {
        let task_node = node.create_child("tasks");
        let report_node = node.create_child("reports");
        Employee {
            _name: name.to_string(),
            _email: email.to_string(),
            _node: node,
            tasks: vec![],
            reports: vec![],
            task_node,
            report_node,
        }
    }

    pub fn task_count(&self) -> usize {
        self.tasks.len()
    }

    /// Add a new task to this employee.
    pub fn add_task(&mut self, bug_number: &str, name: &str) -> &mut Task {
        let report_index =
            (0..self.reports.len()).fold(None, |min: Option<usize>, i: usize| match min {
                Some(j) => Some(if self.reports[j].task_count() < self.reports[i].task_count() {
                    j
                } else {
                    i
                }),
                None => Some(i),
            });
        match report_index {
            None => self.add_task_inner(bug_number, name),
            Some(report_index) => {
                if self.task_count() < self.reports[report_index].task_count() {
                    self.add_task_inner(bug_number, name)
                } else {
                    self.reports[report_index].add_task(bug_number, name)
                }
            }
        }
    }

    fn add_task_inner(&mut self, bug_number: &str, name: &str) -> &mut Task {
        let node_name = format!("task-{}", bug_number);
        let task = Task::new(bug_number, name, self.task_node.create_child(&node_name));
        self.tasks.push(task);
        self.tasks.last_mut().unwrap()
    }

    /// Add a new report to this employee.
    pub fn add_report(&mut self, name: &str, email: &str) -> usize {
        let employee = Employee::new(name, email, self.report_node.create_child(email));
        self.reports.push(employee);
        self.reports.len() - 1
    }

    pub fn get_report(&mut self, index: usize) -> Option<&mut Employee> {
        self.reports.get_mut(index)
    }
}

fn main() -> Result<(), Error> {
    let mut executor = fasync::Executor::new().context("error creating executor")?;
    let mut fs = ServiceFs::new();

    // Creates a new inspector object. This will create the "root" node in the
    // inspect tree to which further children objects can be added.
    let inspector = inspect::Inspector::new();

    // Serves the Inspect Tree at the standard location "/diagnostics/fuchsia.inspect.Tree"
    inspector.serve(&mut fs)?;

    // Create a CEO |Employee| nested underneath the |root_object|.
    // The name "reporting_tree" will appear as a child of the root object.
    let mut ceo =
        Employee::new("CEO", "ceo@example.com", inspector.root().create_child("reporting_tree"));

    // Create some reports for the CEO, named Bob, Prakash, and Svetlana.
    let bob_index = ceo.add_report("Bob", "bob@example.com");
    let prakash_index = ceo.add_report("Prakash", "prakash@example.com");
    let svetlana_index = ceo.add_report("Svetlana", "svetlana@example.com");

    // Bob has 3 reports: Julie, James, and Jun.
    ceo.get_report(bob_index).unwrap().add_report("Julie", "julie@example.com");
    ceo.get_report(bob_index).unwrap().add_report("James", "james@example.com");
    ceo.get_report(bob_index).unwrap().add_report("Jun", "jun@example.com");

    // Prakash has two reports: Gerald and Nathan.
    ceo.get_report(prakash_index).unwrap().add_report("Gerald", "gerald@example.com");
    // Nathan is an intern, so assign him a task to complete his training.
    let report_index =
        ceo.get_report(prakash_index).unwrap().add_report("Nathan", "nathan@example.com");
    ceo.get_report(report_index)
        .unwrap()
        .add_task("ABC-12", "Complete intern code training")
        .set_completion(1.0);

    // Bob has a lot of corporate tasks to complete, he will give these to people
    // in his reporting tree.
    let bob = ceo.get_report(bob_index).unwrap();
    bob.add_task("CORP-100", "Promote extra synergy").set_completion(0.5);
    bob.add_task("CORP-101", "Circle back and re-sync").set_completion(0.75);
    bob.add_task("CORP-102", "Look into issue with facilities").set_completion(0.8);
    bob.add_task("CORP-103", "Issue new badges").set_completion(0.2);

    // Prakash has a lot of engineering tasks to complete, he will give these to
    // people in his reporting tree.
    let prakash = ceo.get_report(prakash_index).unwrap();
    prakash.add_task("ENG-10", "Document key structures").set_completion(1.0);
    prakash.add_task("ENG-11", "Write login page").set_completion(0.1);
    prakash.add_task("ENG-12", "Create design for v2").set_completion(0.33);

    // Svetlana has a lot of infrastructure tasks to complete, she doesn't
    // currently have reports so she takes these herself.
    let svetlana = ceo.get_report(svetlana_index).unwrap();
    svetlana.add_task("INFRA-100", "Implement new infrastructure").set_completion(1.0);
    svetlana.add_task("INFRA-101", "Onboard new users").set_completion(0.8);

    // Svetlana hired new people to help with infrastructure.
    svetlana.add_report("Hector", "hector@example.com");
    svetlana.add_report("Dianne", "dianne@example.com");
    svetlana.add_report("Andre", "andre@example.com");

    // Good thing Svetlana just hired, here are a bunch of tasks.
    svetlana.add_task("INFRA-102", "Bring up new datacenter").set_completion(0.75);
    svetlana.add_task("INFRA-103", "Cleanup old file structure").set_completion(0.25);
    svetlana.add_task("INFRA-104", "Rewire the datacenter again").set_completion(0.9);
    svetlana.add_task("INFRA-105", "Upgrade the cooling system").set_completion(0.8);
    svetlana.add_task("INFRA-106", "Investigate opening a datacenter on Mars").set_completion(1.0);
    svetlana.add_task("INFRA-107", "Interface with the cloud").set_completion(0.05);

    fs.take_and_serve_directory_handle()?;

    let () = executor.run_singlethreaded(fs.collect());
    Ok(())
}

#[cfg(test)]
mod tests {
    use {super::*, fuchsia_inspect::assert_inspect_tree};

    #[test]
    fn test_tree() {
        let inspector = inspect::Inspector::new();
        let mut ceo = Employee::new(
            "CEO",
            "ceo@example.com",
            inspector.root().create_child("reporting_tree"),
        );
        let bob_index = ceo.add_report("Bob", "bob@example.com");
        let bob = ceo.get_report(bob_index).unwrap();
        bob.add_report("Julie", "julie@example.com");
        bob.add_report("James", "james@example.com");
        bob.add_task("CORP-100", "Promote extra synergy").set_completion(0.5);
        bob.add_task("CORP-101", "Circle back and re-sync").set_completion(0.75);
        bob.add_task("CORP-102", "Look into issue with facilities").set_completion(0.8);

        assert_inspect_tree!(inspector, root: {
            reporting_tree: {
                tasks: {},
                reports: {
                    "bob@example.com": {
                        tasks: {
                            "task-CORP-102": {
                                bug: "CORP-102",
                                name: "Look into issue with facilities",
                                completion: 0.8
                            }
                        },
                        reports: {
                            "julie@example.com": {
                                tasks: {
                                    "task-CORP-101": {
                                        bug: "CORP-101",
                                        name: "Circle back and re-sync",
                                        completion: 0.75
                                    }
                                },
                                reports: {}
                            },
                            "james@example.com": {
                                tasks: {
                                    "task-CORP-100": {
                                        bug: "CORP-100",
                                        name: "Promote extra synergy",
                                        completion: 0.5
                                    }
                                },
                                reports: {}
                            }
                        }
                    }
                }
            }
        });
    }
}