class Berkshelf::Berksfile

def [](name)
  @dependencies[name]
end

def add_dependency(name, constraint = nil, options = {})
  if @dependencies[name]
    # Only raise an exception if the dependency is a true duplicate
    groups = (options[:group].nil? || options[:group].empty?) ? [:default] : options[:group]
    unless (@dependencies[name].groups & groups).empty?
      raise DuplicateDependencyDefined.new(name)
    end
  end
  # this appears to be dead code
  # if options[:path]
  #  metadata_file = File.join(options[:path], "metadata.rb")
  # end
  options[:constraint] = constraint
  @dependencies[name] = Dependency.new(self, name, options)
end

def cookbook(*args)
  options = args.last.is_a?(Hash) ? args.pop : {}
  name, constraint = args
  options[:path] &&= File.expand_path(options[:path], File.dirname(filepath))
  options[:group] = Array(options[:group])
  if @active_group
    options[:group] += @active_group
  end
  add_dependency(name, constraint, **options)
end

def cookbooks
  dependencies.map { |dependency| retrieve_locked(dependency) }
end

def dependencies
  @dependencies.values.sort.select(&@filter)
end

def extension(name)
  require "berkshelf/#{name}"
  true
rescue LoadError
  raise LoadError, "Could not load an extension by the name `#{name}'. " \
    "Please make sure it is installed."
end

def find(name)
  @dependencies[name]
end

def find_chefignore(path)
  filename = "chefignore"
  Pathname.new(path).ascend do |dir|
    next unless dir.directory?
    [
      dir.join(filename),
      dir.join("cookbooks", filename),
      dir.join(".chef",     filename),
    ].each do |possible|
      return possible.expand_path.to_s if possible.exist?
    end
  end
  nil
end

def from_file(file, options = {})
  raise BerksfileNotFound.new(file) unless File.exist?(file)
  begin
    new(file, options).evaluate_file(file)
  rescue => ex
    raise BerksfileReadError.new(ex)
  end
end

def from_options(options = {})
  options[:berksfile] ||= File.join(Dir.pwd, Berkshelf::DEFAULT_FILENAME)
  symbolized = Hash[options.map { |k, v| [k.to_sym, v] }]
  from_file(options[:berksfile], symbolized.select { |k,| %i{except only delete}.include? k })
end

def group(*args)
  @active_group = args
  yield
  @active_group = nil
end

def groups
  {}.tap do |groups|
    dependencies.each do |dependency|
      dependency.groups.each do |group|
        groups[group] ||= []
        groups[group] << dependency
      end
    end
  end
end

def has_dependency?(dependency)
  name = Dependency.name(dependency)
  dependencies.map(&:name).include?(name)
end

def initialize(path, options = {})
  @filepath         = File.expand_path(path)
  @dependencies     = {}
  @sources          = {}
  @delete           = options[:delete]
  # defaults for what solvers to use
  @required_solver  = nil
  @preferred_solver = :gecode
  if options[:except] && options[:only]
    raise ArgumentError, "Cannot specify both :except and :only!"
  elsif options[:except]
    except = Array(options[:except]).collect(&:to_sym)
    @filter = ->(dependency) { (except & dependency.groups).empty? }
  elsif options[:only]
    only = Array(options[:only]).collect(&:to_sym)
    @filter = ->(dependency) { !(only & dependency.groups).empty? }
  else
    @filter = ->(dependency) { true }
  end
end

def install
  Installer.new(self).run
end

def list
  validate_lockfile_present!
  validate_lockfile_trusted!
  validate_dependencies_installed!
  lockfile.graph.locks.values
end

def lockfile
  @lockfile ||= Lockfile.from_berksfile(self)
end

def metadata(options = {})
  path = options[:path] || File.dirname(filepath)
  loader = Chef::Cookbook::CookbookVersionLoader.new(path)
  loader.load!
  cookbook_version = loader.cookbook_version
  metadata = cookbook_version.metadata
  add_dependency(metadata.name, nil, path: path, metadata: true)
end

def outdated(*names, include_non_satisfying: false)
  validate_lockfile_present!
  validate_lockfile_trusted!
  validate_dependencies_installed!
  validate_cookbook_names!(names)
  lockfile.graph.locks.inject({}) do |hash, (name, dependency)|
    sources.each do |source|
      cookbooks = source.versions(name)
      latest = cookbooks.select do |cookbook|
        (include_non_satisfying || dependency.version_constraint.satisfies?(cookbook.version)) &&
          Semverse::Version.coerce(cookbook.version) > dependency.locked_version
      end.max_by(&:version)
      unless latest.nil?
        hash[name] ||= {
          "local" => dependency.locked_version,
          "remote" => {
            source => Semverse::Version.coerce(latest.version),
          },
        }
      end
    end
    hash
  end
end

def package(path)
  packager = Packager.new(path)
  packager.validate!
  outdir = Dir.mktmpdir do |temp_dir|
    Berkshelf.ui.mute { vendor(File.join(temp_dir, "cookbooks")) }
    packager.run(temp_dir)
  end
  Berkshelf.formatter.package(outdir)
  outdir
end

def retrieve_locked(dependency)
  lockfile.retrieve(dependency)
end

def solver(name, precedence = :preferred)
  if name && precedence == :required
    @required_solver = name
  elsif name && precedence == :preferred
    @preferred_solver = name
  else
    raise ArgumentError, "Invalid solver precedence ':#{precedence}'"
  end
end

def source(api_url, **options)
  source = Source.new(self, api_url, **options)
  @sources[source.uri.to_s] = source
end

def source_for(name, version)
  sources.find { |source| source.cookbook(name, version) }
end

def sources
  if @sources.empty?
    raise NoAPISourcesDefined
  else
    @sources.values
  end
end

def update(*names)
  validate_lockfile_present!
  validate_cookbook_names!(names)
  Berkshelf.log.info "Updating cookbooks"
  # Calculate the list of cookbooks to unlock
  if names.empty?
    Berkshelf.log.debug "  Unlocking all the things!"
    lockfile.unlock_all
  else
    names.each do |name|
      Berkshelf.log.debug "  Unlocking #{name}"
      lockfile.unlock(name, true)
    end
  end
  # NOTE: We intentionally do NOT pass options to the installer
  install
end

def upload(*args)
  validate_lockfile_present!
  validate_lockfile_trusted!
  validate_dependencies_installed!
  Uploader.new(self, *args).run
end

def validate_cookbook_names!(names)
  missing = names - lockfile.graph.locks.keys
  unless missing.empty?
    raise DependencyNotFound.new(missing)
  end
end

def validate_dependencies_installed!
  lockfile.graph.locks.each do |_, dependency|
    unless dependency.installed?
      raise DependencyNotInstalled.new(dependency)
    end
  end
  true
end

def validate_lockfile_present!
  raise LockfileNotFound unless lockfile.present?
  true
end

def validate_lockfile_trusted!
  raise LockfileOutOfSync unless lockfile.trusted?
  true
end

def vendor(destination)
  Dir.mktmpdir("vendor") do |scratch|
    cached_cookbooks = install
    return nil if cached_cookbooks.empty?
    cached_cookbooks.each do |cookbook|
      Berkshelf.formatter.vendor(cookbook, destination)
      cookbook_destination = File.join(scratch, cookbook.cookbook_name)
      FileUtils.mkdir_p(cookbook_destination)
      # Dir.glob does not support backslash as a File separator
      src   = cookbook.path.to_s.tr("\\", "/")
      files = FileSyncer.glob(File.join(src, "**/*"))
      # strip directories
      files.reject! { |file_path| File.directory?(file_path) }
      # convert to relative Pathname objects for chefignore
      files.map! { |file_path| Chef::Util::PathHelper.relative_path_from(cookbook.path.to_s, file_path) }
      chefignore = Chef::Cookbook::Chefignore.new(find_chefignore(cookbook.path.to_s) || cookbook.path.to_s)
      # apply chefignore
      files.reject! { |file_path| chefignore.ignored?(file_path) }
      # convert Pathname objects back to strings
      files.map!(&:to_s)
      # copy each file to destination
      files.each do |rpath|
        FileUtils.mkdir_p( File.join(cookbook_destination, File.dirname(rpath)) )
        FileUtils.cp( File.join(cookbook.path.to_s, rpath), File.join(cookbook_destination, rpath) )
      end
      cookbook.compile_metadata(cookbook_destination)
    end
    # Don't vendor the raw metadata (metadata.rb). The raw metadata is
    # unecessary for the client, and this is required until compiled metadata
    # (metadata.json) takes precedence over raw metadata in the Chef-Client.
    #
    # We can change back to including the raw metadata in the future after
    # this has been fixed or just remove these comments. There is no
    # circumstance that I can currently think of where raw metadata should
    # ever be read by the client.
    #
    # - Jamie
    #
    # See the following tickets for more information:
    #
    #   * https://tickets.opscode.com/browse/CHEF-4811
    #   * https://tickets.opscode.com/browse/CHEF-4810
    FileSyncer.sync(scratch, destination, exclude: EXCLUDED_VCS_FILES_WHEN_VENDORING, delete: @delete)
  end
  destination
end

def verify
  validate_lockfile_present!
  validate_lockfile_trusted!
  Berkshelf.formatter.msg "Verifying (#{lockfile.cached.length}) cookbook(s)..."
  Validator.validate(lockfile.cached)
  true
end

def viz(outfile = nil, format = "png")
  outfile = File.join(Dir.pwd, outfile || "graph.png")
  validate_lockfile_present!
  validate_lockfile_trusted!
  vizualiser = Visualizer.from_lockfile(lockfile)
  case format
  when "dot"
    vizualiser.to_dot_file(outfile)
  when "png"
    vizualiser.to_png(outfile)
  else
    raise ConfigurationError, "Vizualiser format #{format} not recognised."
  end
end