module Hyperstack
  module Internal
    module Component
      class RenderingContext
        class NotQuiet < Exception; end
        class << self
          attr_accessor :waiting_on_resources

          def raise_if_not_quiet?
            @raise_if_not_quiet
          end

          def raise_if_not_quiet=(x)
            @raise_if_not_quiet = x
          end

          def quiet_test(component)
            return unless component.waiting_on_resources && raise_if_not_quiet? #&& component.class != RescueMetaWrapper <- WHY  can't create a spec that this fails without this, but several fail with it.
            raise NotQuiet.new("#{component} is waiting on resources")
          end

          def render_string(string)
            @buffer ||= []
            @buffer << string
          end

          def render(name, *args, &block)
            was_outer_most = !@not_outer_most
            @not_outer_most = true
            remove_nodes_from_args(args)
            @buffer ||= [] #unless @buffer
            if block
              element = build do
                saved_waiting_on_resources = nil #waiting_on_resources  what was the purpose of this its used below to or in with the current elements waiting_for_resources
                self.waiting_on_resources = nil
                run_child_block(&block)
                if name
                  buffer = @buffer.dup
                  ReactWrapper.create_element(name, *args) { buffer }.tap do |element|
                    element.waiting_on_resources = saved_waiting_on_resources || !!buffer.detect { |e| e.waiting_on_resources if e.respond_to?(:waiting_on_resources) }
                    element.waiting_on_resources ||= waiting_on_resources if buffer.last.is_a?(String)
                  end
                else
                  buffer = @buffer.collect do |item|
                    if item.is_a? Hyperstack::Component::Element
                      item.waiting_on_resources ||= saved_waiting_on_resources
                      item
                    else
                      RenderingContext.render(:span) { item.to_s }.tap { |element| element.waiting_on_resources = saved_waiting_on_resources }
                    end
                  end
                  if buffer.length > 1
                    buffer
                  else
                    buffer.first
                  end
                end
              end
            elsif name.is_a? Hyperstack::Component::Element
              element = name
            else
              element = ReactWrapper.create_element(name, *args)
              element.waiting_on_resources = waiting_on_resources
            end
            @buffer << element
            self.waiting_on_resources = nil
            element
          ensure
            @not_outer_most = @buffer = nil if was_outer_most
          end

          def build
            current = @buffer
            @buffer = []
            return_val = yield @buffer
            @buffer = current
            return_val
          end

          def delete(element)
            @buffer.delete(element)
            @last_deleted = element
            element
          end
          alias as_node delete

          def rendered?(element)
            @buffer.include? element
          end

          def replace(e1, e2)
            @buffer[@buffer.index(e1)] = e2
          end

          def remove_nodes_from_args(args)
            args[0].each do |key, value|
              begin
                value.delete if value.is_a?(Hyperstack::Component::Element) # deletes Element from buffer
              rescue Exception
              end
            end if args[0] && args[0].is_a?(Hash)
          end

          # run_child_block yields to the child rendering block which will put any
          # elements to be rendered into the current rendering buffer.
          #
          # for example when rendering this div: div { "hello".span; "goodby".span }
          # two child Elements will be generated.
          #
          # However the block itself will return a value, which in some cases should
          # also added to the buffer:
          #
          # If the final value of the block is a
          #
          #   a hyper model dummy value that is being loaded, then wrap it in a span and add it to the buffer
          #   a string (or if the buffer is empty any value), then add it to the buffer
          #   an Element, then add it on the buffer unless it has been just deleted
          #          #
          # Note that the reason we don't always allow Strings to be automatically pushed is
          # to avoid confusing results in situations like this:
          #   DIV { collection.each { |item| SPAN { item } } }
          # If we accepted any object to be rendered this would generate:
          #   DIV { SPAN { collection[0] } SPAN { collection[n] } collection.to_s }
          # which is probably not the desired output.  If it was you would just append to_s
          # to the end of the expression, to force it to be added to the output buffer.
          #
          # However if the buffer is empty then it makes sense to automatically apply the `.to_s`
          # to the value, and push it on the buffer, unless it is a falsy value or an array

          def run_child_block
            result = yield
            check_for_component_return(result)
            if dummy_value?(result)
              # hyper-mesh DummyValues must
              # be converted to spans INSIDE the parent, otherwise the waiting_on_resources
              # flag will get set in the wrong context
              RenderingContext.render(:span) { result.to_s }
            elsif result.is_a?(Hyperstack::Component::Element)
              @buffer << result if @buffer.empty? unless @last_deleted == result
            elsif pushable_string?(result)
              @buffer << result.to_s
            end
            @last_deleted = nil
          end

          def check_for_component_return(result)
            # check for a common error of saying (for example) DIV (without parens)
            # which returns the DIV component class instead of a rendered DIV
            return unless result.try :hyper_component?

            Hyperstack::Component::IsomorphicHelpers.log(
              "a component's render method returned the component class #{result}, did you mean to say #{result}()",
              :warning
            )
          end

          def dummy_value?(result)
            result.respond_to?(:loading?) && result.loading?
          end

          def pushable_string?(result)
            # if the buffer is not empty we will only push on strings, and ignore anything else
            return result.is_a?(String) unless @buffer.empty?

            # if the buffer IS empty then we can push on anything except we avoid nil, false and arrays
            # as these are almost never what you want to render, and if you do there are mechanisms
            # to render them explicitly
            result && result.respond_to?(:to_n) && !result.is_a?(Array)
          end

          def improper_render(message, solution)
          end
        end
      end
    end
  end
end

class Object
  %i[span td th].each do |tag|
    define_method(tag) do |*args, &block|
      args.unshift(tag)
      # legacy hyperloop allowed tags to be lower case as well so if self is a component
      # then this is just a DSL method for example:
      # render(:div) do
      #   span { 'foo' }
      # end
      # in this case self is just the component being rendered, so span is just a method
      # in the component.
      # If we fully deprecate lowercase tags, then this next line can go...
      return send(*args, &block) if respond_to?(:hyper_component?) && hyper_component?

      Hyperstack::Internal::Component::RenderingContext.render(*args) { to_s }
    end
  end

  def para(*args, &block)
    args.unshift(:p)
    # see above comment
    return send(*args, &block) if respond_to?(:hyper_component?) && hyper_component?

    Hyperstack::Internal::Component::RenderingContext.render(*args) { to_s }
  end

  def br
    # see above comment
    return send(:br) if respond_to?(:hyper_component?) && hyper_component?
    
    Hyperstack::Internal::Component::RenderingContext.render(Hyperstack::Internal::Component::Tags::FRAGMENT) do
      Hyperstack::Internal::Component::RenderingContext.render(Hyperstack::Internal::Component::Tags::FRAGMENT) { to_s }
      Hyperstack::Internal::Component::RenderingContext.render(Hyperstack::Internal::Component::Tags::BR)
    end
  end

end