use std::collections::BTreeMap;

mod cache;
mod env;
mod execution;
mod fingerprint;
mod glob;
mod graph;
mod watch;

pub use cache::Cache;
pub use env::{Error as EnvError, load_values as load_env_values};
pub use execution::{CancelToken, Execution, FailedTask, ReadyTask, Report, RunOptions, Step};
pub use fingerprint::graph_fingerprint;
pub use glob::{
    PatternError, collect_paths, compile_pattern, covers, expand_files, normalize_pattern,
    validate_output_pattern, validate_pattern,
};
pub use graph::{Action, CallbackRef, Graph, Task, shell_quote};
pub use watch::{
    EnvResolution, Relevance, WatchContext, WatchEvent, WatchSet, WatchState, external_roots,
    forget_directories, known_directories, normalize_path, relative_to, remember_directories,
    resolution_paths, resolve_watch_target, resolved_input_paths,
};

#[derive(Debug, thiserror::Error)]
pub enum Error {
    #[error("Unknown task {0:?}")]
    UnknownTask(String),
    #[error("Task cycle detected: {0}")]
    Cycle(String),
    #[error("Task {task:?} files pattern {pattern:?} matched no files")]
    UnmatchedFiles { task: String, pattern: String },
    #[error("Task {task:?}: invalid glob pattern {pattern:?}: {message}")]
    Pattern {
        task: String,
        pattern: String,
        message: String,
    },
    #[error("Task {task:?}: cannot read {path}: {source}")]
    Read {
        task: String,
        path: String,
        #[source]
        source: std::io::Error,
    },
    #[error("Invalid environment variable name {0:?}")]
    EnvName(String),
    #[error(transparent)]
    Env(#[from] EnvError),
    #[error("Task {task:?}: unsupported action {kind} in this driver")]
    UnsupportedAction { task: String, kind: &'static str },
    #[error(transparent)]
    Io(#[from] std::io::Error),
}

pub type Result<T> = std::result::Result<T, Error>;
pub type EnvMap = BTreeMap<String, String>;

// ------------------------------------------------------------------ reporter

pub trait Reporter {
    fn cached(&self, _name: &str) {}
    fn unmatched_output(&self, _name: &str, _pattern: &str) {}
    fn cache_error(&self, _name: &str, _message: &str) {}
}

pub struct NoopReporter;
impl Reporter for NoopReporter {}