Node  = require('./node')

{escapeQuotes} = require('../util/text')

# HAML node that contains Haml a haml tag that can have attributes
# and a text or code assignment. There are shortcuts for id and class
# generation and some special logic for merging attributes into existing
# ids and classes.
#
# @example Haml tag
#   %footer                               =>  <footer></footer>
#
# @example Haml id
#   #content                              =>  <div id='content'></div>
#   %span#status{ :id => @user.status }   =>  <span id='status_#{ @user.status }'></span>
#
# @example Haml classes
#   .hidden                               => <div class='hidden'></div>
#   %span.large.hidden                    => <span class='large hidden'></span>
#   .large{ :class => @user.role }        => <div class='large #{ @user.role }'></div>
#
# Haml HTML attributes are very limited and allows only simple string
# (with interpolation) or variable assignment to an attribute.
#
# @example Haml HTML attributes
#   %p(class='hidden')                     => <p class='hidden'><p>
#   #account(class=@status)                => <div id='account' class='#{ status }'></div>
#   .logout(title="Logout #{ user.name }") => <div class='logout' title='Logout #{ user.name }'></div>
#
# Ruby HTML attributes are more powerful and allows in addition to the
# HTML attributes function calls:
#
# @example Haml Ruby attributes
#   %p{ :class => App.user.get('role') }   => <p class='#{ App.user.get('role') }'></p>
#
module.exports = class Haml extends Node

  # Evaluate the node content and store the opener tag
  # and the closer tag if applicable.
  #
  evaluate: ->
    tokens = @parseExpression(@expression)

    # Evaluate Haml doctype
    if tokens.doctype
      @opener = @markText "#{ escapeQuotes(@buildDocType(tokens.doctype)) }"

    # Evaluate Haml tag
    else
      # Create a Haml node that can contain child nodes
      if @isNotSelfClosing(tokens.tag)

        prefix = @buildHtmlTagPrefix(tokens)

        # Add Haml tag that contains a code assignment will be closed immediately
        if tokens.assignment

          match = tokens.assignment.match /^(=|!=|&=|~)\s*(.*)$/

          identifier = match[1]
          assignment = match[2]

          if identifier is '~'
            code = "\#{$fp #{ assignment } }"

          # Code block with escaped code block, either `=` in escaped mode or `&=`
          else if identifier is '&=' or (identifier is '=' and @escapeHtml)
            if @preserve
              if @cleanValue
                code = "\#{ $p($e($c(#{ assignment }))) }"
              else
                code = "\#{ $p($e(#{ assignment })) }"
            else
              if @cleanValue
                code = "\#{ $e($c(#{ assignment })) }"
              else
                code = "\#{ $e(#{ assignment }) }"

          # Code block with unescaped output, either with `!=` or escaped mode to false
          else if identifier is '!=' or (identifier is '=' and not @escapeHtml)
            if @preserve
              if @cleanValue
                code = "\#{ $p($c(#{ assignment })) }"
              else
                code = "\#{ $p(#{ assignment }) }"
            else
              if @cleanValue
                code = "\#{ $c(#{ assignment }) }"
              else
                code = "\#{ #{ assignment } }"

          @opener = @markText "#{ prefix }>#{ code }"
          @closer = @markText "</#{ tokens.tag }>"

        # A Haml tag that contains an inline text
        else if tokens.text
          @opener = @markText "#{ prefix }>#{ tokens.text }"
          @closer = @markText "</#{ tokens.tag }>"

        # A Haml tag that can get more child nodes
        else
          @opener = @markText prefix + '>'
          @closer = @markText "</#{ tokens.tag}>"

      # Create a self closing tag that depends on the format `<br>` or `<br/>`
      # when it doesn't contain some text
      else
        tokens.tag = tokens.tag.replace /\/$/, ''
        prefix     = @buildHtmlTagPrefix(tokens)

        if tokens.text
          @opener = @markText "#{ prefix }>#{ tokens.text }"
          @closer = @markText "</#{ tokens.tag }>"
        else
          @opener = @markText "#{ prefix }#{ if @format is 'xhtml' then ' /' else '' }>#{ tokens.text }"

  # Parses the expression and detect the tag, attributes
  # and any assignment. In addition class and id cleanup
  # is performed according the the Haml spec:
  #
  # * Classes are merged together
  # * When multiple ids are provided, the last one is taken,
  #   except they are defined in shortcut notation and attribute
  #   notation. In this case, they will be combined, separated by
  #   underscore.
  #
  # @example Id merging
  #   #user{ :id => @user.id }    =>  <div id='user_#{ @user.id }'></div>
  #
  # @param [String] exp the HAML expression
  # @return [Object] the parsed tag and options tokens
  #
  parseExpression: (exp) ->
    tag = @parseTag(exp)

    @preserve = true if @preserveTags.indexOf(tag.tag) isnt -1

    id         = @interpolateCodeAttribute(tag.ids?.pop(), true)
    classes    = tag.classes
    attributes = {}

    # Clean attributes
    if tag.attributes
      for key, value of tag.attributes
        if key is 'id'
          if id
            # Merge attribute id into existing id
            id += '_' + @interpolateCodeAttribute(value, true)
          else
            # Push id from attribute
            id = @interpolateCodeAttribute(value, true)

        # Merge classes
        else if key is 'class'
          classes or= []
          classes.push value

        # Add to normal attributes
        else
          attributes[key] = value

    {
      doctype    : tag.doctype
      tag        : tag.tag
      id         : id
      classes    : classes
      text       : escapeQuotes(tag.text)
      attributes : attributes
      assignment : tag.assignment
      reference  : tag.reference
    }

  # Parse a tag line. This recognizes DocType tags `!!!` and
  # HAML tags like `#id.class text`.
  #
  # It also parses the code assignment `=`, `}=` and `)=` or
  # inline text and the whitespace removal markers `<` and `>`.
  #
  # It detects an object reference `[` and attributes `(` / `{`.
  #
  # @param [String] exp the HAML expression
  # @return [Object] the parsed tag tokens
  #
  parseTag: (exp) ->
    try
      doctype = exp.match(/^(\!{3}.*)/)?[1]
      return { doctype: doctype } if doctype

      # Match the haml tag %a, .name, etc.
      haml = exp.match(/^((?:[#%\.][a-z0-9_:\-]*[\/]?)+)/i)[0]
      rest = exp.substring(haml.length)

      # The haml tag has attributes
      if rest.match /^[{([]/

        reference  = ''
        htmlAttributes = ''
        rubyAttributes = ''

        for start in ['[', '{', '(', '[', '{', '(']
          if start is rest[0]
            # Get used attribute surround end character
            end = switch start
                    when '{' then '}'
                    when '(' then ')'
                    when '[' then ']'

            # Extract attributes by keeping track of brace/parenthesis level
            level = 0
            for pos in [0..rest.length]
              ch = rest[pos]

              # Increase level when a nested brace/parenthesis is started
              level += 1 if ch is start

              # Decrease level when a nested brace/parenthesis is end or exit when on the last level
              if ch is end
                if level is 1 then break else level -= 1

            # Extract result
            switch start
              when '{'
                rubyAttributes += rest.substring(0, pos + 1)
                rest = rest.substring(pos + 1)
              when '('
                htmlAttributes += rest.substring(0, pos + 1)
                rest = rest.substring(pos + 1)
              when '['
                reference = rest.substring(1, pos)
                rest = rest.substring(pos + 1)

        assignment = rest || ''

      # No attributes defined
      else
        reference = ''
        htmlAttributes = ''
        rubyAttributes = ''
        assignment = rest

      # Merge HTML and Ruby style attributes
      attributes = {}
      for attr in [@parseAttributes(htmlAttributes), @parseAttributes(rubyAttributes)]
        attributes[key] = val for key, val of attr

      # Extract whitespace removal
      if whitespace = assignment.match(/^[<>]{0,2}/)?[0]
        assignment = assignment.substring(whitespace.length)

      # Remove the delimiter space from the assignment
      assignment = assignment.substring(1) if assignment[0] is ' '

      # Process inline text or assignment
      if assignment and not assignment.match(/^(=|!=|&=|~)/)
        text       = assignment.replace(/^ /, '')
        assignment = undefined

      # Set whitespace removal markers
      if whitespace
        @wsRemoval.around = true if whitespace.indexOf('>') isnt -1

        if whitespace.indexOf('<') isnt -1
          @wsRemoval.inside = true
          @preserve = true

      # Extracts tag name, id and classes
      tag     = haml.match(/\%([a-z_\-][a-z0-9_:\-]*[\/]?)/i)
      ids     = haml.match(/\#([a-z_\-][a-z0-9_\-]*)/gi)
      classes = haml.match(/\.([a-z0-9_\-]*)/gi)

      {
        tag        : if tag then tag[1] else 'div'
        ids        : ("'#{ id.substr(1) }'" for id    in ids)     if ids
        classes    : ("'#{ klass.substr(1) }'" for klass in classes) if classes
        attributes : attributes
        assignment : assignment
        reference  : reference
        text       : text
      }

    catch error
      throw new Error("Unable to parse tag from #{ exp }: #{ error }")

  # Parse attributes either in Ruby style `%tag{ :attr => 'value' }`
  # or HTML style `%tag(attr='value)`. Both styles can be mixed:
  # `%tag(attr='value){ :attr => 'value' }`.
  #
  # This takes also care of proper attribute interpolation, unwrapping
  # quoted keys and value, e.g. `'a' => 'hello'` becomes `a => hello`.
  #
  # @param [String] exp the HAML expression
  # @return [Object] the parsed attributes
  #
  parseAttributes: (exp) ->
    attributes = {}
    return attributes if exp is undefined

    type = exp.substring(0, 1)

    # Mark key separator characters within quoted values, so they aren't recognized as keys.
    exp = exp.replace /(=|:|=>)\s*('([^\\']|\\\\|\\')*'|"([^\\"]|\\\\|\\")*")/g, (match, type, value) ->
      type + value?.replace /(:|=|=>)/g, '\u0090$1'

    # Mark key separator characters within parenthesis, so they aren't recognized as keys.
    level = 0
    start = 0
    markers = []

    if type is '('
      startPos = 1
      endPos = exp.length - 1
    else
      startPos = 0
      endPos = exp.length

    for pos in [startPos...endPos]
      ch = exp[pos]

      # Increase level when a parenthesis is started
      if ch is '('
        level += 1
        start = pos if level is 1

      # Decrease level when a parenthesis is end
      if ch is ')'
        if level is 1
          markers.push({ start: start, end: pos }) if start isnt 0 and pos - start isnt 1
        else
          level -= 1

    for marker in markers.reverse()
      exp = exp.substring(0, marker.start) + exp.substring(marker.start, marker.end).replace(/(:|=|=>)/g, '\u0090$1') + exp.substring(marker.end)

    # Detect the used key type
    switch type
      when '('
        # HTML attribute keys
        keys = ///
               \(\s*([-\w]+[\w:-]*\w?)\s*=
               |
               \s+([-\w]+[\w:-]*\w?)\s*=
               |
               \(\s*('\w+[\w:-]*\w?')\s*=
               |
               \s+('\w+[\w:-]*\w?')\s*=
               |
               \(\s*("\w+[\w:-]*\w?")\s*=
               |
               \s+("\w+[\w:-]*\w?")\s*=
               ///g

      when '{'
        # Ruby attribute keys
        keys = ///
               [{,]\s*(\w+[\w:-]*\w?)\s*:
               |
               [{,]\s*('[-\w]+[\w:-]*\w?')\s*:
               |
               [{,]\s*("[-\w]+[\w:-]*\w?")\s*:
               |
               [{,]\s*:(\w+[\w:-]*\w?)\s*=>
               |
               [{,]\s*:?'([-\w]+[\w:-]*\w?)'\s*=>
               |
               [{,]\s*:?"([-\w]+[\w:-]*\w?)"\s*=>
               ///g

    # Split into key value pairs
    pairs = exp.split(keys).filter(Boolean)

    inDataAttribute = false
    hasDataAttribute = false

    # Process the pairs in a group of two
    while pairs.length
      keyValue = pairs.splice 0, 2

      # Just a single attribute without value
      if keyValue.length is 1
        attr = keyValue[0].replace(/^[\s({]+|[\s)}]+$/g, '')
        attributes[attr] = 'true'

      # Attribute with value or multiple attributes
      else
        # Trim key and remove preceding colon and remove markers
        key = keyValue[0]?.replace(/^\s+|\s+$/g, '').replace(/^:/, '')
        key = quoted[2] if quoted = key.match /^("|')(.*)\1$/

        # Trim value, remove succeeding comma and remove markers
        value = keyValue[1]?.replace(/^\s+|[\s,]+$/g, '').replace(/\u0090/g, '')

        if key is 'data' and !value
          inDataAttribute = true
          hasDataAttribute = true

        else if key and value
          if inDataAttribute
            key = if @hyphenateDataAttrs then "data-#{ key.replace('_', '-') }" else "data-#{ key }"
            inDataAttribute = false if /}\s*$/.test value

        switch type
          when '('
            value = value.replace(/^\s+|[\s)]+$/g, '')

            # Detect attributes without value as value suffix
            quote = /^(['"])/.exec(value)?[1]
            pos = value.lastIndexOf quote

            if pos > 1
              for attr in value.substring(pos + 1).split ' '
                attributes[attr] = 'true' if attr

              value = value.substring(0, pos + 1)


            attributes[key] = value
          when '{'
            attributes[key] = value.replace(/^\s+|[\s}]+$/g, '')

    delete attributes['data'] if hasDataAttribute

    attributes

  # Build the HTML tag prefix by concatenating all the
  # tag information together. The result is an unfinished
  # html tag that must be further processed:
  #
  # @example Prefix tag
  #   <a id='id' class='class' attr='value'
  #
  # The Haml spec sorts the `class` names, even when they
  # contain interpolated classes. This is supported by
  # sorting classes at template render time.
  #
  # If both an object reference and an id or class attribute is defined,
  # then the attribute will be ignored.
  #
  # @example Template render time sorting
  #   <p class='#{ [@user.name(), 'show'].sort().join(' ') }'>
  #
  # @param [Object] tokens all parsed tag tokens
  # @return [String] the tag prefix
  #
  buildHtmlTagPrefix: (tokens) ->
    tagParts = ["<#{ tokens.tag }"]

    # Set tag classes
    if tokens.classes

      hasDynamicClass = false

      # Prepare static and dynamic class names
      classList = for name in tokens.classes
        name = @interpolateCodeAttribute(name, true)
        hasDynamicClass = true if name.indexOf('#{') isnt -1
        name

      # Render time classes
      if hasDynamicClass && classList.length > 1
        classes = '#{ ['
        classes += "#{ @quoteAndEscapeAttributeValue(klass, true) }," for klass in classList
        classes = classes.substring(0, classes.length - 1) + '].sort().join(\' \').replace(/^\\s+|\\s+$/g, \'\') }'

      # Compile time classes
      else
        classes = classList.sort().join ' '

      tagParts.push "class='#{ classes }'"

    # Set tag id
    tagParts.push "id='#{ tokens.id }'" if tokens.id

    # Add id from object reference
    if tokens.reference
      if tokens.attributes
        delete tokens.attributes['class']
        delete tokens.attributes['id']

      tagParts.push "\#{$r(" + tokens.reference + ")}"

    # Construct tag attributes
    if tokens.attributes
      for key, value of tokens.attributes

        # Boolean attribute logic
        if value is 'true' or value is 'false'

          # Only show true values
          if value is 'true'
            if @format is 'html5'
              tagParts.push "#{ key }"
            else
              tagParts.push "#{ key }=#{ @quoteAndEscapeAttributeValue(key) }"

        # Anything but booleans
        else
          tagParts.push "#{ key }=#{ @quoteAndEscapeAttributeValue(@interpolateCodeAttribute(value)) }"

    tagParts.join(' ')

  # Wrap plain attributes into an interpolation for execution.
  # In addition wrap it into escaping and cleaning function,
  # depending on the options.
  #
  # @param [String] text the possible code
  # @param [Boolean] unwrap unwrap static text from quotes
  # @return [String] the text of the wrapped code
  #
  interpolateCodeAttribute: (text, unwrap = false) ->
    return unless text

    if not text.match /^("|').*\1$/
      if @escapeAttributes
        if @cleanValue
          text = '#{ $e($c(' + text + ')) }'
        else
          text = '#{ $e(' + text + ') }'
      else
        if @cleanValue
          text = '#{ $c(' + text + ') }'
        else
          text = '#{ (' + text + ') }'

    if unwrap
      text = quoted[2] if quoted = text.match /^("|')(.*)\1$/

    text

  # Quote the attribute value, depending on its
  # content. If the attribute contains an interpolation,
  # each interpolation will be cleaned and/or escaped,
  # depending on the compiler options.
  #
  # @param [String] value the without start and end quote
  # @param [String] code if we are in a code block
  # @return [String] the quoted value
  #
  quoteAndEscapeAttributeValue: (value, code = false) ->
    return unless value

    value  = quoted[2] if quoted = value.match /^("|')(.*)\1$/
    tokens = @splitInterpolations value

    hasSingleQuotes = false
    hasDoubleQuotes = false
    hasInterpolation = false

    # Analyse existing quotes and escape/clean interpolations
    tokens = for token in tokens
      if token[0..1] is '#{'
        # Skip interpolated code attributes
        if token.indexOf('$e') is -1 and token.indexOf('$c') is -1
          if @escapeAttributes
            if @cleanValue
              token = '#{ $e($c(' + token[2...-1] + ')) }'
            else
              token = '#{ $e(' + token[2...-1] + ') }'
          else
            if @cleanValue
              token = '#{ $c(' + token[2...-1] + ') }'

        hasInterpolation = true
      else
        hasSingleQuotes = token.indexOf("'") isnt -1 unless hasSingleQuotes
        hasDoubleQuotes = token.indexOf('"') isnt -1 unless hasDoubleQuotes

      token

    if code
      if hasInterpolation
        result = "\"#{ tokens.join('') }\""
      else
        result = "'#{ tokens.join('') }'"

    else
      # Without any qoutes, wrap the value in single quotes
      if not hasDoubleQuotes and not hasSingleQuotes
        result = "'#{ tokens.join('') }'"

      # With only single quotes, wrap the value in double quotes
      if hasSingleQuotes and not hasDoubleQuotes
        result = "\\\"#{ tokens.join('') }\\\""

      # With only double quotes, wrap the value in single quotes and escape the double quotes
      if hasDoubleQuotes and not hasSingleQuotes
        escaped = for token in tokens
          escapeQuotes(token)
        result = "'#{ escaped.join('') }'"

      # With both type of quotes, wrap the value in single quotes, escape the double quotes and
      # convert the single quotes to it's entity representation
      if hasSingleQuotes and hasDoubleQuotes
        escaped = for token in tokens
          escapeQuotes(token).replace(/'/g, '&#39;')
        result = "'#{ escaped.join('') }'"

    result

  # Split expression by its interpolations.
  #
  # @example
  #   'Hello #{ "#{ soso({}) }" } Interpol') => ["Hello ", "#{ "#{ soso({}) }" }", " Interpol"]
  #   'Hello #{ "#{ soso }" } Interpol') => ["Hello ", "#{ "#{ soso }" }", " Interpol"]
  #   'Hello #{ int } Interpol') => ["Hello ", "#{ int }", " Interpol"]
  #   'Hello Interpol') => ["Hello Interpol"]
  #   '#{ int } Interpol') => ["#{ int }", " Interpol"]
  #   'Hello #{ int }') => ["Hello ", "#{ int }"]
  #   '#{ int }') => ["#{ int }"]
  #
  # @param [String] value the attribute value
  # @return [Array<String>] the splitted string
  #
  splitInterpolations: (value) ->
    level = 0
    start = 0
    tokens = []

    for pos in [0...value.length]
      ch  = value[pos]
      ch2 = value[pos..pos + 1]

      if ch is '{'
        level += 1

      if ch2 is '#{' and level is 0
        tokens.push(value[start...pos])
        start = pos

      if ch is '}'
        level -= 1

        if level is 0
          tokens.push(value[start..pos])
          start = pos + 1

    tokens.push(value[start...value.length])

    tokens.filter(Boolean)

  # Build the DocType string depending on the `!!!` token
  # and the currently used HTML format.
  #
  # @param [String] doctype the HAML doctype
  # @return [String] the HTML doctype
  #
  buildDocType: (doctype) ->
    switch "#{ @format } #{ doctype }"
      when 'xhtml !!! XML' then '<?xml version=\'1.0\' encoding=\'utf-8\' ?>'
      when 'xhtml !!!' then '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">'
      when 'xhtml !!! 1.1' then '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">'
      when 'xhtml !!! mobile' then '<!DOCTYPE html PUBLIC "-//WAPFORUM//DTD XHTML Mobile 1.2//EN" "http://www.openmobilealliance.org/tech/DTD/xhtml-mobile12.dtd">'
      when 'xhtml !!! basic' then '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML Basic 1.1//EN" "http://www.w3.org/TR/xhtml-basic/xhtml-basic11.dtd">'
      when 'xhtml !!! frameset' then '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">'
      when 'xhtml !!! 5', 'html5 !!!' then '<!DOCTYPE html>'
      when 'html5 !!! XML', 'html4 !!! XML' then ''
      when 'html4 !!!' then '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">'
      when 'html4 !!! frameset' then '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" "http://www.w3.org/TR/html4/frameset.dtd">'
      when 'html4 !!! strict' then '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">'

  # Test if the given tag is a non-self enclosing tag, by
  # matching against a fixed tag list or parse for the self
  # closing slash `/` at the end.
  #
  # @param [String] tag the tag name without brackets
  # @return [Boolean] true when a non self closing tag
  #
  isNotSelfClosing: (tag) ->
    @selfCloseTags.indexOf(tag) == -1 && !tag.match(/\/$/)