require 'nokogiri'
require 'json'

module Kanjai
  class TemplateParser
    def initialize(html_source)
        @html_source = html_source
    end


    def get_elements(elements)
      mas = []


      elements.each do |item|
        new_item = item.dup
        new_item.delete(:children)
        mas << new_item if need_elements.include?(new_item[:name])

        mas = mas + get_need_elements(item[:children], need_elements)
      end

      mas
    end

    def find_subparts
      result = []
      @html_source.scan(/<!--###START element[\w\W]+?-->/).each do |item|

        name, type, code = item.scan(/<!--###START\s+element\(name="([^"]+)",\s+type="([\w\s]+)",\s+id="(.+)"\)\s+###/)[0]

        if name.present? and type.present?

          source = item.gsub(/<!--###START\s+element\(name="([^"]+)",\s+type="([\w\s]+)",\s+id="(.+)"\)\s+###/, '')
          source = source.gsub('-->', '')
          source = source.gsub("\n", '')
          source = source.gsub("\r", '')

          source_dom = Nokogiri::HTML::fragment(source)

          @field_options = []
          conditions = []
          elements = html_to_hash(source_dom)

          source_dom.traverse do |node|
            if node.name.to_s == 'condition' && node.attributes && node.attributes['id'] && node.attributes['itemname']

              repeatItemId = ""
              test = node.parent
              while test
                if test.name == 'repeat' && test.attributes["id"].present?
                  repeatItemId = test.attributes["id"].value
                  break
                end
                test = test.parent
              end

              conditions << {
                id:   node.attributes['id'].value,
                name: node.attributes['itemname'].value,
                repeat_id: repeatItemId,
                type: node.attributes['type'] ? node.attributes['type'].value : 'enable'
              }
            end
          end


          #field_options = elements.select {|item| (item[:name] == 'element' or item[:name] == 'repeat'  ) }
          #field_options = get_elements(elements)
          #elements.delete_if {|item| item[:name] == 'element' }

          result << {
              name: name,
              type: type,
              code: code,
              source: source,
              elements: elements,
              field_options: @field_options,
              conditions: conditions
          }
        end
      end


      result
    end


    def find_static_elements
      result = []
      @html_source.scan(/{"static":[\w\W\{]+?}}/).each do |str|
        element_hash = JSON.parse(str)
        result << {:name => identifier(element_hash["static"]), :itemName => element_hash["static"]["itemName"] , :type => element_hash["static"]["type"], :source => str}
      end
      result
    end

    def without_subparts
      @html_source.gsub!(/<!--###START element[\w\W]+?-->/, '')
      static_elements = self.find_static_elements
      static_elements.each do |item|
        @html_source.gsub!(item[:source], item[:name])
      end
      return @html_source
    end



    private

    def html_to_hash(root)
      mas = []

      root.children.each do |item|
        children = html_to_hash(item)
        attr = {}
        item.attributes.each do |key, value|
          attr[key] = value.value
        end

        if item.name == 'repeat' && item.attributes["id"].present?
          repeatItemId = ""
          test = item.parent
          while test
            if test.name == 'repeat' && test.attributes["id"].present?
              repeatItemId = test.attributes["id"].value
              break
            end
            test = test.parent
          end


          @field_options << {:name => item.name, id: item.attributes["id"].value, :itemName => item.attributes["itemname"]&.value, repeatItemId: repeatItemId, :attributes => attr, :source => nil, :children => {}}
        end

        if item.name == "text"
          source = item.text
        else
          source = nil
        end

        repeat = "false"
        repeatItemId = ""
        test = item
        while test
          if test.name == 'repeat' && test.attributes["id"].present?
            repeat = "true"
            repeatItemId = test.attributes["id"].value
            break
          end
          test = test.parent
        end


        source.to_s.scan(/{"element":[\w\W\{]+?}}/).each do |str|
          element_hash = JSON.parse(str)
          @field_options << {:name => identifier(element_hash["element"]), :itemName => element_hash["element"]["itemName"] , main: element_hash["element"]["main"].to_i, :attributes => {'type' => element_hash["element"]["type"], 'repeat' => repeat, 'repeatItemId' => repeatItemId}, :source => nil, :children => {}}
          source.gsub!(str, identifier(element_hash["element"]))
        end

        attr.each do |key, value|
          value.to_s.scan(/{"element":[\w\W\{]+?}}/).each do |str|

            element_hash = JSON.parse(str)
            @field_options << {:name => identifier(element_hash["element"]), :itemName => element_hash["element"]["itemName"] , main: element_hash["element"]["main"].to_i, :attributes => {'type' => element_hash["element"]["type"], 'repeat' => repeat, 'repeatItemId' => repeatItemId}, :source => nil, :children => {}}
            value.gsub!(str, identifier(element_hash["element"]))
          end
        end

        mas << {:name => item.name, :attributes => attr, :source => source, :children => children}
      end


      mas
    end

    def identifier(el)
      el['id'].present? ? el['id'] : el['title']
    end

  end
end