//! CSS bundling.
//!
//! A [Bundler](Bundler) can be used to combine a CSS file and all of its dependencies
//! into a single merged style sheet. It works together with a [SourceProvider](SourceProvider)
//! (e.g. [FileProvider](FileProvider)) to read files from the file system or another source,
//! and returns a [StyleSheet](super::stylesheet::StyleSheet) containing the rules from all
//! of the dependencies of the entry file, recursively.
//!
//! Rules are bundled following `@import` order, and wrapped in the necessary `@media`, `@supports`,
//! and `@layer` rules as appropriate to preserve the authored behavior.
//!
//! # Example
//!
//! ```no_run
//! use std::path::Path;
//! use lightningcss::{
//!   bundler::{Bundler, FileProvider},
//!   stylesheet::ParserOptions
//! };
//!
//! let fs = FileProvider::new();
//! let mut bundler = Bundler::new(&fs, None, ParserOptions::default());
//! let stylesheet = bundler.bundle(Path::new("style.css")).unwrap();
//! ```

use crate::{
  error::ErrorLocation,
  parser::DefaultAtRuleParser,
  properties::{
    css_modules::Specifier,
    custom::{
      CustomProperty, EnvironmentVariableName, TokenList, TokenOrValue, UnparsedProperty, UnresolvedColor,
    },
    Property,
  },
  rules::{
    layer::{LayerBlockRule, LayerName},
    Location,
  },
  traits::{AtRuleParser, ToCss},
  values::ident::DashedIdentReference,
};
use crate::{
  error::{Error, ParserError},
  media_query::MediaList,
  rules::{
    import::ImportRule,
    media::MediaRule,
    supports::{SupportsCondition, SupportsRule},
    CssRule, CssRuleList,
  },
  stylesheet::{ParserOptions, StyleSheet},
};
use dashmap::DashMap;
use parcel_sourcemap::SourceMap;
use rayon::prelude::*;
use std::{
  collections::HashSet,
  fs,
  path::{Path, PathBuf},
  sync::Mutex,
};

/// A Bundler combines a CSS file and all imported dependencies together into
/// a single merged style sheet.
pub struct Bundler<'a, 'o, 's, P, T: AtRuleParser<'a>> {
  source_map: Option<Mutex<&'s mut SourceMap>>,
  fs: &'a P,
  source_indexes: DashMap<PathBuf, u32>,
  stylesheets: Mutex<Vec<BundleStyleSheet<'a, 'o, T::AtRule>>>,
  options: ParserOptions<'o, 'a>,
  at_rule_parser: Mutex<AtRuleParserValue<'s, T>>,
}

enum AtRuleParserValue<'a, T> {
  Owned(T),
  Borrowed(&'a mut T),
}

struct BundleStyleSheet<'i, 'o, T> {
  stylesheet: Option<StyleSheet<'i, 'o, T>>,
  dependencies: Vec<u32>,
  css_modules_deps: Vec<u32>,
  parent_source_index: u32,
  parent_dep_index: u32,
  layer: Option<Option<LayerName<'i>>>,
  supports: Option<SupportsCondition<'i>>,
  media: MediaList<'i>,
  loc: Location,
}

/// A trait to provide the contents of files to a Bundler.
///
/// See [FileProvider](FileProvider) for an implementation that uses the
/// file system.
pub trait SourceProvider: Send + Sync {
  /// A custom error.
  type Error: std::error::Error + Send + Sync;

  /// Reads the contents of the given file path to a string.
  fn read<'a>(&'a self, file: &Path) -> Result<&'a str, Self::Error>;

  /// Resolves the given import specifier to a file path given the file
  /// which the import originated from.
  fn resolve(&self, specifier: &str, originating_file: &Path) -> Result<PathBuf, Self::Error>;
}

/// Provides an implementation of [SourceProvider](SourceProvider)
/// that reads files from the file system.
pub struct FileProvider {
  inputs: Mutex<Vec<*mut String>>,
}

impl FileProvider {
  /// Creates a new FileProvider.
  pub fn new() -> FileProvider {
    FileProvider {
      inputs: Mutex::new(Vec::new()),
    }
  }
}

unsafe impl Sync for FileProvider {}
unsafe impl Send for FileProvider {}

impl SourceProvider for FileProvider {
  type Error = std::io::Error;

  fn read<'a>(&'a self, file: &Path) -> Result<&'a str, Self::Error> {
    let source = fs::read_to_string(file)?;
    let ptr = Box::into_raw(Box::new(source));
    self.inputs.lock().unwrap().push(ptr);
    // SAFETY: this is safe because the pointer is not dropped
    // until the FileProvider is, and we never remove from the
    // list of pointers stored in the vector.
    Ok(unsafe { &*ptr })
  }

  fn resolve(&self, specifier: &str, originating_file: &Path) -> Result<PathBuf, Self::Error> {
    // Assume the specifier is a relative file path and join it with current path.
    Ok(originating_file.with_file_name(specifier))
  }
}

impl Drop for FileProvider {
  fn drop(&mut self) {
    for ptr in self.inputs.lock().unwrap().iter() {
      std::mem::drop(unsafe { Box::from_raw(*ptr) })
    }
  }
}

/// An error that could occur during bundling.
#[derive(Debug)]
#[cfg_attr(any(feature = "serde", feature = "nodejs"), derive(serde::Serialize))]
pub enum BundleErrorKind<'i, T: std::error::Error> {
  /// A parser error occurred.
  ParserError(ParserError<'i>),
  /// An unsupported `@import` condition was encountered.
  UnsupportedImportCondition,
  /// An unsupported cascade layer combination was encountered.
  UnsupportedLayerCombination,
  /// Unsupported media query boolean logic was encountered.
  UnsupportedMediaBooleanLogic,
  /// A custom resolver error.
  ResolverError(#[cfg_attr(any(feature = "serde", feature = "nodejs"), serde(skip))] T),
}

impl<'i, T: std::error::Error> From<Error<ParserError<'i>>> for Error<BundleErrorKind<'i, T>> {
  fn from(err: Error<ParserError<'i>>) -> Self {
    Error {
      kind: BundleErrorKind::ParserError(err.kind),
      loc: err.loc,
    }
  }
}

impl<'i, T: std::error::Error> std::fmt::Display for BundleErrorKind<'i, T> {
  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    use BundleErrorKind::*;
    match self {
      ParserError(err) => err.fmt(f),
      UnsupportedImportCondition => write!(f, "Unsupported import condition"),
      UnsupportedLayerCombination => write!(f, "Unsupported layer combination in @import"),
      UnsupportedMediaBooleanLogic => write!(f, "Unsupported boolean logic in @import media query"),
      ResolverError(err) => std::fmt::Display::fmt(&err, f),
    }
  }
}

impl<'i, T: std::error::Error> BundleErrorKind<'i, T> {
  #[deprecated(note = "use `BundleErrorKind::to_string()` or `std::fmt::Display` instead")]
  #[allow(missing_docs)]
  pub fn reason(&self) -> String {
    self.to_string()
  }
}

impl<'a, 'o, 's, P: SourceProvider> Bundler<'a, 'o, 's, P, DefaultAtRuleParser> {
  /// Creates a new Bundler using the given source provider.
  /// If a source map is given, the content of each source file included in the bundle will
  /// be added accordingly.
  pub fn new(
    fs: &'a P,
    source_map: Option<&'s mut SourceMap>,
    options: ParserOptions<'o, 'a>,
  ) -> Bundler<'a, 'o, 's, P, DefaultAtRuleParser> {
    Bundler {
      source_map: source_map.map(Mutex::new),
      fs,
      source_indexes: DashMap::new(),
      stylesheets: Mutex::new(Vec::new()),
      options,
      at_rule_parser: Mutex::new(AtRuleParserValue::Owned(DefaultAtRuleParser)),
    }
  }
}

impl<'a, 'o, 's, P: SourceProvider, T: AtRuleParser<'a> + Clone + Sync + Send> Bundler<'a, 'o, 's, P, T>
where
  T::AtRule: Sync + Send + ToCss + Clone,
{
  /// Creates a new Bundler using the given source provider.
  /// If a source map is given, the content of each source file included in the bundle will
  /// be added accordingly.
  pub fn new_with_at_rule_parser(
    fs: &'a P,
    source_map: Option<&'s mut SourceMap>,
    options: ParserOptions<'o, 'a>,
    at_rule_parser: &'s mut T,
  ) -> Self {
    Bundler {
      source_map: source_map.map(Mutex::new),
      fs,
      source_indexes: DashMap::new(),
      stylesheets: Mutex::new(Vec::new()),
      options,
      at_rule_parser: Mutex::new(AtRuleParserValue::Borrowed(at_rule_parser)),
    }
  }

  /// Bundles the given entry file and all dependencies into a single style sheet.
  pub fn bundle<'e>(
    &mut self,
    entry: &'e Path,
  ) -> Result<StyleSheet<'a, 'o, T::AtRule>, Error<BundleErrorKind<'a, P::Error>>> {
    // Phase 1: load and parse all files. This is done in parallel.
    self.load_file(
      &entry,
      ImportRule {
        url: "".into(),
        layer: None,
        supports: None,
        media: MediaList::new(),
        loc: Location {
          source_index: 0,
          line: 0,
          column: 0,
        },
      },
    )?;

    // Phase 2: determine the order that the files should be concatenated.
    self.order();

    // Phase 3: concatenate.
    let mut rules: Vec<CssRule<'a, T::AtRule>> = Vec::new();
    self.inline(&mut rules);

    let sources = self
      .stylesheets
      .get_mut()
      .unwrap()
      .iter()
      .flat_map(|s| s.stylesheet.as_ref().unwrap().sources.iter().cloned())
      .collect();

    let mut stylesheet = StyleSheet::new(sources, CssRuleList(rules), self.options.clone());

    stylesheet.source_map_urls = self
      .stylesheets
      .get_mut()
      .unwrap()
      .iter()
      .flat_map(|s| s.stylesheet.as_ref().unwrap().source_map_urls.iter().cloned())
      .collect();

    stylesheet.license_comments = self
      .stylesheets
      .get_mut()
      .unwrap()
      .iter()
      .flat_map(|s| s.stylesheet.as_ref().unwrap().license_comments.iter().cloned())
      .collect();

    if let Some(config) = &self.options.css_modules {
      if config.pattern.has_content_hash() {
        stylesheet.content_hashes = Some(
          self
            .stylesheets
            .get_mut()
            .unwrap()
            .iter()
            .flat_map(|s| {
              let s = s.stylesheet.as_ref().unwrap();
              s.content_hashes.as_ref().unwrap().iter().cloned()
            })
            .collect(),
        );
      }
    }

    Ok(stylesheet)
  }

  fn find_filename(&self, source_index: u32) -> String {
    // This function is only used for error handling, so it's ok if this is a bit slow.
    let entry = self.source_indexes.iter().find(|x| *x.value() == source_index).unwrap();
    entry.key().to_str().unwrap().into()
  }

  fn load_file(&self, file: &Path, rule: ImportRule<'a>) -> Result<u32, Error<BundleErrorKind<'a, P::Error>>> {
    // Check if we already loaded this file.
    let mut stylesheets = self.stylesheets.lock().unwrap();
    let source_index = match self.source_indexes.get(file) {
      Some(source_index) => {
        // If we already loaded this file, combine the media queries and supports conditions
        // from this import rule with the existing ones using a logical or operator.
        let entry = &mut stylesheets[*source_index as usize];

        // We cannot combine a media query and a supports query from different @import rules.
        // e.g. @import "a.css" print; @import "a.css" supports(color: red);
        // This would require duplicating the actual rules in the file.
        if (!rule.media.media_queries.is_empty() && !entry.supports.is_none())
          || (!entry.media.media_queries.is_empty() && !rule.supports.is_none())
        {
          return Err(Error {
            kind: BundleErrorKind::UnsupportedImportCondition,
            loc: Some(ErrorLocation::new(rule.loc, self.find_filename(rule.loc.source_index))),
          });
        }

        if rule.media.media_queries.is_empty() {
          entry.media.media_queries.clear();
        } else if !entry.media.media_queries.is_empty() {
          entry.media.or(&rule.media);
        }

        if let Some(supports) = rule.supports {
          if let Some(existing_supports) = &mut entry.supports {
            existing_supports.or(&supports)
          }
        } else {
          entry.supports = None;
        }

        if let Some(layer) = &rule.layer {
          if let Some(existing_layer) = &entry.layer {
            // We can't OR layer names without duplicating all of the nested rules, so error for now.
            if layer != existing_layer || (layer.is_none() && existing_layer.is_none()) {
              return Err(Error {
                kind: BundleErrorKind::UnsupportedLayerCombination,
                loc: Some(ErrorLocation::new(rule.loc, self.find_filename(rule.loc.source_index))),
              });
            }
          } else {
            entry.layer = rule.layer;
          }
        }

        return Ok(*source_index);
      }
      None => {
        let source_index = stylesheets.len() as u32;
        self.source_indexes.insert(file.to_owned(), source_index);

        stylesheets.push(BundleStyleSheet {
          stylesheet: None,
          layer: rule.layer.clone(),
          media: rule.media.clone(),
          supports: rule.supports.clone(),
          loc: rule.loc.clone(),
          dependencies: Vec::new(),
          css_modules_deps: Vec::new(),
          parent_source_index: 0,
          parent_dep_index: 0,
        });

        source_index
      }
    };

    drop(stylesheets); // ensure we aren't holding the lock anymore

    let code = self.fs.read(file).map_err(|e| Error {
      kind: BundleErrorKind::ResolverError(e),
      loc: if rule.loc.column == 0 {
        None
      } else {
        Some(ErrorLocation::new(rule.loc, self.find_filename(rule.loc.source_index)))
      },
    })?;

    let mut opts = self.options.clone();
    let filename = file.to_str().unwrap();
    opts.filename = filename.to_owned();
    opts.source_index = source_index;

    let mut stylesheet = {
      let mut at_rule_parser = self.at_rule_parser.lock().unwrap();
      let at_rule_parser = match &mut *at_rule_parser {
        AtRuleParserValue::Owned(owned) => owned,
        AtRuleParserValue::Borrowed(borrowed) => *borrowed,
      };

      StyleSheet::<T::AtRule>::parse_with(code, opts, at_rule_parser)?
    };

    if let Some(source_map) = &self.source_map {
      // Only add source if we don't have an input source map.
      // If we do, this will be handled by the printer when remapping locations.
      let sm = stylesheet.source_map_url(0);
      if sm.is_none() || !sm.unwrap().starts_with("data") {
        let mut source_map = source_map.lock().unwrap();
        let source_index = source_map.add_source(filename);
        let _ = source_map.set_source_content(source_index as usize, code);
      }
    }

    // Collect and load dependencies for this stylesheet in parallel.
    let dependencies: Result<Vec<u32>, _> = stylesheet
      .rules
      .0
      .par_iter_mut()
      .filter_map(|r| {
        // Prepend parent layer name to @layer statements.
        if let CssRule::LayerStatement(layer) = r {
          if let Some(Some(parent_layer)) = &rule.layer {
            for name in &mut layer.names {
              name.0.insert_many(0, parent_layer.0.iter().cloned())
            }
          }
        }

        if let CssRule::Import(import) = r {
          let specifier = &import.url;

          // Combine media queries and supports conditions from parent
          // stylesheet with @import rule using a logical and operator.
          let mut media = rule.media.clone();
          let result = media.and(&import.media).map_err(|_| Error {
            kind: BundleErrorKind::UnsupportedMediaBooleanLogic,
            loc: Some(ErrorLocation::new(
              import.loc,
              self.find_filename(import.loc.source_index),
            )),
          });

          if let Err(e) = result {
            return Some(Err(e));
          }

          let layer = if (rule.layer == Some(None) && import.layer.is_some())
            || (import.layer == Some(None) && rule.layer.is_some())
          {
            // Cannot combine anonymous layers
            return Some(Err(Error {
              kind: BundleErrorKind::UnsupportedLayerCombination,
              loc: Some(ErrorLocation::new(
                import.loc,
                self.find_filename(import.loc.source_index),
              )),
            }));
          } else if let Some(Some(a)) = &rule.layer {
            if let Some(Some(b)) = &import.layer {
              let mut name = a.clone();
              name.0.extend(b.0.iter().cloned());
              Some(Some(name))
            } else {
              Some(Some(a.clone()))
            }
          } else {
            import.layer.clone()
          };

          let result = match self.fs.resolve(&specifier, file) {
            Ok(path) => self.load_file(
              &path,
              ImportRule {
                layer,
                media,
                supports: combine_supports(rule.supports.clone(), &import.supports),
                url: "".into(),
                loc: import.loc,
              },
            ),
            Err(err) => Err(Error {
              kind: BundleErrorKind::ResolverError(err),
              loc: Some(ErrorLocation::new(
                import.loc,
                self.find_filename(import.loc.source_index),
              )),
            }),
          };

          Some(result)
        } else {
          None
        }
      })
      .collect();

    // Collect CSS modules dependencies from the `composes` property.
    let css_modules_deps: Result<Vec<u32>, _> = if self.options.css_modules.is_some() {
      stylesheet
        .rules
        .0
        .par_iter_mut()
        .filter_map(|r| {
          if let CssRule::Style(style) = r {
            Some(
              style
                .declarations
                .declarations
                .par_iter_mut()
                .chain(style.declarations.important_declarations.par_iter_mut())
                .filter_map(|d| match d {
                  Property::Composes(composes) => self
                    .add_css_module_dep(file, &rule, style.loc, composes.loc, &mut composes.from)
                    .map(|result| rayon::iter::Either::Left(rayon::iter::once(result))),

                  // Handle variable references if the dashed_idents option is present.
                  Property::Custom(CustomProperty { value, .. })
                  | Property::Unparsed(UnparsedProperty { value, .. })
                    if matches!(&self.options.css_modules, Some(css_modules) if css_modules.dashed_idents) =>
                  {
                    Some(rayon::iter::Either::Right(visit_vars(value).filter_map(|name| {
                      self.add_css_module_dep(
                        file,
                        &rule,
                        style.loc,
                        // TODO: store loc in variable reference?
                        crate::dependencies::Location {
                          line: style.loc.line,
                          column: style.loc.column,
                        },
                        &mut name.from,
                      )
                    })))
                  }
                  _ => None,
                })
                .flatten(),
            )
          } else {
            None
          }
        })
        .flatten()
        .collect()
    } else {
      Ok(vec![])
    };

    let entry = &mut self.stylesheets.lock().unwrap()[source_index as usize];
    entry.stylesheet = Some(stylesheet);
    entry.dependencies = dependencies?;
    entry.css_modules_deps = css_modules_deps?;

    Ok(source_index)
  }

  fn add_css_module_dep(
    &self,
    file: &Path,
    rule: &ImportRule<'a>,
    style_loc: Location,
    loc: crate::dependencies::Location,
    specifier: &mut Option<Specifier>,
  ) -> Option<Result<u32, Error<BundleErrorKind<'a, P::Error>>>> {
    if let Some(Specifier::File(f)) = specifier {
      let result = match self.fs.resolve(&f, file) {
        Ok(path) => {
          let res = self.load_file(
            &path,
            ImportRule {
              layer: rule.layer.clone(),
              media: rule.media.clone(),
              supports: rule.supports.clone(),
              url: "".into(),
              loc: Location {
                source_index: style_loc.source_index,
                line: loc.line,
                column: loc.column,
              },
            },
          );

          if let Ok(source_index) = res {
            *specifier = Some(Specifier::SourceIndex(source_index));
          }

          res
        }
        Err(err) => Err(Error {
          kind: BundleErrorKind::ResolverError(err),
          loc: Some(ErrorLocation::new(
            style_loc,
            self.find_filename(style_loc.source_index),
          )),
        }),
      };
      Some(result)
    } else {
      None
    }
  }

  fn order(&mut self) {
    process(self.stylesheets.get_mut().unwrap(), 0, &mut HashSet::new());

    fn process<'i, T>(
      stylesheets: &mut Vec<BundleStyleSheet<'i, '_, T>>,
      source_index: u32,
      visited: &mut HashSet<u32>,
    ) {
      if visited.contains(&source_index) {
        return;
      }

      visited.insert(source_index);

      let mut dep_index = 0;
      for i in 0..stylesheets[source_index as usize].css_modules_deps.len() {
        let dep_source_index = stylesheets[source_index as usize].css_modules_deps[i];
        let resolved = &mut stylesheets[dep_source_index as usize];

        // CSS modules preserve the first instance of composed stylesheets.
        if !visited.contains(&dep_source_index) {
          resolved.parent_dep_index = dep_index;
          resolved.parent_source_index = source_index;
          process(stylesheets, dep_source_index, visited);
        }

        dep_index += 1;
      }

      for i in 0..stylesheets[source_index as usize].dependencies.len() {
        let dep_source_index = stylesheets[source_index as usize].dependencies[i];
        let resolved = &mut stylesheets[dep_source_index as usize];

        // In browsers, every instance of an @import is evaluated, so we preserve the last.
        resolved.parent_dep_index = dep_index;
        resolved.parent_source_index = source_index;

        process(stylesheets, dep_source_index, visited);
        dep_index += 1;
      }
    }
  }

  fn inline(&mut self, dest: &mut Vec<CssRule<'a, T::AtRule>>) {
    process(self.stylesheets.get_mut().unwrap(), 0, dest);

    fn process<'a, T>(
      stylesheets: &mut Vec<BundleStyleSheet<'a, '_, T>>,
      source_index: u32,
      dest: &mut Vec<CssRule<'a, T>>,
    ) {
      let stylesheet = &mut stylesheets[source_index as usize];
      let mut rules = std::mem::take(&mut stylesheet.stylesheet.as_mut().unwrap().rules.0);

      // Hoist css modules deps
      let mut dep_index = 0;
      for i in 0..stylesheet.css_modules_deps.len() {
        let dep_source_index = stylesheets[source_index as usize].css_modules_deps[i];
        let resolved = &stylesheets[dep_source_index as usize];

        // Include the dependency if this is the first instance as computed earlier.
        if resolved.parent_source_index == source_index && resolved.parent_dep_index == dep_index as u32 {
          process(stylesheets, dep_source_index, dest);
        }

        dep_index += 1;
      }

      let mut import_index = 0;
      for rule in &mut rules {
        match rule {
          CssRule::Import(_) => {
            let dep_source_index = stylesheets[source_index as usize].dependencies[import_index];
            let resolved = &stylesheets[dep_source_index as usize];

            // Include the dependency if this is the last instance as computed earlier.
            if resolved.parent_source_index == source_index && resolved.parent_dep_index == dep_index {
              process(stylesheets, dep_source_index, dest);
            }

            *rule = CssRule::Ignored;
            dep_index += 1;
            import_index += 1;
          }
          CssRule::LayerStatement(_) => {
            // @layer rules are the only rules that may appear before an @import.
            // We must preserve this order to ensure correctness.
            let layer = std::mem::replace(rule, CssRule::Ignored);
            dest.push(layer);
          }
          CssRule::Ignored => {}
          _ => break,
        }
      }

      // Wrap rules in the appropriate @layer, @media, and @supports rules.
      let stylesheet = &mut stylesheets[source_index as usize];

      if stylesheet.layer.is_some() {
        rules = vec![CssRule::LayerBlock(LayerBlockRule {
          name: stylesheet.layer.take().unwrap(),
          rules: CssRuleList(rules),
          loc: stylesheet.loc,
        })]
      }

      if !stylesheet.media.media_queries.is_empty() {
        rules = vec![CssRule::Media(MediaRule {
          query: std::mem::replace(&mut stylesheet.media, MediaList::new()),
          rules: CssRuleList(rules),
          loc: stylesheet.loc,
        })]
      }

      if stylesheet.supports.is_some() {
        rules = vec![CssRule::Supports(SupportsRule {
          condition: stylesheet.supports.take().unwrap(),
          rules: CssRuleList(rules),
          loc: stylesheet.loc,
        })]
      }

      dest.extend(rules);
    }
  }
}

fn combine_supports<'a>(
  a: Option<SupportsCondition<'a>>,
  b: &Option<SupportsCondition<'a>>,
) -> Option<SupportsCondition<'a>> {
  if let Some(mut a) = a {
    if let Some(b) = b {
      a.and(b)
    }
    Some(a)
  } else {
    b.clone()
  }
}

fn visit_vars<'a, 'b>(
  token_list: &'b mut TokenList<'a>,
) -> impl ParallelIterator<Item = &'b mut DashedIdentReference<'a>> {
  let mut stack = vec![token_list.0.iter_mut()];
  std::iter::from_fn(move || {
    while !stack.is_empty() {
      let iter = stack.last_mut().unwrap();
      match iter.next() {
        Some(TokenOrValue::Var(var)) => {
          if let Some(fallback) = &mut var.fallback {
            stack.push(fallback.0.iter_mut());
          }
          return Some(&mut var.name);
        }
        Some(TokenOrValue::Env(env)) => {
          if let Some(fallback) = &mut env.fallback {
            stack.push(fallback.0.iter_mut());
          }
          if let EnvironmentVariableName::Custom(name) = &mut env.name {
            return Some(name);
          }
        }
        Some(TokenOrValue::UnresolvedColor(color)) => match color {
          UnresolvedColor::RGB { alpha, .. } | UnresolvedColor::HSL { alpha, .. } => {
            stack.push(alpha.0.iter_mut());
          }
          UnresolvedColor::LightDark { light, dark } => {
            stack.push(light.0.iter_mut());
            stack.push(dark.0.iter_mut());
          }
        },
        None => {
          stack.pop();
        }
        _ => {}
      }
    }
    None
  })
  .par_bridge()
}

#[cfg(test)]
mod tests {
  use super::*;
  use crate::{
    css_modules::{self, CssModuleExports, CssModuleReference},
    parser::ParserFlags,
    stylesheet::{MinifyOptions, PrinterOptions},
    targets::{Browsers, Targets},
  };
  use indoc::indoc;
  use std::collections::HashMap;

  #[derive(Clone)]
  struct TestProvider {
    map: HashMap<PathBuf, String>,
  }

  impl SourceProvider for TestProvider {
    type Error = std::io::Error;

    fn read<'a>(&'a self, file: &Path) -> Result<&'a str, Self::Error> {
      Ok(self.map.get(file).unwrap())
    }

    fn resolve(&self, specifier: &str, originating_file: &Path) -> Result<PathBuf, Self::Error> {
      Ok(originating_file.with_file_name(specifier))
    }
  }

  /// Stand-in for a user-authored `SourceProvider` with application-specific logic.
  struct CustomProvider {
    map: HashMap<PathBuf, String>,
  }

  impl SourceProvider for CustomProvider {
    type Error = std::io::Error;

    /// Read files from in-memory map.
    fn read<'a>(&'a self, file: &Path) -> Result<&'a str, Self::Error> {
      Ok(self.map.get(file).unwrap())
    }

    /// Resolve by stripping a `foo:` prefix off any import. Specifiers without
    /// this prefix fail with an error.
    fn resolve(&self, specifier: &str, _originating_file: &Path) -> Result<PathBuf, Self::Error> {
      if specifier.starts_with("foo:") {
        Ok(Path::new(&specifier["foo:".len()..]).to_path_buf())
      } else {
        let err = std::io::Error::new(
          std::io::ErrorKind::NotFound,
          format!(
            "Failed to resolve `{}`, specifier does not start with `foo:`.",
            &specifier
          ),
        );

        Err(err)
      }
    }
  }

  macro_rules! fs(
    { $($key:literal: $value:expr),* } => {
      {
        #[allow(unused_mut)]
        let mut m = HashMap::new();
        $(
          m.insert(PathBuf::from($key), $value.to_owned());
        )*
        m
      }
    };
  );

  fn bundle<P: SourceProvider>(fs: P, entry: &str) -> String {
    let mut bundler = Bundler::new(&fs, None, ParserOptions::default());
    let stylesheet = bundler.bundle(Path::new(entry)).unwrap();
    stylesheet.to_css(PrinterOptions::default()).unwrap().code
  }

  fn bundle_css_module<P: SourceProvider>(
    fs: P,
    entry: &str,
    project_root: Option<&str>,
  ) -> (String, CssModuleExports) {
    bundle_css_module_with_pattern(fs, entry, project_root, "[hash]_[local]")
  }

  fn bundle_css_module_with_pattern<P: SourceProvider>(
    fs: P,
    entry: &str,
    project_root: Option<&str>,
    pattern: &'static str,
  ) -> (String, CssModuleExports) {
    let mut bundler = Bundler::new(
      &fs,
      None,
      ParserOptions {
        css_modules: Some(css_modules::Config {
          dashed_idents: true,
          pattern: css_modules::Pattern::parse(pattern).unwrap(),
          ..Default::default()
        }),
        ..ParserOptions::default()
      },
    );
    let mut stylesheet = bundler.bundle(Path::new(entry)).unwrap();
    stylesheet.minify(MinifyOptions::default()).unwrap();
    let res = stylesheet
      .to_css(PrinterOptions {
        project_root,
        ..PrinterOptions::default()
      })
      .unwrap();
    (res.code, res.exports.unwrap())
  }

  fn bundle_custom_media<P: SourceProvider>(fs: P, entry: &str) -> String {
    let mut bundler = Bundler::new(
      &fs,
      None,
      ParserOptions {
        flags: ParserFlags::CUSTOM_MEDIA,
        ..ParserOptions::default()
      },
    );
    let mut stylesheet = bundler.bundle(Path::new(entry)).unwrap();
    let targets = Targets {
      browsers: Some(Browsers {
        safari: Some(13 << 16),
        ..Browsers::default()
      }),
      ..Default::default()
    };
    stylesheet
      .minify(MinifyOptions {
        targets,
        ..MinifyOptions::default()
      })
      .unwrap();
    stylesheet
      .to_css(PrinterOptions {
        targets,
        ..PrinterOptions::default()
      })
      .unwrap()
      .code
  }

  fn error_test<P: SourceProvider>(
    fs: P,
    entry: &str,
    maybe_cb: Option<Box<dyn FnOnce(BundleErrorKind<P::Error>) -> ()>>,
  ) {
    let mut bundler = Bundler::new(&fs, None, ParserOptions::default());
    let res = bundler.bundle(Path::new(entry));
    match res {
      Ok(_) => unreachable!(),
      Err(e) => {
        if let Some(cb) = maybe_cb {
          cb(e.kind);
        }
      }
    }
  }

  fn flatten_exports(exports: CssModuleExports) -> HashMap<String, String> {
    let mut res = HashMap::new();
    for (name, export) in &exports {
      let mut classes = export.name.clone();
      for composes in &export.composes {
        classes.push(' ');
        classes.push_str(match composes {
          CssModuleReference::Local { name } => name,
          CssModuleReference::Global { name } => name,
          _ => unreachable!(),
        })
      }
      res.insert(name.clone(), classes);
    }
    res
  }

  #[test]
  fn test_bundle() {
    let res = bundle(
      TestProvider {
        map: fs! {
          "/a.css": r#"
          @import "b.css";
          .a { color: red }
        "#,
          "/b.css": r#"
          .b { color: green }
        "#
        },
      },
      "/a.css",
    );
    assert_eq!(
      res,
      indoc! { r#"
      .b {
        color: green;
      }

      .a {
        color: red;
      }
    "#}
    );

    let res = bundle(
      TestProvider {
        map: fs! {
          "/a.css": r#"
          @import "b.css" print;
          .a { color: red }
        "#,
          "/b.css": r#"
          .b { color: green }
        "#
        },
      },
      "/a.css",
    );
    assert_eq!(
      res,
      indoc! { r#"
      @media print {
        .b {
          color: green;
        }
      }

      .a {
        color: red;
      }
    "#}
    );

    let res = bundle(
      TestProvider {
        map: fs! {
          "/a.css": r#"
          @import "b.css" supports(color: green);
          .a { color: red }
        "#,
          "/b.css": r#"
          .b { color: green }
        "#
        },
      },
      "/a.css",
    );
    assert_eq!(
      res,
      indoc! { r#"
      @supports (color: green) {
        .b {
          color: green;
        }
      }

      .a {
        color: red;
      }
    "#}
    );

    let res = bundle(
      TestProvider {
        map: fs! {
          "/a.css": r#"
          @import "b.css" supports(color: green) print;
          .a { color: red }
        "#,
          "/b.css": r#"
          .b { color: green }
        "#
        },
      },
      "/a.css",
    );
    assert_eq!(
      res,
      indoc! { r#"
      @supports (color: green) {
        @media print {
          .b {
            color: green;
          }
        }
      }

      .a {
        color: red;
      }
    "#}
    );

    let res = bundle(
      TestProvider {
        map: fs! {
          "/a.css": r#"
          @import "b.css" print;
          @import "b.css" screen;
          .a { color: red }
        "#,
          "/b.css": r#"
          .b { color: green }
        "#
        },
      },
      "/a.css",
    );
    assert_eq!(
      res,
      indoc! { r#"
      @media print, screen {
        .b {
          color: green;
        }
      }

      .a {
        color: red;
      }
    "#}
    );

    let res = bundle(
      TestProvider {
        map: fs! {
          "/a.css": r#"
          @import "b.css" supports(color: red);
          @import "b.css" supports(foo: bar);
          .a { color: red }
        "#,
          "/b.css": r#"
          .b { color: green }
        "#
        },
      },
      "/a.css",
    );
    assert_eq!(
      res,
      indoc! { r#"
      @supports (color: red) or (foo: bar) {
        .b {
          color: green;
        }
      }

      .a {
        color: red;
      }
    "#}
    );

    let res = bundle(
      TestProvider {
        map: fs! {
          "/a.css": r#"
          @import "b.css" print;
          .a { color: red }
        "#,
          "/b.css": r#"
          @import "c.css" (color);
          .b { color: yellow }
        "#,
          "/c.css": r#"
          .c { color: green }
        "#
        },
      },
      "/a.css",
    );
    assert_eq!(
      res,
      indoc! { r#"
      @media print and (color) {
        .c {
          color: green;
        }
      }

      @media print {
        .b {
          color: #ff0;
        }
      }

      .a {
        color: red;
      }
    "#}
    );

    let res = bundle(
      TestProvider {
        map: fs! {
          "/a.css": r#"
          @import "b.css";
          .a { color: red }
        "#,
          "/b.css": r#"
          @import "c.css";
        "#,
          "/c.css": r#"
          @import "a.css";
          .c { color: green }
        "#
        },
      },
      "/a.css",
    );
    assert_eq!(
      res,
      indoc! { r#"
      .c {
        color: green;
      }

      .a {
        color: red;
      }
    "#}
    );

    let res = bundle(
      TestProvider {
        map: fs! {
          "/a.css": r#"
          @import "b/c.css";
          .a { color: red }
        "#,
          "/b/c.css": r#"
          .b { color: green }
        "#
        },
      },
      "/a.css",
    );
    assert_eq!(
      res,
      indoc! { r#"
      .b {
        color: green;
      }

      .a {
        color: red;
      }
    "#}
    );

    let res = bundle(
      TestProvider {
        map: fs! {
          "/a.css": r#"
          @import "./b/c.css";
          .a { color: red }
        "#,
          "/b/c.css": r#"
          .b { color: green }
        "#
        },
      },
      "/a.css",
    );
    assert_eq!(
      res,
      indoc! { r#"
      .b {
        color: green;
      }

      .a {
        color: red;
      }
    "#}
    );

    let res = bundle_custom_media(
      TestProvider {
        map: fs! {
          "/a.css": r#"
          @import "media.css";
          @import "b.css";
          .a { color: red }
        "#,
          "/media.css": r#"
          @custom-media --foo print;
        "#,
          "/b.css": r#"
          @media (--foo) {
            .a { color: green }
          }
        "#
        },
      },
      "/a.css",
    );
    assert_eq!(
      res,
      indoc! { r#"
      @media print {
        .a {
          color: green;
        }
      }

      .a {
        color: red;
      }
    "#}
    );

    let res = bundle(
      TestProvider {
        map: fs! {
          "/a.css": r#"
          @import "b.css" layer(foo);
          .a { color: red }
        "#,
          "/b.css": r#"
          .b { color: green }
        "#
        },
      },
      "/a.css",
    );
    assert_eq!(
      res,
      indoc! { r#"
      @layer foo {
        .b {
          color: green;
        }
      }

      .a {
        color: red;
      }
    "#}
    );

    let res = bundle(
      TestProvider {
        map: fs! {
          "/a.css": r#"
          @import "b.css" layer;
          .a { color: red }
        "#,
          "/b.css": r#"
          .b { color: green }
        "#
        },
      },
      "/a.css",
    );
    assert_eq!(
      res,
      indoc! { r#"
      @layer {
        .b {
          color: green;
        }
      }

      .a {
        color: red;
      }
    "#}
    );

    let res = bundle(
      TestProvider {
        map: fs! {
          "/a.css": r#"
          @import "b.css" layer(foo);
          .a { color: red }
        "#,
          "/b.css": r#"
          @import "c.css" layer(bar);
          .b { color: green }
        "#,
          "/c.css": r#"
          .c { color: green }
        "#
        },
      },
      "/a.css",
    );
    assert_eq!(
      res,
      indoc! { r#"
      @layer foo.bar {
        .c {
          color: green;
        }
      }

      @layer foo {
        .b {
          color: green;
        }
      }

      .a {
        color: red;
      }
    "#}
    );

    let res = bundle(
      TestProvider {
        map: fs! {
          "/a.css": r#"
          @import "b.css" layer(foo);
          @import "b.css" layer(foo);
        "#,
          "/b.css": r#"
          .b { color: green }
        "#
        },
      },
      "/a.css",
    );
    assert_eq!(
      res,
      indoc! { r#"
      @layer foo {
        .b {
          color: green;
        }
      }
    "#}
    );

    let res = bundle(
      TestProvider {
        map: fs! {
          "/a.css": r#"
          @layer bar, foo;
          @import "b.css" layer(foo);

          @layer bar {
            div {
              background: red;
            }
          }
        "#,
          "/b.css": r#"
          @layer qux, baz;
          @import "c.css" layer(baz);

          @layer qux {
            div {
              background: green;
            }
          }
        "#,
          "/c.css": r#"
          div {
            background: yellow;
          }
        "#
        },
      },
      "/a.css",
    );
    assert_eq!(
      res,
      indoc! { r#"
      @layer bar, foo;
      @layer foo.qux, foo.baz;

      @layer foo.baz {
        div {
          background: #ff0;
        }
      }

      @layer foo {
        @layer qux {
          div {
            background: green;
          }
        }
      }

      @layer bar {
        div {
          background: red;
        }
      }
    "#}
    );

    // Layer order depends on @import conditions.
    let res = bundle(
      TestProvider {
        map: fs! {
          "/a.css": r#"
          @import "b.css" layer(bar) (min-width: 1000px);

          @layer baz {
            #box { background: purple }
          }

          @layer bar {
            #box { background: yellow }
          }
        "#,
          "/b.css": r#"
          #box { background: green }
        "#
        },
      },
      "/a.css",
    );
    assert_eq!(
      res,
      indoc! { r#"
      @media (width >= 1000px) {
        @layer bar {
          #box {
            background: green;
          }
        }
      }

      @layer baz {
        #box {
          background: purple;
        }
      }

      @layer bar {
        #box {
          background: #ff0;
        }
      }
    "#}
    );

    error_test(
      TestProvider {
        map: fs! {
          "/a.css": r#"
          @import "b.css" layer(foo);
          @import "b.css" layer(bar);
        "#,
          "/b.css": r#"
          .b { color: red }
        "#
        },
      },
      "/a.css",
      Some(Box::new(|err| {
        assert!(matches!(err, BundleErrorKind::UnsupportedLayerCombination));
      })),
    );

    error_test(
      TestProvider {
        map: fs! {
          "/a.css": r#"
          @import "b.css" layer;
          @import "b.css" layer;
        "#,
          "/b.css": r#"
          .b { color: red }
        "#
        },
      },
      "/a.css",
      Some(Box::new(|err| {
        assert!(matches!(err, BundleErrorKind::UnsupportedLayerCombination));
      })),
    );

    error_test(
      TestProvider {
        map: fs! {
          "/a.css": r#"
          @import "b.css" layer;
          .a { color: red }
        "#,
          "/b.css": r#"
          @import "c.css" layer;
          .b { color: green }
        "#,
          "/c.css": r#"
          .c { color: green }
        "#
        },
      },
      "/a.css",
      Some(Box::new(|err| {
        assert!(matches!(err, BundleErrorKind::UnsupportedLayerCombination));
      })),
    );

    error_test(
      TestProvider {
        map: fs! {
          "/a.css": r#"
          @import "b.css" layer;
          .a { color: red }
        "#,
          "/b.css": r#"
          @import "c.css" layer(foo);
          .b { color: green }
        "#,
          "/c.css": r#"
          .c { color: green }
        "#
        },
      },
      "/a.css",
      Some(Box::new(|err| {
        assert!(matches!(err, BundleErrorKind::UnsupportedLayerCombination));
      })),
    );

    let res = bundle(
      TestProvider {
        map: fs! {
          "/index.css": r#"
          @import "a.css";
          @import "b.css";
        "#,
          "/a.css": r#"
          @import "./c.css";
          body { background: red; }
        "#,
          "/b.css": r#"
          @import "./c.css";
          body { color: red; }
        "#,
          "/c.css": r#"
          body {
            background: white;
            color: black;
          }
        "#
        },
      },
      "/index.css",
    );
    assert_eq!(
      res,
      indoc! { r#"
      body {
        background: red;
      }

      body {
        background: #fff;
        color: #000;
      }

      body {
        color: red;
      }
    "#}
    );

    let res = bundle(
      TestProvider {
        map: fs! {
          "/index.css": r#"
          @import "a.css";
          @import "b.css";
          @import "a.css";
        "#,
          "/a.css": r#"
          body { background: green; }
        "#,
          "/b.css": r#"
          body { background: red; }
        "#
        },
      },
      "/index.css",
    );
    assert_eq!(
      res,
      indoc! { r#"
      body {
        background: red;
      }

      body {
        background: green;
      }
    "#}
    );

    let res = bundle(
      CustomProvider {
        map: fs! {
          "/a.css": r#"
            @import "foo:/b.css";
            .a { color: red; }
          "#,
          "/b.css": ".b { color: green; }"
        },
      },
      "/a.css",
    );
    assert_eq!(
      res,
      indoc! { r#"
        .b {
          color: green;
        }

        .a {
          color: red;
        }
      "# }
    );

    error_test(
      CustomProvider {
        map: fs! {
          "/a.css": r#"
            /* Forgot to prefix with `foo:`. */
            @import "/b.css";
            .a { color: red; }
          "#,
          "/b.css": ".b { color: green; }"
        },
      },
      "/a.css",
      Some(Box::new(|err| {
        let kind = match err {
          BundleErrorKind::ResolverError(ref error) => error.kind(),
          _ => unreachable!(),
        };
        assert!(matches!(kind, std::io::ErrorKind::NotFound));
        assert!(err
          .to_string()
          .contains("Failed to resolve `/b.css`, specifier does not start with `foo:`."));
      })),
    );

    // let res = bundle(fs! {
    //   "/a.css": r#"
    //     @import "b.css" supports(color: red) (color);
    //     @import "b.css" supports(foo: bar) (orientation: horizontal);
    //     .a { color: red }
    //   "#,
    //   "/b.css": r#"
    //     .b { color: green }
    //   "#
    // }, "/a.css");

    // let res = bundle(fs! {
    //   "/a.css": r#"
    //     @import "b.css" not print;
    //     .a { color: red }
    //   "#,
    //   "/b.css": r#"
    //     @import "c.css" not screen;
    //     .b { color: green }
    //   "#,
    //   "/c.css": r#"
    //     .c { color: yellow }
    //   "#
    // }, "/a.css");
  }

  #[test]
  fn test_css_module() {
    macro_rules! map {
      { $($key:expr => $val:expr),* } => {
        HashMap::from([
          $(($key.to_owned(), $val.to_owned()),)*
        ])
      };
    }

    let (code, exports) = bundle_css_module(
      TestProvider {
        map: fs! {
          "/a.css": r#"
          @import "b.css";
          .a { color: red }
        "#,
          "/b.css": r#"
          .a { color: green }
        "#
        },
      },
      "/a.css",
      None,
    );
    assert_eq!(
      code,
      indoc! { r#"
      ._9z6RGq_a {
        color: green;
      }

      ._6lixEq_a {
        color: red;
      }
    "#}
    );
    assert_eq!(
      flatten_exports(exports),
      map! {
        "a" => "_6lixEq_a"
      }
    );

    let (code, exports) = bundle_css_module(
      TestProvider {
        map: fs! {
          "/a.css": r#"
          .a { composes: x from './b.css'; color: red; }
          .b { color: yellow }
        "#,
          "/b.css": r#"
          .x { composes: y; background: green }
          .y { font: Helvetica }
        "#
        },
      },
      "/a.css",
      None,
    );
    assert_eq!(
      code,
      indoc! { r#"
      ._8Cs9ZG_x {
        background: green;
      }

      ._8Cs9ZG_y {
        font: Helvetica;
      }

      ._6lixEq_a {
        color: red;
      }

      ._6lixEq_b {
        color: #ff0;
      }
    "#}
    );
    assert_eq!(
      flatten_exports(exports),
      map! {
        "a" => "_6lixEq_a _8Cs9ZG_x _8Cs9ZG_y",
        "b" => "_6lixEq_b"
      }
    );

    let (code, exports) = bundle_css_module(
      TestProvider {
        map: fs! {
          "/a.css": r#"
          .a { composes: x from './b.css'; background: red; }
        "#,
          "/b.css": r#"
          .a { background: red }
        "#
        },
      },
      "/a.css",
      None,
    );
    assert_eq!(
      code,
      indoc! { r#"
      ._8Cs9ZG_a {
        background: red;
      }

      ._6lixEq_a {
        background: red;
      }
    "#}
    );
    assert_eq!(
      flatten_exports(exports),
      map! {
        "a" => "_6lixEq_a"
      }
    );

    let (code, exports) = bundle_css_module(
      TestProvider {
        map: fs! {
          "/a.css": r#"
          .a {
            background: var(--bg from "./b.css", var(--fallback from "./b.css"));
            color: rgb(255 255 255 / var(--opacity from "./b.css"));
            width: env(--env, var(--env-fallback from "./env.css"));
          }
        "#,
          "/b.css": r#"
          .b {
            --bg: red;
            --fallback: yellow;
            --opacity: 0.5;
          }
        "#,
          "/env.css": r#"
          .env {
            --env-fallback: 20px;
          }
        "#
        },
      },
      "/a.css",
      None,
    );
    assert_eq!(
      code,
      indoc! { r#"
      ._8Cs9ZG_b {
        --_8Cs9ZG_bg: red;
        --_8Cs9ZG_fallback: yellow;
        --_8Cs9ZG_opacity: .5;
      }

      .GbJUva_env {
        --GbJUva_env-fallback: 20px;
      }

      ._6lixEq_a {
        background: var(--_8Cs9ZG_bg, var(--_8Cs9ZG_fallback));
        color: rgb(255 255 255 / var(--_8Cs9ZG_opacity));
        width: env(--_6lixEq_env, var(--GbJUva_env-fallback));
      }
    "#}
    );
    assert_eq!(
      flatten_exports(exports),
      map! {
        "a" => "_6lixEq_a",
        "--env" => "--_6lixEq_env"
      }
    );

    // Hashes are stable between project roots.
    let expected = indoc! { r#"
    .dyGcAa_b {
      background: #ff0;
    }

    .CK9avG_a {
      background: #fff;
    }
  "#};

    let (code, _) = bundle_css_module(
      TestProvider {
        map: fs! {
          "/foo/bar/a.css": r#"
        @import "b.css";
        .a {
          background: white;
        }
      "#,
          "/foo/bar/b.css": r#"
        .b {
          background: yellow;
        }
      "#
        },
      },
      "/foo/bar/a.css",
      Some("/foo/bar"),
    );
    assert_eq!(code, expected);

    let (code, _) = bundle_css_module(
      TestProvider {
        map: fs! {
          "/x/y/z/a.css": r#"
      @import "b.css";
      .a {
        background: white;
      }
    "#,
          "/x/y/z/b.css": r#"
      .b {
        background: yellow;
      }
    "#
        },
      },
      "/x/y/z/a.css",
      Some("/x/y/z"),
    );
    assert_eq!(code, expected);

    let (code, _) = bundle_css_module_with_pattern(
      TestProvider {
        map: fs! {
          "/a.css": r#"
          @import "b.css";
          .a { color: red }
        "#,
          "/b.css": r#"
          .a { color: green }
        "#
        },
      },
      "/a.css",
      None,
      "[content-hash]-[local]",
    );
    assert_eq!(
      code,
      indoc! { r#"
      .do5n2W-a {
        color: green;
      }

      .pP97eq-a {
        color: red;
      }
    "#}
    );
  }

  #[test]
  fn test_source_map() {
    let source = r#".imported {
      content: "yay, file support!";
    }

    .selector {
      margin: 1em;
      background-color: #f60;
    }

    .selector .nested {
      margin: 0.5em;
    }

    /*# sourceMappingURL=data:application/json;base64,ewoJInZlcnNpb24iOiAzLAoJInNvdXJjZVJvb3QiOiAicm9vdCIsCgkiZmlsZSI6ICJzdGRvdXQiLAoJInNvdXJjZXMiOiBbCgkJInN0ZGluIiwKCQkic2Fzcy9fdmFyaWFibGVzLnNjc3MiLAoJCSJzYXNzL19kZW1vLnNjc3MiCgldLAoJInNvdXJjZXNDb250ZW50IjogWwoJCSJAaW1wb3J0IFwiX3ZhcmlhYmxlc1wiO1xuQGltcG9ydCBcIl9kZW1vXCI7XG5cbi5zZWxlY3RvciB7XG4gIG1hcmdpbjogJHNpemU7XG4gIGJhY2tncm91bmQtY29sb3I6ICRicmFuZENvbG9yO1xuXG4gIC5uZXN0ZWQge1xuICAgIG1hcmdpbjogJHNpemUgLyAyO1xuICB9XG59IiwKCQkiJGJyYW5kQ29sb3I6ICNmNjA7XG4kc2l6ZTogMWVtOyIsCgkJIi5pbXBvcnRlZCB7XG4gIGNvbnRlbnQ6IFwieWF5LCBmaWxlIHN1cHBvcnQhXCI7XG59IgoJXSwKCSJtYXBwaW5ncyI6ICJBRUFBLFNBQVMsQ0FBQztFQUNSLE9BQU8sRUFBRSxvQkFBcUI7Q0FDL0I7O0FGQ0QsU0FBUyxDQUFDO0VBQ1IsTUFBTSxFQ0hELEdBQUc7RURJUixnQkFBZ0IsRUNMTCxJQUFJO0NEVWhCOztBQVBELFNBQVMsQ0FJUCxPQUFPLENBQUM7RUFDTixNQUFNLEVDUEgsS0FBRztDRFFQIiwKCSJuYW1lcyI6IFtdCn0= */"#;

    let fs = TestProvider {
      map: fs! {
        "/a.css": r#"
        @import "/b.css";
        .a { color: red; }
      "#,
        "/b.css": source
      },
    };

    let mut sm = parcel_sourcemap::SourceMap::new("/");
    let mut bundler = Bundler::new(&fs, Some(&mut sm), ParserOptions::default());
    let mut stylesheet = bundler.bundle(Path::new("/a.css")).unwrap();
    stylesheet.minify(MinifyOptions::default()).unwrap();
    stylesheet
      .to_css(PrinterOptions {
        source_map: Some(&mut sm),
        minify: true,
        ..PrinterOptions::default()
      })
      .unwrap();
    let map = sm.to_json(None).unwrap();
    assert_eq!(
      map,
      r#"{"version":3,"sourceRoot":null,"mappings":"ACAA,uCCGA,2CAAA,8BFDQ","sources":["a.css","sass/_demo.scss","stdin"],"sourcesContent":["\n        @import \"/b.css\";\n        .a { color: red; }\n      ",".imported {\n  content: \"yay, file support!\";\n}","@import \"_variables\";\n@import \"_demo\";\n\n.selector {\n  margin: $size;\n  background-color: $brandColor;\n\n  .nested {\n    margin: $size / 2;\n  }\n}"],"names":[]}"#
    );
  }

  #[test]
  fn test_license_comments() {
    let res = bundle(
      TestProvider {
        map: fs! {
          "/a.css": r#"
          /*! Copyright 2023 Someone awesome */
          @import "b.css";
          .a { color: red }
        "#,
          "/b.css": r#"
          /*! Copyright 2023 Someone else */
          .b { color: green }
        "#
        },
      },
      "/a.css",
    );
    assert_eq!(
      res,
      indoc! { r#"
      /*! Copyright 2023 Someone awesome */
      /*! Copyright 2023 Someone else */
      .b {
        color: green;
      }

      .a {
        color: red;
      }
    "#}
    );
  }
}