// 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.

#[cfg(target_os = "fuchsia")]
use tracing::{error, warn};

use crate::config::ActionConfig;

use {
    super::{
        config::DiagnosticData,
        metrics::{
            fetch::{Fetcher, FileDataFetcher},
            metric_value::{MetricValue, Problem},
            ExpressionContext, ExpressionTree, Function, Metric, MetricState, Metrics, ValueSource,
        },
        plugins::{register_plugins, Plugin},
    },
    crate::metric_value_to_int,
    anyhow::{bail, Error},
    fidl_fuchsia_feedback::MAX_CRASH_SIGNATURE_LENGTH,
    serde::{Deserialize, Serialize},
    std::{cell::RefCell, collections::HashMap},
};

/// Provides the [metric_state] context to evaluate [Action]s and results of the [actions].
pub struct ActionContext<'a> {
    actions: &'a Actions,
    metric_state: MetricState<'a>,
    action_results: ActionResults,
    plugins: Vec<Box<dyn Plugin>>,
}

impl<'a> ActionContext<'a> {
    pub(crate) fn new(
        metrics: &'a Metrics,
        actions: &'a Actions,
        diagnostic_data: &'a [DiagnosticData],
        now: Option<i64>,
    ) -> ActionContext<'a> {
        let fetcher = FileDataFetcher::new(diagnostic_data);
        let mut action_results = ActionResults::new();
        fetcher.errors().iter().for_each(|e| {
            action_results.errors.push(format!("[DEBUG: BAD DATA] {}", e));
        });
        ActionContext {
            actions,
            metric_state: MetricState::new(metrics, Fetcher::FileData(fetcher), now),
            action_results,
            plugins: register_plugins(),
        }
    }
}

/// Stores the results of each [Action] specified in [source] and
/// the [warnings] and [gauges] that are generated.
#[derive(Clone, Debug)]
pub struct ActionResults {
    pub infos: Vec<String>,
    pub warnings: Vec<String>,
    pub errors: Vec<String>,
    pub gauges: Vec<String>,
    pub broken_gauges: Vec<String>,
    pub snapshots: Vec<SnapshotTrigger>,
    pub sort_gauges: bool,
    pub verbose: bool,
    pub sub_results: Vec<(String, Box<ActionResults>)>,
}

impl ActionResults {
    pub fn new() -> ActionResults {
        ActionResults {
            infos: Vec::new(),
            warnings: Vec::new(),
            errors: Vec::new(),
            gauges: Vec::new(),
            broken_gauges: Vec::new(),
            snapshots: Vec::new(),
            sort_gauges: true,
            verbose: false,
            sub_results: Vec::new(),
        }
    }

    pub fn all_issues(&self) -> impl Iterator<Item = &str> {
        self.infos.iter().chain(self.warnings.iter()).chain(self.errors.iter()).map(|s| s.as_ref())
    }
}

/// [SnapshotTrigger] is the information needed to generate a request for a crash report.
/// It can be returned from the library as part of ActionResults.
#[derive(Debug, Clone, PartialEq)]
pub struct SnapshotTrigger {
    pub interval: i64, // zx::Duration but this library has to run on host.
    pub signature: String,
}

/// [Actions] are stored as a map of maps, both with string keys. The outer key
/// is the namespace for the inner key, which is the name of the [Action].
pub(crate) type Actions = HashMap<String, ActionsSchema>;

/// [ActionsSchema] stores the [Action]s from a single config file / namespace.
///
/// This struct is used to deserialize the [Action]s from the JSON-formatted
/// config file.
pub(crate) type ActionsSchema = HashMap<String, Action>;

/// Action represent actions that can be taken using an evaluated value(s).
#[derive(Clone, Debug, Serialize, PartialEq)]
#[serde(tag = "type")]
pub enum Action {
    Alert(Alert),
    Gauge(Gauge),
    Snapshot(Snapshot),
}

impl Action {
    pub fn from_config_with_namespace(
        action_config: ActionConfig,
        namespace: &str,
    ) -> Result<Action, anyhow::Error> {
        let action = match action_config {
            ActionConfig::Alert { trigger, print, file_bug, tag, severity } => {
                Action::Alert(Alert {
                    trigger: ValueSource::try_from_expression_with_namespace(&trigger, namespace)?,
                    print,
                    file_bug,
                    tag,
                    severity,
                })
            }
            ActionConfig::Warning { trigger, print, file_bug, tag } => Action::Alert(Alert {
                trigger: ValueSource::try_from_expression_with_namespace(&trigger, namespace)?,
                print,
                file_bug,
                tag,
                // TODO(https://fxbug.dev/42153014): `Warning` will be deprecated once all config files use `Alert`
                severity: Severity::Warning,
            }),
            ActionConfig::Gauge { value, format, tag } => Action::Gauge(Gauge {
                value: ValueSource::try_from_expression_with_namespace(&value, namespace)?,
                format,
                tag,
            }),
            ActionConfig::Snapshot { trigger, repeat, signature } => Action::Snapshot(Snapshot {
                trigger: ValueSource::try_from_expression_with_namespace(&trigger, namespace)?,
                repeat: ValueSource::try_from_expression_with_namespace(&repeat, namespace)?,
                signature,
            }),
        };
        Ok(action)
    }
}

#[derive(Clone, Debug, Deserialize, Serialize, PartialEq)]
//#[serde(tag = "severity")]
pub enum Severity {
    Info,
    Warning,
    Error,
}

pub(crate) fn validate_action(
    action_name: &str,
    action_config: &ActionConfig,
    namespace: &str,
) -> Result<(), Error> {
    match action_config {
        // Make sure the snapshot signature isn't too long.
        ActionConfig::Snapshot { signature, repeat, .. } => {
            if signature.len() > MAX_CRASH_SIGNATURE_LENGTH as usize {
                bail!("Signature too long in {}", action_name);
            }
            let repeat = ValueSource::try_from_expression_with_namespace(&repeat, namespace)?;
            // Make sure repeat is a const int expression (cache the value if so)
            match repeat.metric {
                Metric::Eval(repeat_expression) => {
                    let repeat_value = MetricState::evaluate_const_expression(
                        &repeat_expression.parsed_expression,
                    );
                    if let MetricValue::Int(repeat_int) = repeat_value {
                        repeat.cached_value.borrow_mut().replace(MetricValue::Int(repeat_int));
                    } else {
                        bail!(
                            "Snapshot {} repeat expression '{}' must evaluate to int, not {:?}",
                            action_name,
                            repeat_expression.raw_expression,
                            repeat_value
                        );
                    }
                }
                _ => unreachable!("ValueSource::try_from() only produces an Eval"),
            }
        }
        // Make sure Error-level alerts have a file_bug field.
        ActionConfig::Alert { severity, file_bug, .. } => {
            if *severity == Severity::Error && file_bug.is_none() {
                bail!("Error severity requires file_bug field in {}", action_name);
            }
        }
        _ => {}
    }
    Ok(())
}

/// Action that is triggered if a predicate is met.
#[derive(Clone, Debug, Serialize, PartialEq)]
pub struct Alert {
    /// A wrapped expression to evaluate which determines if this action triggers.
    pub trigger: ValueSource,
    /// What to print if trigger is true.
    pub print: String,
    /// Describes where bugs should be filed if this action triggers.
    pub file_bug: Option<String>,
    /// An optional tag to associate with this Action.
    pub tag: Option<String>,
    /// Info, Warning, Error, with the same meanings as the log types. Error must have a file_bug:
    /// field but that field is optional for Info and Warning.
    pub severity: Severity,
}

/// Action that displays percentage of value.
#[derive(Clone, Debug, Serialize, PartialEq)]
pub struct Gauge {
    /// Value to surface.
    pub value: ValueSource,
    /// Opaque type that determines how value should be formatted (e.g. percentage).
    pub format: Option<String>,
    /// An optional tag to associate with this Action.
    pub tag: Option<String>,
}

/// Action that displays percentage of value.
#[derive(Clone, Debug, Serialize, PartialEq)]
pub struct Snapshot {
    /// Take snapshot when this is true.
    pub trigger: ValueSource,
    /// A wrapped expression evaluating to time delay before repeated triggers.
    pub repeat: ValueSource,
    /// Sent in the crash report.
    pub signature: String,
    // There's no tag option because snapshot conditions are always news worth seeing.
}

impl Gauge {
    pub fn get_formatted_value(&self, metric_value: MetricValue) -> String {
        match metric_value {
            MetricValue::Float(value) => match &self.format {
                Some(format) if format.as_str() == "percentage" => {
                    format!("{:.2}%", value * 100.0f64)
                }
                _ => format!("{}", value),
            },
            MetricValue::Int(value) => match &self.format {
                Some(format) if format.as_str() == "percentage" => format!("{}%", value * 100),
                _ => format!("{}", value),
            },
            MetricValue::Problem(Problem::Ignore(_)) => "N/A".to_string(),
            value => format!("{:?}", value),
        }
    }
}

impl Action {
    pub fn get_tag(&self) -> Option<String> {
        match self {
            Action::Alert(action) => action.tag.clone(),
            Action::Gauge(action) => action.tag.clone(),
            Action::Snapshot(_) => None,
        }
    }

    /// Creates a [Warning] with a trigger evaluating to Bool(true) and its cache pre-populated.
    pub fn new_synthetic_warning(print: String) -> Action {
        let trigger_true = get_trigger_true();
        Action::Alert(Alert {
            trigger: trigger_true,
            print,
            file_bug: None,
            tag: None,
            severity: Severity::Warning,
        })
    }

    pub fn new_synthetic_error(print: String, file_bug: String) -> Action {
        let trigger_true = get_trigger_true();
        Action::Alert(Alert {
            trigger: trigger_true,
            print,
            file_bug: Some(file_bug),
            tag: None,
            severity: Severity::Error,
        })
    }

    /// Creates a [Gauge] with the cache value pre-populated.
    /// This only supports string values.
    pub fn new_synthetic_string_gauge(
        raw_value: String,
        format: Option<String>,
        tag: Option<String>,
    ) -> Action {
        let value = ValueSource {
            metric: Metric::Eval(ExpressionContext {
                raw_expression: format!("'{}'", raw_value),
                parsed_expression: ExpressionTree::Value(MetricValue::String(raw_value.clone())),
            }),
            cached_value: RefCell::new(Some(MetricValue::String(raw_value))),
        };
        Action::Gauge(Gauge { value, format, tag })
    }

    /// Returns true if any significant problem or notification is found.
    /// If the trigger or value hasnn't been evaluated, returns false
    pub(crate) fn has_reportable_issue(&self) -> bool {
        let value = match self {
            Action::Alert(alert) => &alert.trigger.cached_value,
            Action::Snapshot(snapshot) => &snapshot.trigger.cached_value,
            Action::Gauge(gauge) => &gauge.value.cached_value,
        };
        let reportable_on_true = match self {
            Action::Gauge(_) => false,
            Action::Snapshot(_) => true,
            Action::Alert(alert) if alert.severity == Severity::Info => false,
            Action::Alert(_) => true,
        };
        let result = match *value.borrow() {
            Some(MetricValue::Bool(true)) if reportable_on_true => true,
            Some(MetricValue::Problem(Problem::Missing(_))) => false,
            Some(MetricValue::Problem(Problem::Ignore(_))) => false,
            Some(MetricValue::Problem(_)) => true,
            _ => false,
        };
        result
    }
}

fn get_trigger_true() -> ValueSource {
    ValueSource {
        metric: Metric::Eval(ExpressionContext {
            raw_expression: "True()".to_string(),
            parsed_expression: ExpressionTree::Function(Function::True, vec![]),
        }),
        cached_value: RefCell::new(Some(MetricValue::Bool(true))),
    }
}

/// Contains all Error, Warning, and Info generated while computing snapshots.
pub type WarningVec = Vec<String>;

impl ActionContext<'_> {
    /// Processes all actions, acting on the ones that trigger.
    pub fn process(&mut self) -> &ActionResults {
        if let Fetcher::FileData(file_data) = &self.metric_state.fetcher {
            for plugin in &self.plugins {
                self.action_results
                    .sub_results
                    .push((plugin.display_name().to_string(), Box::new(plugin.run(file_data))));
            }
        }

        for (namespace, actions) in self.actions.iter() {
            for (name, action) in actions.iter() {
                match action {
                    Action::Alert(alert) => self.update_alerts(alert, namespace, name),
                    Action::Gauge(gauge) => self.update_gauges(gauge, namespace, name),
                    Action::Snapshot(snapshot) => self.update_snapshots(snapshot, namespace, name),
                };
            }
        }

        &self.action_results
    }

    pub(crate) fn set_verbose(&mut self, verbose: bool) {
        self.action_results.verbose = verbose;
    }

    /// Evaluate and return snapshots. Consume self.
    pub fn into_snapshots(mut self) -> (Vec<SnapshotTrigger>, WarningVec) {
        for (namespace, actions) in self.actions.iter() {
            for (name, action) in actions.iter() {
                if let Action::Snapshot(snapshot) = action {
                    self.update_snapshots(snapshot, namespace, name)
                }
            }
        }
        let mut alerts = vec![];
        alerts.extend(self.action_results.errors);
        alerts.extend(self.action_results.warnings);
        alerts.extend(self.action_results.infos);
        (self.action_results.snapshots, alerts)
    }

    /// Update warnings if condition is met.
    fn update_alerts(&mut self, action: &Alert, namespace: &String, name: &String) {
        match self.metric_state.eval_action_metric(namespace, &action.trigger) {
            MetricValue::Bool(true) => {
                if let Some(file_bug) = &action.file_bug {
                    self.action_results
                        .errors
                        .push(format!("[BUG:{}] {}.", file_bug, action.print));
                } else {
                    self.action_results.warnings.push(format!("[WARNING] {}.", action.print));
                }
            }
            MetricValue::Bool(false) => (),
            MetricValue::Problem(Problem::Ignore(_)) => (),
            MetricValue::Problem(Problem::Missing(reason)) => {
                self.action_results.infos.push(format!(
                    "[MISSING] In config '{}::{}': (need boolean trigger) {:?}",
                    namespace, name, reason,
                ));
            }
            MetricValue::Problem(problem) => {
                self.action_results.errors.push(format!(
                    "[ERROR] In config '{}::{}': (need boolean trigger): {:?}",
                    namespace, name, problem,
                ));
            }
            other => {
                self.action_results.errors.push(format!(
                    "[DEBUG: BAD CONFIG] Unexpected value type in config '{}::{}' (need boolean trigger): {}",
                    namespace,
                    name,
                    other,
                ));
            }
        };
    }

    /// Update snapshots if condition is met.
    fn update_snapshots(&mut self, action: &Snapshot, namespace: &str, name: &str) {
        match self.metric_state.eval_action_metric(namespace, &action.trigger) {
            MetricValue::Bool(true) => {
                let repeat_value = self.metric_state.eval_action_metric(namespace, &action.repeat);
                let interval = metric_value_to_int(repeat_value);
                match interval {
                    Ok(interval) => {
                        let signature = action.signature.clone();
                        let output = SnapshotTrigger { interval, signature };
                        self.action_results.snapshots.push(output);
                    }
                    Err(ref bad_type) => {
                        self.action_results.errors.push(format!(
                            "Bad interval in config '{}::{}': {:?}",
                            namespace, name, bad_type,
                        ));
                        #[cfg(target_os = "fuchsia")]
                        error!("Bad interval in config '{}::{}': {:?}", namespace, name, interval);
                    }
                }
            }
            MetricValue::Bool(false) => (),
            MetricValue::Problem(Problem::Ignore(_)) => (),
            MetricValue::Problem(reason) => {
                #[cfg(target_os = "fuchsia")]
                warn!(
                    "Snapshot trigger was not boolean in config '{}::{}': {:?}",
                    namespace, name, reason,
                );
                self.action_results
                    .infos
                    .push(format!("[MISSING] In config '{}::{}': {:?}", namespace, name, reason,));
            }
            other => {
                #[cfg(target_os = "fuchsia")]
                error!(
                    "[DEBUG: BAD CONFIG] Unexpected value type in config '{}::{}' (need boolean): {}",
                    namespace,
                    name,
                    other,
                );
                self.action_results.errors.push(format!(
                    "[DEBUG: BAD CONFIG] Unexpected value type in config '{}::{}' (need boolean): {}",
                    namespace,
                    name,
                    other,
                ));
            }
        };
    }

    /// Update gauges.
    fn update_gauges(&mut self, action: &Gauge, namespace: &String, name: &String) {
        let value = self.metric_state.eval_action_metric(namespace, &action.value);
        match value {
            MetricValue::Problem(Problem::Ignore(_)) => {
                self.action_results.broken_gauges.push(format!("{}: N/A", name));
            }
            MetricValue::Problem(problem) => {
                self.action_results.broken_gauges.push(format!("{}: {:?}", name, problem));
            }
            value => {
                self.action_results.gauges.push(format!(
                    "{}: {}",
                    name,
                    action.get_formatted_value(value)
                ));
            }
        }
    }
}

#[cfg(test)]
mod test {
    use {
        super::*,
        crate::{config::Source, make_metrics},
    };

    /// Tells whether any of the stored values include a substring.
    fn includes(values: &Vec<String>, substring: &str) -> bool {
        for value in values {
            if value.contains(substring) {
                return true;
            }
        }
        return false;
    }

    #[fuchsia::test]
    fn actions_fire_correctly() {
        let metrics = make_metrics!({
            "file":{
                eval: {
                    "true": "0 == 0",
                    "false": "0 == 1",
                    "true_array": "[0 == 0]",
                    "false_array": "[0 == 1]"
                }
            }
        });
        let mut actions = Actions::new();
        let mut action_file = ActionsSchema::new();
        action_file.insert(
            "do_true".to_string(),
            Action::Alert(Alert {
                trigger: ValueSource::try_from_expression_with_namespace("true", "file").unwrap(),
                print: "True was fired".to_string(),
                file_bug: Some("Some>Monorail>Component".to_string()),
                tag: None,
                severity: Severity::Warning,
            }),
        );
        action_file.insert(
            "do_false".to_string(),
            Action::Alert(Alert {
                trigger: ValueSource::try_from_expression_with_namespace("false", "file").unwrap(),
                print: "False was fired".to_string(),
                file_bug: None,
                tag: None,
                severity: Severity::Warning,
            }),
        );
        action_file.insert(
            "do_true_array".to_string(),
            Action::Alert(Alert {
                trigger: ValueSource::try_from_expression_with_namespace("true_array", "file")
                    .unwrap(),
                print: "True array was fired".to_string(),
                file_bug: None,
                tag: None,
                severity: Severity::Warning,
            }),
        );
        action_file.insert(
            "do_false_array".to_string(),
            Action::Alert(Alert {
                trigger: ValueSource::try_from_expression_with_namespace("false_array", "file")
                    .unwrap(),
                print: "False array was fired".to_string(),
                file_bug: None,
                tag: None,
                severity: Severity::Warning,
            }),
        );

        action_file.insert(
            "do_operation".to_string(),
            Action::Alert(Alert {
                trigger: ValueSource::try_from_expression_with_namespace("0 < 10", "file").unwrap(),
                print: "Inequality triggered".to_string(),
                file_bug: None,
                tag: None,
                severity: Severity::Warning,
            }),
        );
        actions.insert("file".to_string(), action_file);
        let no_data = Vec::new();
        let mut context = ActionContext::new(&metrics, &actions, &no_data, None);
        let results = context.process();
        assert!(includes(&results.errors, "[BUG:Some>Monorail>Component] True was fired."));
        assert!(includes(&results.warnings, "[WARNING] Inequality triggered."));
        assert!(includes(&results.warnings, "[WARNING] True array was fired"));
        assert!(!includes(&results.warnings, "False was fired"));
        assert!(!includes(&results.warnings, "False array was fired"));
    }

    #[fuchsia::test]
    fn gauges_fire_correctly() {
        let metrics = make_metrics!({
            "file":{
                eval: {
                    "gauge_f1": "2 / 5",
                    "gauge_f2": "4 / 5",
                    "gauge_f3": "6 / 5",
                    "gauge_i4": "9 // 2",
                    "gauge_i5": "11 // 2",
                    "gauge_i6": "13 // 2",
                    "gauge_b7": "2 == 2",
                    "gauge_b8": "2 > 2",
                    "gauge_s9": "'foo'"
                }
            }
        });
        let mut actions = Actions::new();
        let mut action_file = ActionsSchema::new();
        macro_rules! insert_gauge {
            ($name:expr, $format:expr) => {
                action_file.insert(
                    $name.to_string(),
                    Action::Gauge(Gauge {
                        value: ValueSource::try_from_expression_with_namespace($name, "file")
                            .unwrap(),
                        format: $format,
                        tag: None,
                    }),
                );
            };
        }
        insert_gauge!("gauge_f1", None);
        insert_gauge!("gauge_f2", Some("percentage".to_string()));
        insert_gauge!("gauge_f3", Some("unknown".to_string()));
        insert_gauge!("gauge_i4", None);
        insert_gauge!("gauge_i5", Some("percentage".to_string()));
        insert_gauge!("gauge_i6", Some("unknown".to_string()));
        insert_gauge!("gauge_b7", None);
        insert_gauge!("gauge_b8", None);
        insert_gauge!("gauge_s9", None);
        actions.insert("file".to_string(), action_file);
        let no_data = Vec::new();
        let mut context = ActionContext::new(&metrics, &actions, &no_data, None);

        let results = context.process();

        assert!(includes(&results.gauges, "gauge_f1: 0.4"));
        assert!(includes(&results.gauges, "gauge_f2: 80.00%"));
        assert!(includes(&results.gauges, "gauge_f3: 1.2"));
        assert!(includes(&results.gauges, "gauge_i4: 4"));
        assert!(includes(&results.gauges, "gauge_i5: 500%"));
        assert!(includes(&results.gauges, "gauge_i6: 6"));
        assert!(includes(&results.gauges, "gauge_b7: Bool(true)"));
        assert!(includes(&results.gauges, "gauge_b8: Bool(false)"));
        assert!(includes(&results.gauges, "gauge_s9: String(\"foo\")"));
    }

    #[fuchsia::test]
    fn action_context_errors() {
        let metrics = Metrics::new();
        let actions = Actions::new();
        let data = vec![DiagnosticData::new(
            "inspect.json".to_string(),
            Source::Inspect,
            r#"
            [
                {
                    "moniker": "abcd",
                    "payload": {"root": {"val": 10}}
                },
                {
                    "moniker": "abcd2",
                    "payload": ["a", "b"]
                },
                {
                    "moniker": "abcd3",
                    "payload": null
                }
            ]
            "#
            .to_string(),
        )
        .expect("create data")];
        let action_context = ActionContext::new(&metrics, &actions, &data, None);
        // Caution - test footgun! This error will show up without calling process() but
        // most get_warnings() results will not.
        assert_eq!(
            vec!["[DEBUG: BAD DATA] Unable to deserialize Inspect contents for abcd2 to node hierarchy"
                .to_string()],
            action_context.action_results.errors
        );
    }

    #[fuchsia::test]
    fn time_propagates_correctly() {
        let metrics = Metrics::new();
        let mut actions = Actions::new();
        let mut action_file = ActionsSchema::new();
        action_file.insert(
            "time_1234".to_string(),
            Action::Alert(Alert {
                trigger: ValueSource::try_from_expression_with_namespace("Now() == 1234", "file")
                    .unwrap(),
                print: "1234".to_string(),
                tag: None,
                file_bug: None,
                severity: Severity::Warning,
            }),
        );
        action_file.insert(
            "time_missing".to_string(),
            Action::Alert(Alert {
                trigger: ValueSource::try_from_expression_with_namespace("Problem(Now())", "file")
                    .unwrap(),
                print: "missing".to_string(),
                tag: None,
                file_bug: None,
                severity: Severity::Warning,
            }),
        );
        actions.insert("file".to_string(), action_file);
        let data = vec![];
        let actions_missing = actions.clone();
        let mut context_1234 = ActionContext::new(&metrics, &actions, &data, Some(1234));
        let results_1234 = context_1234.process();
        let mut context_missing = ActionContext::new(&metrics, &actions_missing, &data, None);
        let results_no_time = context_missing.process();

        assert_eq!(vec!["[WARNING] 1234.".to_string()], results_1234.warnings);
        assert!(results_no_time
            .infos
            .contains(&"[MISSING] In config \'file::time_1234\': (need boolean trigger) \"No valid time available\"".to_string()));
        assert!(results_no_time.warnings.contains(&"[WARNING] missing.".to_string()));
    }

    #[fuchsia::test]
    fn snapshots_update_correctly() -> Result<(), Error> {
        let metrics = Metrics::new();
        let actions = Actions::new();
        let data = vec![];
        let mut action_context = ActionContext::new(&metrics, &actions, &data, None);
        let true_value = ValueSource::try_from_expression_with_default_namespace("1==1")?;
        let false_value = ValueSource::try_from_expression_with_default_namespace("1==2")?;
        let five_value = ValueSource {
            metric: Metric::Eval(ExpressionContext::try_from_expression_with_default_namespace(
                "5",
            )?),
            cached_value: RefCell::new(Some(MetricValue::Int(5))),
        };
        let foo_value = ValueSource::try_from_expression_with_default_namespace("'foo'")?;
        let missing_value = ValueSource::try_from_expression_with_default_namespace("foo")?;
        let snapshot_5_sig = SnapshotTrigger { interval: 5, signature: "signature".to_string() };
        // Tester re-uses the same action_context, so results will accumulate.
        macro_rules! tester {
            ($trigger:expr, $repeat:expr, $func:expr) => {
                let selector_interval_action = Snapshot {
                    trigger: $trigger.clone(),
                    repeat: $repeat.clone(),
                    signature: "signature".to_string(),
                };
                action_context.update_snapshots(&selector_interval_action, "", "");
                assert!($func(&action_context.action_results.snapshots));
            };
        }
        type VT = Vec<SnapshotTrigger>;

        // Verify it doesn't crash on bad inputs
        tester!(true_value, foo_value, |s: &VT| s.is_empty());
        tester!(true_value, missing_value, |s: &VT| s.is_empty());
        tester!(foo_value, five_value, |s: &VT| s.is_empty());
        tester!(five_value, five_value, |s: &VT| s.is_empty());
        tester!(missing_value, five_value, |s: &VT| s.is_empty());
        // Problem::Missing shows up in infos, not warnings
        assert_eq!(action_context.action_results.infos.len(), 1);
        assert_eq!(action_context.action_results.warnings.len(), 0);
        assert_eq!(action_context.action_results.errors.len(), 4);
        // False trigger shouldn't add a result
        tester!(false_value, five_value, |s: &VT| s.is_empty());
        tester!(true_value, five_value, |s| s == &vec![snapshot_5_sig.clone()]);
        // We can have more than one of the same trigger in the results.
        tester!(true_value, five_value, |s| s
            == &vec![snapshot_5_sig.clone(), snapshot_5_sig.clone()]);
        assert_eq!(action_context.action_results.infos.len(), 1);
        assert_eq!(action_context.action_results.warnings.len(), 0);
        assert_eq!(action_context.action_results.errors.len(), 4);
        let (snapshots, warnings) = action_context.into_snapshots();
        assert_eq!(snapshots.len(), 2);
        assert_eq!(warnings.len(), 5);
        Ok(())
    }

    #[fuchsia::test]
    fn actions_cache_correctly() {
        let metrics = make_metrics!({
            "file":{
                eval: {
                    "true": "0 == 0",
                    "false": "0 == 1",
                    "five": "5"
                }
            }
        });
        let mut actions = Actions::new();
        let mut action_file = ActionsSchema::new();
        action_file.insert(
            "true_warning".to_string(),
            Action::Alert(Alert {
                trigger: ValueSource::try_from_expression_with_namespace("true", "file").unwrap(),
                print: "True was fired".to_string(),
                file_bug: None,
                tag: None,
                severity: Severity::Warning,
            }),
        );
        action_file.insert(
            "false_gauge".to_string(),
            Action::Gauge(Gauge {
                value: ValueSource::try_from_expression_with_namespace("false", "file").unwrap(),
                format: None,
                tag: None,
            }),
        );
        action_file.insert(
            "true_snapshot".to_string(),
            Action::Snapshot(Snapshot {
                trigger: ValueSource::try_from_expression_with_namespace("true", "file").unwrap(),
                repeat: ValueSource {
                    metric: Metric::Eval(
                        ExpressionContext::try_from_expression_with_namespace("five", "file")
                            .unwrap(),
                    ),
                    cached_value: RefCell::new(Some(MetricValue::Int(5))),
                },
                signature: "signature".to_string(),
            }),
        );
        action_file.insert(
            "test_snapshot".to_string(),
            Action::Snapshot(Snapshot {
                trigger: ValueSource::try_from_expression_with_namespace("true", "file").unwrap(),
                repeat: ValueSource::try_from_expression_with_namespace("five", "file").unwrap(),
                signature: "signature".to_string(),
            }),
        );
        actions.insert("file".to_string(), action_file);
        let no_data = Vec::new();
        let mut context = ActionContext::new(&metrics, &actions, &no_data, None);
        context.process();

        // Ensure Alert caches correctly
        if let Action::Alert(warning) = actions.get("file").unwrap().get("true_warning").unwrap() {
            assert_eq!(*warning.trigger.cached_value.borrow(), Some(MetricValue::Bool(true)));
        } else {
            unreachable!("'true_warning' must be an Action::Alert")
        }

        // Ensure Gauge caches correctly
        if let Action::Gauge(gauge) = actions.get("file").unwrap().get("false_gauge").unwrap() {
            assert_eq!(*gauge.value.cached_value.borrow(), Some(MetricValue::Bool(false)));
        } else {
            unreachable!("'false_gauge' must be an Action::Gauge")
        }

        // Ensure Snapshot caches correctly
        if let Action::Snapshot(snapshot) =
            actions.get("file").unwrap().get("true_snapshot").unwrap()
        {
            assert_eq!(*snapshot.trigger.cached_value.borrow(), Some(MetricValue::Bool(true)));
            assert_eq!(*snapshot.repeat.cached_value.borrow(), Some(MetricValue::Int(5)));
        } else {
            unreachable!("'true_snapshot' must be an Action::Snapshot")
        }

        // Ensure value-calculation does not fail for a Snapshot with an empty cache.
        // The cached value for 'repeat' is expected to be pre-calculated during deserialization
        // however, an empty cached value should still be supported.
        if let Action::Snapshot(snapshot) =
            actions.get("file").unwrap().get("test_snapshot").unwrap()
        {
            assert_eq!(*snapshot.trigger.cached_value.borrow(), Some(MetricValue::Bool(true)));
            assert_eq!(*snapshot.repeat.cached_value.borrow(), Some(MetricValue::Int(5)));
        } else {
            unreachable!("'true_snapshot' must be an Action::Snapshot")
        }
    }
}