# frozen_string_literal: true

require_relative "hot_module/version"

require "nokolexbor"

# 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"

  # @param klass [Class]
  # @return [void]
  def self.included(klass)
    klass.extend ClassMethods
    # 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 tmpl.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

      @tag_name = tag_name

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

        @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

      @shadow_root = shadow_root
    end

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

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

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

    # @return [Nokogiri::XML::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 ||= []
    end

    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, Nokogiri::XML::Element]
    def content; end
  end

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

  # @param attributes [Hash]
  # @param content [String, Nokogiri::XML::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

    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)

    # 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

    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 << content if content
    else
      tmpl_el.children[0] << style_tag if style_tag
      tmpl_el.children[0].at_css("slot:not([name])")&.swap(content) if 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(...)
  end

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

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

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

  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 ||= []
  end

  def _context_locals
    @_context_locals ||= {}
  end

  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
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 :)