require 'sfn'

module Sfn
  module MonkeyPatch
    module Stack
      # Google specific monkey patch implementations
      module Google

        # Helper module to allow nested stack behavior to function as expected
        # internally within sfn
        module PretendStack

          # disable reload
          def reload
            self
          end

          # disable template load
          def perform_template_load
            Smash.new
          end

          # only show resources associated to this stack
          def resources
            collection = Miasma::Models::Orchestration::Stack::Resources.new(self)
            collection.define_singleton_method(:perform_population) do
              valid = stack.sparkleish_template.fetch(:resources, {}).keys
              stack.custom[:resources].find_all{|r| valid.include?(r[:name])}.map do |attrs|
                Miasma::Models::Orchestration::Stack::Resource.new(stack, attrs).valid_state
              end
            end
            collection
          end

          # Sub-stacks never provide events
          def events
            collection = Miasma::Models::Orchestration::Stack::Events.new(self)
            collection.define_singleton_method(:perform_population){ [] }
            collection
          end
        end

        # Return all stacks contained within this stack
        #
        # @param recurse [TrueClass, FalseClass] recurse to fetch _all_ stacks
        # @return [Array<Miasma::Models::Orchestration::Stack>]
        def nested_stacks_google(recurse=true)
          my_template = sparkleish_template
          if(my_template[:resources][name])
            my_template = my_template.get(:resources, name, :properties, :stack)
          end
          n_stacks = my_template[:resources].map do |s_name, content|
            if(content[:type] == 'sparkleformation.stack')
              n_stack = self.class.new(api)
              n_stack.extend PretendStack
              n_layout = custom.fetch(:layout, {}).fetch(:resources, []).detect{|r| r[:name] == name}
              n_layout = (n_layout || custom.fetch(:layout, {})).fetch(:resources, []).detect{|r| r[:name] == s_name} || Smash.new
              n_stack.load_data(
                :name => s_name,
                :id => s_name,
                :template => content.get(:properties, :stack),
                :outputs => n_layout.fetch('outputs', []).map{|o_val| Smash.new(:key => o_val[:name], :value => o_val['finalValue'])},
                :custom => {
                  :resources => resources.all.map(&:attributes),
                  :layout => n_layout
                }
              ).valid_state
              n_stack.data[:logical_id] = s_name
              n_stack.data[:parent_stack] = self
              n_stack
            end
          end.compact
          if(recurse)
            (n_stacks + n_stacks.map(&:nested_stacks)).flatten.compact
          else
            n_stacks
          end
        end

        # @return [Hash] restructured google template
        def sparkleish_template_google(*args)
          copy_template = template.to_smash
          deref = lambda do |template|
            result = template.to_smash
            (result.delete(:resources) || []).each do |t_resource|
              t_name = t_resource.delete(:name)
              if(t_resource[:type].to_s.end_with?('.jinja'))
                schema = copy_template.fetch(:config, :content, :imports, []).delete("#{t_resource[:type]}.schema")
                schema_content = copy_template.fetch(:imports, []).detect do |s_item|
                  s_item[:name] == schema
                end
                if(schema_content)
                  t_resource.set(:parameters, schema_content.get(:content, :properties))
                end
                n_template = copy_template.fetch(:imports, []).detect do |s_item|
                  s_item[:name] == t_resource[:type]
                end
                if(n_template)
                  t_resource[:type] = 'sparkleformation.stack'
                  current_properties = t_resource.delete(:properties)
                  t_resource.set(:properties, :parameters, current_properties) if current_properties
                  t_resource.set(:properties, :stack, deref.call(n_template[:content]))
                end
              end
              result.set(:resources, t_name, t_resource)
            end
            result
          end
          s_template = deref.call(Smash.new(:resources => copy_template.get(:config, :content, :resources)))
          if(s_template.empty?)
            template.to_smash
          else
            layout = custom.fetch(:layout, {}).to_smash
            (layout.delete(:resources) || []).each do |l_resource|
              layout.set(:resources, l_resource.delete(:name), l_resource)
            end
            args.include?(:remove_wrapper) ? s_template.get(:resources, name, :properties, :stack) : s_template
          end
        end

        # @return [Hash]
        def root_parameters_google
          sparkleish_template.fetch(:resources, name, :properties, :parameters, Smash.new)
        end

      end
    end
  end
end