require 'sfn'

module Sfn
  class Command
    # Export command
    class Export < Command
      include Sfn::CommandModule::Base
      include Sfn::Utils::ObjectStorage

      # Run export action
      def execute!
        raise NotImplementedError.new 'Implementation updates required'
        stack_name = name_args.first
        ui.info "#{ui.color('Stack Export:', :bold)} #{stack_name}"
        ui.confirm 'Perform export'
        stack = provider.stacks.get(stack_name)
        if stack
          export_options = Smash.new.tap do |opts|
            [:chef_popsicle, :chef_environment_parameter, :ignore_parameters].each do |key|
              opts[key] = config[key] unless config[key].nil?
            end
          end
          exporter = Sfn::Utils::StackExporter.new(stack, export_options)
          result = exporter.export
          outputs = [
            write_to_file(result, stack),
            write_to_bucket(result, stack),
          ].compact
          if outputs.empty?
            ui.warn 'No persistent output location defined. Printing export:'
            ui.info _format_json(result)
          end
          ui.info "#{ui.color('Stack export', :bold)} (#{name_args.first}): #{ui.color('complete', :green)}"
          unless outputs.empty?
            outputs.each do |output|
              ui.info ui.color("  -> #{output}", :blue)
            end
          end
        else
          ui.fatal "Failed to discover requested stack: #{ui.color(stack_name, :red, :bold)}"
          exit -1
        end
      end

      # Generate file name for stack export JSON contents
      #
      # @param stack [Miasma::Models::Orchestration::Stack]
      # @return [String] file name
      def export_file_name(stack)
        name = config[:file]
        if name
          if name.respond_to?(:call)
            name.call(stack)
          else
            name.to_s
          end
        else
          "#{stack.stack_name}-#{Time.now.to_i}.json"
        end
      end

      # Write stack export to local file
      #
      # @param payload [Hash] stack export payload
      # @param stack [Misama::Stack::Orchestration::Stack]
      # @return [String, NilClass] path to file
      def write_to_file(payload, stack)
        raise NotImplementedError
        if config[:path]
          full_path = File.join(
            config[:path],
            export_file_name(stack)
          )
          _, bucket, path = full_path.split('/', 3)
          directory = provider.service_for(:storage,
                                           :provider => :local,
                                           :local_root => '/').directories.get(bucket)
          file_store(payload, path, directory)
        end
      end

      # Write stack export to remote bucket
      #
      # @param payload [Hash] stack export payload
      # @param stack [Miasma::Models::Orchestration::Stack]
      # @return [String, NilClass] remote bucket key
      def write_to_bucket(payload, stack)
        raise NotImplementedError
        if bucket = config[:bucket]
          key_path = File.join(*[
            bucket_prefix(stack),
            export_file_name(stack),
          ].compact)
          file_store(payload, key_path, provider.service_for(:storage).directories.get(bucket))
        end
      end
    end
  end
end