require "fileutils"
require "pathname"
require "tempfile"

require "archive/tar/minitar"
require "log4r"

require "vagrant/util/platform"

require "support/isolated_environment"
require "support/tempdir"

module Unit
  class IsolatedEnvironment < ::IsolatedEnvironment
    def create_vagrant_env(options=nil)
      options = {
        :cwd => @workdir,
        :home_path => @homedir
      }.merge(options || {})

      Vagrant::Environment.new(options)
    end

    # This creates a file in the isolated environment. By default this file
    # will be created in the working directory of the isolated environment.
    def file(name, contents)
      @workdir.join(name).open("w+") do |f|
        f.write(contents)
      end
    end

    def vagrantfile(contents, root=nil)
      root ||= @workdir
      root.join("Vagrantfile").open("w+") do |f|
        f.write(contents)
      end
    end

    def box(name, vagrantfile_contents="")
      # Create the box directory
      box_dir = boxes_dir.join(name)
      box_dir.mkpath

      # Create the "box.ovf" file because that is how Vagrant heuristically
      # determines a box is a V1 box.
      box_dir.join("box.ovf").open("w") { |f| f.write("") }

      # Populate the vagrantfile
      vagrantfile(vagrantfile_contents, box_dir)

      # Return the directory
      box_dir
    end

    # Create an alias because "box" makes a V1 box, so "box1"
    alias :box1 :box

    # Creates a fake box to exist in this environment.
    #
    # @param [String] name Name of the box
    # @param [Symbol] provider Provider the box was built for.
    # @return [Pathname] Path to the box directory.
    def box2(name, provider, options=nil)
      # Default options
      options = {
        :vagrantfile => ""
      }.merge(options || {})

      # Make the box directory
      box_dir = boxes_dir.join(name, provider.to_s)
      box_dir.mkpath

      # Create a metadata.json file
      box_metadata_file = box_dir.join("metadata.json")
      box_metadata_file.open("w") do |f|
        f.write("{}")
      end

      # Create a Vagrantfile
      box_vagrantfile = box_dir.join("Vagrantfile")
      box_vagrantfile.open("w") do |f|
        f.write(options[:vagrantfile])
      end

      # Return the box directory
      box_dir
    end

    # This creates a "box" file with the given provider.
    #
    # @param [Symbol] provider Provider for the box.
    # @return [Pathname] Path to the newly created box.
    def box2_file(provider)
      # This is the metadata we want to store in our file
      metadata = {
        "type"     => "v2_box",
        "provider" => provider
      }

      # Create a temporary directory to store our data we will tar up
      td_source = Tempdir.new
      td_dest   = Tempdir.new

      # Store the temporary directory so it is not deleted until
      # this instance is garbage collected.
      @_box2_file_temp ||= []
      @_box2_file_temp << td_dest

      # The source as a Pathname, which is easier to work with
      source = Pathname.new(td_source.path)

      # The destination file
      result = Pathname.new(td_dest.path).join("temporary.box")

      File.open(result, Vagrant::Util::Platform.tar_file_options) do |tar|
        Archive::Tar::Minitar::Output.open(tar) do |output|
          begin
            # Switch to the source directory so that Archive::Tar::Minitar
            # can tar things up.
            current_dir = FileUtils.pwd
            FileUtils.cd(source)

            # Put the metadata.json in here.
            source.join("metadata.json").open("w") do |f|
              f.write(JSON.generate(metadata))
            end

            # Add all the files
            Dir.glob(File.join(".", "**", "*")).each do |entry|
              Archive::Tar::Minitar.pack_file(entry, output)
            end
          ensure
            FileUtils.cd(current_dir)
          end
        end
      end

      # Resulting box
      result
    end

    def boxes_dir
      dir = @homedir.join("boxes")
      dir.mkpath
      dir
    end
  end
end