#include "sass.hpp"

#include <cctype>

#include <iostream>

#include <iomanip>

#include "util.hpp"

#include "position.hpp"

#include "prelexer.hpp"

#include "constants.hpp"

namespace Sass {

  // using namespace Lexer;

  using namespace Constants;

  namespace Prelexer {

    /*

        def string_re(open, close)

          /#{open}((?:\\.|\#(?!\{)|[^#{close}\\#])*)(#{close}|#\{)/m

        end

      end

      # A hash of regular expressions that are used for tokenizing strings.

      #

      # The key is a `[Symbol, Boolean]` pair.

      # The symbol represents which style of quotation to use,

      # while the boolean represents whether or not the string

      # is following an interpolated segment.

      STRING_REGULAR_EXPRESSIONS = {

        :double => {

          /#{open}((?:\\.|\#(?!\{)|[^#{close}\\#])*)(#{close}|#\{)/m

          false => string_re('"', '"'),

          true => string_re('', '"')

        },

        :single => {

          false => string_re("'", "'"),

          true => string_re('', "'")

        },

        :uri => {

          false => /url\(#{W}(#{URLCHAR}*?)(#{W}\)|#\{)/,

          true => /(#{URLCHAR}*?)(#{W}\)|#\{)/

        },

        # Defined in https://developer.mozilla.org/en/CSS/@-moz-document as a

        # non-standard version of http://www.w3.org/TR/css3-conditional/

        :url_prefix => {

          false => /url-prefix\(#{W}(#{URLCHAR}*?)(#{W}\)|#\{)/,

          true => /(#{URLCHAR}*?)(#{W}\)|#\{)/

        },

        :domain => {

          false => /domain\(#{W}(#{URLCHAR}*?)(#{W}\)|#\{)/,

          true => /(#{URLCHAR}*?)(#{W}\)|#\{)/

        }

      }

    */

    /*

      /#{open}

        (

          \\.

          |

          \# (?!\{)

          |

          [^#{close}\\#]

        )*

        (#{close}|#\{)

      /m

      false => string_re('"', '"'),

      true => string_re('', '"')

    */

    extern const char string_double_negates[] = "\"\\#";

    const char* re_string_double_close(const char* src)

    {

      return sequence <

        // valid chars

        zero_plus <

          alternatives <

            // escaped char

            sequence <

              exactly <'\\'>,

              any_char

            >,

            // non interpolate hash

            sequence <

              exactly <'#'>,

              negate <

                exactly <'{'>

              >

            >,

            // other valid chars

            neg_class_char <

              string_double_negates

            >

          >

        >,

        // quoted string closer

        // or interpolate opening

        alternatives <

          exactly <'"'>,

          lookahead < exactly< hash_lbrace > >

        >

      >(src);

    }

    const char* re_string_double_open(const char* src)

    {

      return sequence <

        // quoted string opener

        exactly <'"'>,

        // valid chars

        zero_plus <

          alternatives <

            // escaped char

            sequence <

              exactly <'\\'>,

              any_char

            >,

            // non interpolate hash

            sequence <

              exactly <'#'>,

              negate <

                exactly <'{'>

              >

            >,

            // other valid chars

            neg_class_char <

              string_double_negates

            >

          >

        >,

        // quoted string closer

        // or interpolate opening

        alternatives <

          exactly <'"'>,

          lookahead < exactly< hash_lbrace > >

        >

      >(src);

    }

    extern const char string_single_negates[] = "'\\#";

    const char* re_string_single_close(const char* src)

    {

      return sequence <

        // valid chars

        zero_plus <

          alternatives <

            // escaped char

            sequence <

              exactly <'\\'>,

              any_char

            >,

            // non interpolate hash

            sequence <

              exactly <'#'>,

              negate <

                exactly <'{'>

              >

            >,

            // other valid chars

            neg_class_char <

              string_single_negates

            >

          >

        >,

        // quoted string closer

        // or interpolate opening

        alternatives <

          exactly <'\''>,

          lookahead < exactly< hash_lbrace > >

        >

      >(src);

    }

    const char* re_string_single_open(const char* src)

    {

      return sequence <

        // quoted string opener

        exactly <'\''>,

        // valid chars

        zero_plus <

          alternatives <

            // escaped char

            sequence <

              exactly <'\\'>,

              any_char

            >,

            // non interpolate hash

            sequence <

              exactly <'#'>,

              negate <

                exactly <'{'>

              >

            >,

            // other valid chars

            neg_class_char <

              string_single_negates

            >

          >

        >,

        // quoted string closer

        // or interpolate opening

        alternatives <

          exactly <'\''>,

          lookahead < exactly< hash_lbrace > >

        >

      >(src);

    }

    /*

      :uri => {

        false => /url\(#{W}(#{URLCHAR}*?)(#{W}\)|#\{)/,

        true => /(#{URLCHAR}*?)(#{W}\)|#\{)/

      },

    */

    const char* re_string_uri_close(const char* src)

    {

      return sequence <

        non_greedy<

          alternatives<

            class_char< real_uri_chars >,

            uri_character,

            NONASCII,

            ESCAPE

          >,

          alternatives<

            sequence < optional < W >, exactly <')'> >,

            lookahead < exactly< hash_lbrace > >

          >

        >,

        optional <

          sequence < optional < W >, exactly <')'> >

        >

      >(src);

    }

    const char* re_string_uri_open(const char* src)

    {

      return sequence <

        exactly <'u'>,

        exactly <'r'>,

        exactly <'l'>,

        exactly <'('>,

        W,

        alternatives<

          quoted_string,

          non_greedy<

            alternatives<

              class_char< real_uri_chars >,

              uri_character,

              NONASCII,

              ESCAPE

            >,

            alternatives<

              sequence < W, exactly <')'> >,

              exactly< hash_lbrace >

            >

          >

        >

      >(src);

    }

    // Match a line comment (/.*?(?=\n|\r\n?|\Z)/.

    const char* line_comment(const char* src)

    {

      return sequence<

               exactly <

                 slash_slash

               >,

               non_greedy<

                 any_char,

                 end_of_line

               >

             >(src);

    }

    // Match a block comment.

    const char* block_comment(const char* src)

    {

      return sequence<

               delimited_by<

                 slash_star,

                 star_slash,

                 false

               >

             >(src);

    }

    /* not use anymore - remove?

    const char* block_comment_prefix(const char* src) {

      return exactly<slash_star>(src);

    }

    // Match either comment.

    const char* comment(const char* src) {

      return line_comment(src);

    }

    */

    // Match zero plus white-space or line_comments

    const char* optional_css_whitespace(const char* src) {

      return zero_plus< alternatives<spaces, line_comment> >(src);

    }

    const char* css_whitespace(const char* src) {

      return one_plus< alternatives<spaces, line_comment> >(src);

    }

    // Match optional_css_whitepace plus block_comments

    const char* optional_css_comments(const char* src) {

      return zero_plus< alternatives<spaces, line_comment, block_comment> >(src);

    }

    const char* css_comments(const char* src) {

      return one_plus< alternatives<spaces, line_comment, block_comment> >(src);

    }

    // Match one backslash escaped char /\\./

    const char* escape_seq(const char* src)

    {

      return sequence<

        exactly<'\\'>,

        alternatives <

          minmax_range<

            1, 3, xdigit

          >,

          any_char

        >,

        optional <

          exactly <' '>

        >

      >(src);

    }

    // Match identifier start

    const char* identifier_alpha(const char* src)

    {

      return alternatives<

               unicode_seq,

               alpha,

               unicode,

               exactly<'-'>,

               exactly<'_'>,

               NONASCII,

               ESCAPE,

               escape_seq

             >(src);

    }

    // Match identifier after start

    const char* identifier_alnum(const char* src)

    {

      return alternatives<

               unicode_seq,

               alnum,

               unicode,

               exactly<'-'>,

               exactly<'_'>,

               NONASCII,

               ESCAPE,

               escape_seq

             >(src);

    }

    // Match CSS identifiers.

    const char* strict_identifier(const char* src)

    {

      return sequence<

               one_plus < strict_identifier_alpha >,

               zero_plus < strict_identifier_alnum >

               // word_boundary not needed

             >(src);

    }

    // Match CSS identifiers.

    const char* identifier(const char* src)

    {

      return sequence<

               zero_plus< exactly<'-'> >,

               one_plus < identifier_alpha >,

               zero_plus < identifier_alnum >

               // word_boundary not needed

             >(src);

    }

    const char* strict_identifier_alpha(const char* src)

    {

      return alternatives <

               alpha,

               unicode,

               escape_seq,

               exactly<'_'>

             >(src);

    }

    const char* strict_identifier_alnum(const char* src)

    {

      return alternatives <

               alnum,

               unicode,

               escape_seq,

               exactly<'_'>

             >(src);

    }

    // Match a single CSS unit

    const char* one_unit(const char* src)

    {

      return sequence <

               optional < exactly <'-'> >,

               strict_identifier_alpha,

               zero_plus < alternatives<

                 strict_identifier_alnum,

                 sequence <

                   one_plus < exactly<'-'> >,

                   strict_identifier_alpha

                 >

               > >

             >(src);

    }

    // Match numerator/denominator CSS units

    const char* multiple_units(const char* src)

    {

      return

        sequence <

          one_unit,

          zero_plus <

            sequence <

              exactly <'*'>,

              one_unit

            >

          >

        >(src);

    }

    // Match complex CSS unit identifiers

    const char* unit_identifier(const char* src)

    {

      return sequence <

        multiple_units,

        optional <

          sequence <

          exactly <'/'>,

          negate < sequence <

            exactly < calc_fn_kwd >,

            exactly < '(' >

          > >,

          multiple_units

        > >

      >(src);

    }

    const char* identifier_alnums(const char* src)

    {

      return one_plus< identifier_alnum >(src);

    }

    // Match number prefix ([\+\-]+)

    const char* number_prefix(const char* src) {

      return alternatives <

        exactly < '+' >,

        sequence <

          exactly < '-' >,

          optional_css_whitespace,

          exactly< '-' >

        >

      >(src);

    }

    // Match interpolant schemas

    const char* identifier_schema(const char* src) {

      return sequence <

               one_plus <

                 sequence <

                   zero_plus <

                     alternatives <

                       sequence <

                         optional <

                           exactly <'$'>

                         >,

                         identifier

                       >,

                       exactly <'-'>

                     >

                   >,

                   interpolant,

                   zero_plus <

                     alternatives <

                       digits,

                       sequence <

                         optional <

                           exactly <'$'>

                         >,

                         identifier

                       >,

                       quoted_string,

                       exactly<'-'>

                     >

                   >

                 >

               >,

               negate <

                 exactly<'%'>

               >

             > (src);

    }

    // interpolants can be recursive/nested

    const char* interpolant(const char* src) {

      return recursive_scopes< exactly<hash_lbrace>, exactly<rbrace> >(src);

    }

    // $re_squote = /'(?:$re_itplnt|\\.|[^'])*'/

    const char* single_quoted_string(const char* src) {

      // match a single quoted string, while skipping interpolants

      return sequence <

        exactly <'\''>,

        zero_plus <

          alternatives <

            // skip escapes

            sequence <

              exactly < '\\' >,

              re_linebreak

            >,

            escape_seq,

            unicode_seq,

            // skip interpolants

            interpolant,

            // skip non delimiters

            any_char_but < '\'' >

          >

        >,

        exactly <'\''>

      >(src);

    }

    // $re_dquote = /"(?:$re_itp|\\.|[^"])*"/

    const char* double_quoted_string(const char* src) {

      // match a single quoted string, while skipping interpolants

      return sequence <

        exactly <'"'>,

        zero_plus <

          alternatives <

            // skip escapes

            sequence <

              exactly < '\\' >,

              re_linebreak

            >,

            escape_seq,

            unicode_seq,

            // skip interpolants

            interpolant,

            // skip non delimiters

            any_char_but < '"' >

          >

        >,

        exactly <'"'>

      >(src);

    }

    // $re_quoted = /(?:$re_squote|$re_dquote)/

    const char* quoted_string(const char* src) {

      // match a quoted string, while skipping interpolants

      return alternatives<

        single_quoted_string,

        double_quoted_string

      >(src);

    }

    const char* sass_value(const char* src) {

      return alternatives <

        quoted_string,

        identifier,

        percentage,

        hex,

        dimension,

        number

      >(src);

    }

    // this is basically `one_plus < sass_value >`

    // takes care to not parse invalid combinations

    const char* value_combinations(const char* src) {

      // `2px-2px` is invalid combo

      bool was_number = false;

      const char* pos;

      while (src) {

        if ((pos = alternatives < quoted_string, identifier, percentage, hex >(src))) {

          was_number = false;

          src = pos;

        } else if (!was_number && !exactly<'+'>(src) && (pos = alternatives < dimension, number >(src))) {

          was_number = true;

          src = pos;

        } else {

          break;

        }

      }

      return src;

    }

    // must be at least one interpolant

    // can be surrounded by sass values

    // make sure to never parse (dim)(dim)

    // since this wrongly consumes `2px-1px`

    // `2px1px` is valid number (unit `px1px`)

    const char* value_schema(const char* src)

    {

      return sequence <

        one_plus <

          sequence <

            optional < value_combinations >,

            interpolant,

            optional < value_combinations >

          >

        >

      >(src);

    }

    // Match CSS '@' keywords.

    const char* at_keyword(const char* src) {

      return sequence<exactly<'@'>, identifier>(src);

    }

    /*

        tok(%r{

          (

            \\.

          |

            (?!url\()

            [^"'/\#!;\{\}] # "

          |

            /(?![\*\/])

          |

            \#(?!\{)

          |

            !(?![a-z]) # TODO: never consume "!" when issue 1126 is fixed.

          )+

        }xi) || tok(COMMENT) || tok(SINGLE_LINE_COMMENT) || interp_string || interp_uri ||

                interpolation(:warn_for_color)

    */

    const char* re_almost_any_value_token(const char* src) {

      return alternatives <

        one_plus <

          alternatives <

            sequence <

              exactly <'\\'>,

              any_char

            >,

            sequence <

              negate <

                sequence <

                  exactly < url_kwd >,

                  exactly <'('>

                >

              >,

              neg_class_char <

                almost_any_value_class

              >

            >,

            sequence <

              exactly <'/'>,

              negate <

                alternatives <

                  exactly <'/'>,

                  exactly <'*'>

                >

              >

            >,

            sequence <

              exactly <'\\'>,

              exactly <'#'>,

              negate <

                exactly <'{'>

              >

            >,

            sequence <

              exactly <'!'>,

              negate <

                alpha

              >

            >

          >

        >,

        block_comment,

        line_comment,

        interpolant,

        space,

        sequence <

          exactly<'u'>,

          exactly<'r'>,

          exactly<'l'>,

          exactly<'('>,

          zero_plus <

            alternatives <

              class_char< real_uri_chars >,

              uri_character,

              NONASCII,

              ESCAPE

            >

          >,

          // false => /url\(#{W}(#{URLCHAR}*?)(#{W}\)|#\{)/,

          // true => /(#{URLCHAR}*?)(#{W}\)|#\{)/

          exactly<')'>

        >

      >(src);

    }

    /*

      DIRECTIVES = Set[:mixin, :include, :function, :return, :debug, :warn, :for,

        :each, :while, :if, :else, :extend, :import, :media, :charset, :content,

        :_moz_document, :at_root, :error]

    */

    const char* re_special_directive(const char* src) {

      return alternatives <

        word < mixin_kwd >,

        word < include_kwd >,

        word < function_kwd >,

        word < return_kwd >,

        word < debug_kwd >,

        word < warn_kwd >,

        word < for_kwd >,

        word < each_kwd >,

        word < while_kwd >,

        word < if_kwd >,

        word < else_kwd >,

        word < extend_kwd >,

        word < import_kwd >,

        word < media_kwd >,

        word < charset_kwd >,

        word < content_kwd >,

        // exactly < moz_document_kwd >,

        word < at_root_kwd >,

        word < error_kwd >

      >(src);

    }

    const char* re_prefixed_directive(const char* src) {

      return sequence <

        optional <

          sequence <

            exactly <'-'>,

            one_plus < alnum >,

            exactly <'-'>

          >

        >,

        exactly < supports_kwd >

      >(src);

    }

    const char* re_reference_combinator(const char* src) {

      return sequence <

        optional <

          sequence <

            zero_plus <

              exactly <'-'>

            >,

            identifier,

            exactly <'|'>

          >

        >,

        zero_plus <

          exactly <'-'>

        >,

        identifier

      >(src);

    }

    const char* static_reference_combinator(const char* src) {

      return sequence <

        exactly <'/'>,

        re_reference_combinator,

        exactly <'/'>

      >(src);

    }

    const char* schema_reference_combinator(const char* src) {

      return sequence <

        exactly <'/'>,

        optional <

          sequence <

            css_ip_identifier,

            exactly <'|'>

          >

        >,

        css_ip_identifier,

        exactly <'/'>

      > (src);

    }

    const char* kwd_import(const char* src) {

      return word<import_kwd>(src);

    }

    const char* kwd_at_root(const char* src) {

      return word<at_root_kwd>(src);

    }

    const char* kwd_with_directive(const char* src) {

      return word<with_kwd>(src);

    }

    const char* kwd_without_directive(const char* src) {

      return word<without_kwd>(src);

    }

    const char* kwd_media(const char* src) {

      return word<media_kwd>(src);

    }

    const char* kwd_supports_directive(const char* src) {

      return word<supports_kwd>(src);

    }

    const char* kwd_mixin(const char* src) {

      return word<mixin_kwd>(src);

    }

    const char* kwd_function(const char* src) {

      return word<function_kwd>(src);

    }

    const char* kwd_return_directive(const char* src) {

      return word<return_kwd>(src);

    }

    const char* kwd_include_directive(const char* src) {

      return word<include_kwd>(src);

    }

    const char* kwd_content_directive(const char* src) {

      return word<content_kwd>(src);

    }

    const char* kwd_charset_directive(const char* src) {

      return word<charset_kwd>(src);

    }

    const char* kwd_extend(const char* src) {

      return word<extend_kwd>(src);

    }

    const char* kwd_if_directive(const char* src) {

      return word<if_kwd>(src);

    }

    const char* kwd_else_directive(const char* src) {

      return word<else_kwd>(src);

    }

    const char* elseif_directive(const char* src) {

      return sequence< exactly< else_kwd >,

                                optional_css_comments,

                                word< if_after_else_kwd > >(src);

    }

    const char* kwd_for_directive(const char* src) {

      return word<for_kwd>(src);

    }

    const char* kwd_from(const char* src) {

      return word<from_kwd>(src);

    }

    const char* kwd_to(const char* src) {

      return word<to_kwd>(src);

    }

    const char* kwd_through(const char* src) {

      return word<through_kwd>(src);

    }

    const char* kwd_each_directive(const char* src) {

      return word<each_kwd>(src);

    }

    const char* kwd_in(const char* src) {

      return word<in_kwd>(src);

    }

    const char* kwd_while_directive(const char* src) {

      return word<while_kwd>(src);

    }