# frozen_string_literal: true

require_relative "hot_module/version"

require "nokolexbor"
require "concurrent"

# Include this module into your own component class
module HoTModuLe
  class Error < StandardError; end

  module JSTemplateLiterals
    refine Kernel do
      def `(str)
        str
      end
    end
  end

  using JSTemplateLiterals

  AttributeBinding = Struct.new(:matcher, :method_name, :method, :only_for_tag, keyword_init: true) # rubocop:disable Lint/StructNewOverride

  require_relative "hot_module/fragment"
  require_relative "hot_module/query_selection"

  def self.registered_elements
    @registered_elements ||= Concurrent::Set.new

    @registered_elements.each do |component|
      begin
        next if Kernel.const_get(component.to_s) == component # thin out unloaded consts
      rescue NameError; end # rubocop:disable Lint/SuppressedException

      @registered_elements.delete component
    end

    @registered_elements
  end

  # @param klass [Class]
  # @return [void]
  def self.included(klass)
    klass.extend ClassMethods

    klass.attribute_binding "hmod:children", :_hmod_children_binding, only: :template
    klass.attribute_binding "hmod:replace", :_hmod_replace_binding
    klass.attribute_binding "hmod:text", :_hmod_expr_binding
    klass.attribute_binding "hmod:html", :_hmod_expr_binding

    # Don't stomp on a superclass's `content` method
    return if klass.instance_methods.include?(:content)

    klass.include ContentMethod
  end

  # Extends the component class
  module ClassMethods
    def camelcased(method_symbols)
      Array(method_symbols).each do |method_symbol|
        alias_method(method_symbol.to_s.gsub(/(?!^)_[a-z0-9]/) { |match| match[1].upcase }, method_symbol)
      end
    end

    def html_file_extensions = %w[module.html mod.html html].freeze

    def processed_css_extension = "css-local"

    # @param tag_name [String]
    # @param html_module [String] if not provided, a class method called `source_location` must be
    #   available with the absolute path of the Ruby file
    # @param shadow_root [Boolean] default is true
    # @return [void]
    def custom_element(tag_name, html_module = nil, shadow_root: true) # rubocop:disable Metrics/AbcSize
      if html_module.nil? && !respond_to?(:source_location)
        raise HoTModuLe::Error, "You must either supply a file path argument or respond to `source_location'"
      end

      self.tag_name tag_name

      if html_module
        self.html_module html_module
      else
        basepath = File.join(File.dirname(source_location), File.basename(source_location, ".*"))

        self.html_module(html_file_extensions.lazy.filter_map do |ext|
          path = "#{basepath}.#{ext}"
          File.exist?(path) ? path : nil
        end.first)

        raise HoTModuLe::Error, "Cannot find sidecar HTML module for `#{self}'" unless @html_module
      end

      self.shadow_root shadow_root
    end

    # @param value [String]
    # @return [String]
    def tag_name(value = nil)
      @tag_name ||= begin
        HoTModuLe.registered_elements << self
        value
      end
    end

    # @param value [String]
    # @return [String]
    def html_module(value = nil) = @html_module ||= value

    # @param value [Boolean]
    # @return [Boolean]
    def shadow_root(value = nil) = @shadow_root ||= value

    # @return [Nokolexbor::Element]
    def doc
      @doc ||= begin
        @doc_html = "<#{tag_name}>#{File.read(html_module).strip}</#{tag_name}>"
        Nokolexbor::DocumentFragment.parse(@doc_html).first_element_child
      end
    end

    def line_number_of_node(node)
      loc = node.source_location
      instance_variable_get(:@doc_html)[0..loc].count("\n") + 1
    end

    def attribute_bindings = @attribute_bindings ||= []

    def attribute_binding(matcher, method_name, only: nil)
      attribute_bindings << AttributeBinding.new(
        matcher: Regexp.new(matcher),
        method_name: method_name,
        only_for_tag: only
      )
    end
  end

  module ContentMethod
    # @return [String, Nokolexbor::Element]
    def content = @_content
  end

  # Override in component
  #
  # @return [Hash]
  def attributes = {}

  # @param attributes [Hash]
  # @param content [String, Nokolexbor::Element]
  # @param return_node [Boolean]
  def render_element(attributes: self.attributes, content: self.content, return_node: false) # rubocop:disable Metrics
    doc = self.class.doc.clone
    @_content = content

    tmpl_el = doc.css("> template").find { _1.attributes.empty? }

    unless tmpl_el
      tmpl_el = doc.document.create_element("template")
      immediate_children = doc.css("> :not(style):not(script)")
      tmpl_el.children[0] << immediate_children
      doc.prepend_child(tmpl_el)
    end

    # Process all the template bits
    process_fragment(tmpl_el)

    HoTModuLe.registered_elements.each do |component|
      tmpl_el.children[0].css(component.tag_name).reverse.each do |node|
        if node["hmod:ignore"]
          node.attribute("hmod:ignore").remove
          next
        end

        attrs = node.attributes.transform_values(&:value)
        attrs.reject! { |k| k.start_with?("hmod:") }
        new_attrs = {}
        attrs.each do |k, v|
          next unless k.start_with?("arg:")

          new_key = k.delete_prefix("arg:")
          attrs.delete(k)
          new_attrs[new_key] = instance_eval(v, self.class.html_module, self.class.line_number_of_node(node))
        end
        attrs.merge!(new_attrs)
        attrs.transform_keys!(&:to_sym)

        new_node = node.replace(
          component.new(**attrs).render_element(content: node.children)
        )
        new_node.first.attribute("hmod:ignore")&.remove
      end
    end

    # Set attributes on the custom element
    attributes.each { |k, v| doc[k.to_s.tr("_", "-")] = value_to_attribute(v) if v }

    # Look for external and internal styles
    output_styles = ""
    external_styles = doc.css("link[rel=stylesheet]")
    external_styles.each do |external_style|
      next unless external_style["hmod:process"]

      output_styles += File.read(File.expand_path(external_style["href"], File.dirname(self.class.html_module)))
      external_style.remove
    rescue StandardError => e
      raise e.class, e.message.lines.first,
            ["#{self.class.html_module}:#{external_style.line}", *e.backtrace]
    end
    sidecar_file = "#{File.join(
      File.dirname(self.class.html_module), File.basename(self.class.html_module, ".*")
    )}.#{self.class.processed_css_extension}"
    output_styles += if File.exist?(sidecar_file)
                       File.read(sidecar_file)
                     else
                       doc.css("> style:not([scope])").map(&:content).join
                     end

    # Now remove all nodes *except* the template
    doc.children.each do |node|
      node.remove unless node == tmpl_el
    end

    style_tag = nil
    if output_styles.length.positive?
      # We'll transfer everything over to a single style element
      style_tag = tmpl_el.document.create_element("style")
      style_tag.content = output_styles
    end

    child_content = @_replaced_children || content
    if self.class.shadow_root
      # Guess what? We can reuse the same template tag! =)
      tmpl_el["shadowrootmode"] = "open"
      tmpl_el.children[0] << style_tag if style_tag
      doc << child_content if child_content
    else
      tmpl_el.children[0] << style_tag if style_tag
      tmpl_el.children[0].at_css("slot:not([name])")&.swap(child_content) if child_content
      tmpl_el.children[0].children.each do |node|
        doc << node
      end
      tmpl_el.remove
    end

    # And that is that.
    return_node ? doc : doc.to_html
  end

  def call(...) = render_element(...)

  def inspect = "#<#{self.class.name} #{attributes}>"

  def value_to_attribute(val)
    case val
    when String, Numeric
      val
    when TrueClass
      ""
    else
      val.to_json
    end
  end

  def node_or_string(val)
    val.is_a?(Nokolexbor::Node) ? val : val.to_s
  end

  # Override in component if need be, otherwise we'll use the node walker/binding pipeline
  #
  # @param fragment [Nokolexbor::Element]
  # @return [void]
  def process_fragment(fragment) = Fragment.new(fragment, self).process

  def process_list(attribute:, node:, item_node:, for_in:) # rubocop:disable Metrics
    _context_nodes.push(node)

    lh = for_in[0].strip.delete_prefix("(").delete_suffix(")").split(",").map!(&:strip)
    rh = for_in[1].strip

    list_items = evaluate_attribute_expression(attribute, rh)

    # TODO: handle object style
    # https://vuejs.org/guide/essentials/list.html#v-for-with-an-object

    return unless list_items

    _in_context_nodes do |previous_context|
      list_items.each_with_index do |list_item, index|
        new_node = item_node.clone
        node.parent << new_node
        new_node["hmod-added"] = ""

        @_context_locals = { **(previous_context || {}) }
        _context_locals[lh[0]] = list_item
        _context_locals[lh[1]] = index if lh[1]

        Fragment.new(new_node, self).process
      end
    end
  end

  def evaluate_attribute_expression(attribute, eval_code = attribute.value)
    eval_code = eval_code.gsub(/\${(.*)}/, "\#{\\1}")
    _context_locals.keys.reverse_each do |name|
      eval_code = "#{name} = _context_locals[\"#{name}\"];" + eval_code
    end
    instance_eval(eval_code, self.class.html_module, self.class.line_number_of_node(attribute))
  end

  def class_list_for(obj)
    case obj
    when Hash
      obj.filter { |_k, v| v }.keys
    when Array
      # TODO: handle objects inside of an array?
      obj
    else
      Array[obj]
    end.join(" ")
  end

  def _context_nodes = @_context_nodes ||= []

  def _context_locals = @_context_locals ||= {}

  def _check_stack(node)
    node_and_ancestors = [node, *node.ancestors.to_a]
    stack_misses = 0

    _context_nodes.each do |stack_node|
      if node_and_ancestors.none? { _1["hmod-added"] } && node_and_ancestors.none? { _1 == stack_node }
        stack_misses += 1
      end
    end

    stack_misses.times { _context_nodes.pop }

    node_and_ancestors.any? { _context_nodes.include?(_1) }
  end

  def _in_context_nodes
    previous_context = _context_locals
    yield previous_context
    @_context_locals = previous_context
  end

  def _hmod_children_binding(attribute:, node:) # rubocop:disable Lint/UnusedMethodArgument
    @_replaced_children = node.children[0]
    node.remove
  end

  def _hmod_replace_binding(attribute:, node:)
    if node.name == "template"
      node.children[0].inner_html = node_or_string(evaluate_attribute_expression(attribute))
      node.replace(node.children[0].children)
    else
      node.inner_html = node_or_string(evaluate_attribute_expression(attribute))
      node.replace(node.children)
    end
  end

  def _hmod_expr_binding(attribute:, node:)
    if attribute.name.end_with?(":text")
      node.content = node_or_string(evaluate_attribute_expression(attribute))
      attribute.parent.delete(attribute.name)
    elsif attribute.name.end_with?(":html")
      node.inner_html = node_or_string(evaluate_attribute_expression(attribute))
      attribute.parent.delete(attribute.name)
    end
  end
end

if defined?(Bridgetown)
  Bridgetown.initializer :hot_module do |config|
    Bridgetown::Component.extend ActiveSupport::DescendantsTracker

    HoTModuLe.module_eval do
      def render_in(*)
        @attributes&.[]=("hmod:ignore", "")
        super
      end
    end

    # Eager load all components
    config.hook :site, :after_reset do |site|
      unless site.config.eager_load_paths.find { _1.end_with?(site.config.components_dir) }
        site.config.eager_load_paths << site.config.autoload_paths.find { _1.end_with?(site.config.components_dir) }
      end
    end

    require_relative "hot_module/component_renderer"
    config.builder HoTModuLe::ComponentRenderer
  end
end

HotModule = HoTModuLe # alias for people who are annoyed :)