// Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

part of _js_helper;

// Helper method used by internal libraries.
regExpGetNative(JSSyntaxRegExp regexp) => regexp._nativeRegExp;

class JSSyntaxRegExp implements RegExp {
  final String _pattern;
  final bool _isMultiLine;
  final bool _isCaseSensitive;
  var _nativeRegExp;

  JSSyntaxRegExp._internal(String pattern,
                           bool multiLine,
                           bool caseSensitive,
                           bool global)
      : _nativeRegExp = makeNative(pattern, multiLine, caseSensitive, global),
        this._pattern = pattern,
        this._isMultiLine = multiLine,
        this._isCaseSensitive = caseSensitive;

  JSSyntaxRegExp(String pattern,
                 {bool multiLine: false,
                  bool caseSensitive: true})
      : this._internal(pattern, multiLine, caseSensitive, false);

  JSSyntaxRegExp._globalVersionOf(JSSyntaxRegExp other)
      : this._internal(other.pattern,
                       other.isMultiLine,
                       other.isCaseSensitive,
                       true);

  JSSyntaxRegExp._anchoredVersionOf(JSSyntaxRegExp other)
      : this._internal(other.pattern + "|()",
                       other.isMultiLine,
                       other.isCaseSensitive,
                       true);

  static makeNative(
      String pattern, bool multiLine, bool caseSensitive, bool global) {
    checkString(pattern);
    String m = multiLine ? 'm' : '';
    String i = caseSensitive ? '' : 'i';
    String g = global ? 'g' : '';
    // We're using the JavaScript's try catch instead of the Dart one
    // to avoid dragging in Dart runtime support just because of using
    // RegExp.
    var regexp = JS('',
        '(function() {'
         'try {'
          'return new RegExp(#, # + # + #);'
         '} catch (e) {'
           'return e;'
         '}'
        '})()', pattern, m, i, g);
    if (JS('bool', '# instanceof RegExp', regexp)) return regexp;
    // The returned value is the JavaScript exception. Turn it into a
    // Dart exception.
    String errorMessage = JS('String', r'String(#)', regexp);
    throw new FormatException(
        "Illegal RegExp pattern: $pattern, $errorMessage");
  }

  Match firstMatch(String str) {
    List<String> m =
        JS('=List|Null', r'#.exec(#)', _nativeRegExp, checkString(str));
    if (m == null) return null;
    var matchStart = JS('int', r'#.index', m);
    // m.lastIndex only works with flag 'g'.
    var matchEnd = matchStart + m[0].length;
    return new _MatchImplementation(pattern, str, matchStart, matchEnd, m);
  }

  bool hasMatch(String str) {
    return JS('bool', r'#.test(#)', _nativeRegExp, checkString(str));
  }

  String stringMatch(String str) {
    var match = firstMatch(str);
    return match == null ? null : match.group(0);
  }

  Iterable<Match> allMatches(String str) {
    checkString(str);
    return new _AllMatchesIterable(this, str);
  }

  Match matchAsPrefix(String string, [int start = 0]) {
    if (start < 0 || start > string.length) {
      throw new RangeError.range(start, 0, string.length);
    }
    // An "anchored version" of a regexp is created by adding "|()" to the
    // source. This means that the regexp always matches at the first position
    // that it tries, and you can see if the original regexp matched, or it
    // was the added zero-width match that matched, by looking at the last
    // capture. If it is a String, the match participated, otherwise it didn't.
    JSSyntaxRegExp regexp = new JSSyntaxRegExp._anchoredVersionOf(this);
    if (start > 0) {
      JS("void", "#.lastIndex = #", regExpGetNative(regexp), start);
    }
    _MatchImplementation match = regexp.firstMatch(string);
    if (match == null) return null;
    if (match._groups[match._groups.length - 1] != null) return null;
    match._groups.length -= 1;
    return match;
  }

  String get pattern => _pattern;
  bool get isMultiLine => _isMultiLine;
  bool get isCaseSensitive => _isCaseSensitive;
}

class _MatchImplementation implements Match {
  final Pattern pattern;
  final String str;
  final int start;
  final int end;
  final List<String> _groups;

  const _MatchImplementation(
      this.pattern,
      this.str,
      int this.start,
      int this.end,
      List<String> this._groups);

  String group(int index) => _groups[index];
  String operator [](int index) => group(index);
  int get groupCount => _groups.length - 1;

  List<String> groups(List<int> groups) {
    List<String> out = [];
    for (int i in groups) {
      out.add(group(i));
    }
    return out;
  }
}

class _AllMatchesIterable extends IterableBase<Match> {
  final JSSyntaxRegExp _re;
  final String _str;

  const _AllMatchesIterable(this._re, this._str);

  Iterator<Match> get iterator => new _AllMatchesIterator(_re, _str);
}

class _AllMatchesIterator implements Iterator<Match> {
  final RegExp _regExp;
  final RegExp _globalRegExp;
  String _str;
  Match _current;

  _AllMatchesIterator(JSSyntaxRegExp re, String this._str)
    : _regExp = re,
      _globalRegExp = new JSSyntaxRegExp._globalVersionOf(re);

  Match get current => _current;

  bool moveNext() {
    if (_str == null) return false;
    // firstMatch actually acts as nextMatch because of
    // hidden global flag.
    if (_current != null && _current.start == _current.end) {
      // Advance implicit start-position if last match was empty.
      JS("void", "#.lastIndex++", regExpGetNative(_globalRegExp));
    }
    List<String> m =
        JS('=List|Null', r'#.exec(#)', regExpGetNative(_globalRegExp), _str);
    if (m == null) {
      _current = null;
      _str = null;  // Marks iteration as ended.
      return false;
    }
    var matchStart = JS('int', r'#.index', m);
    var matchEnd = matchStart + m[0].length;
    _current = new _MatchImplementation(_regExp, _str, matchStart, matchEnd, m);
    return true;
  }
}

Match firstMatchAfter(JSSyntaxRegExp re, String str, int start) {
  JSSyntaxRegExp global = new JSSyntaxRegExp._globalVersionOf(re);
  JS("void", "#.lastIndex = #", regExpGetNative(global), start);
  List<String> m =
      JS('=List|Null', r'#.exec(#)', regExpGetNative(global), checkString(str));
  if (m == null) return null;
  var matchStart = JS('int', r'#.index', m);
  var matchEnd = matchStart + m[0].length;
  return new _MatchImplementation(re, str, matchStart, matchEnd, m);
}