// 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.

library dart.uri;

import 'dart:math';
import 'dart:utf';

part 'encode_decode.dart';
part 'helpers.dart';

/**
 * A parsed URI, inspired by Closure's [URI][] class. Implements [RFC-3986][].
 * The domain component can either be a hostname, a IPv4 address or an IPv6
 * address, contained in '[' and ']', following [RFC-2732][]. If the domain
 * component contains a ':', the String returned from [toString] will have
 * '[' and ']' around the domain part.
 * [URI]: http://closure-library.googlecode.com/svn/docs/class_goog_Uri.html
 * [RFC-3986]: http://tools.ietf.org/html/rfc3986#section-4.3)
 * [RFC-2732]: http://www.ietf.org/rfc/rfc2732.txt
 */
class Uri {
  final String scheme;
  final String userInfo;
  final String domain;
  final int port;
  final String path;
  final String query;
  final String fragment;

  static Uri parse(String uri) => new Uri._fromMatch(_splitRe.firstMatch(uri));

  Uri._fromMatch(Match m) :
    this.fromComponents(scheme: _emptyIfNull(m[_COMPONENT_SCHEME]),
                        userInfo: _emptyIfNull(m[_COMPONENT_USER_INFO]),
                        domain: _eitherOf(
                            m[_COMPONENT_DOMAIN], m[_COMPONENT_DOMAIN_IPV6]),
                        port: _parseIntOrZero(m[_COMPONENT_PORT]),
                        path: _emptyIfNull(m[_COMPONENT_PATH]),
                        query: _emptyIfNull(m[_COMPONENT_QUERY_DATA]),
                        fragment: _emptyIfNull(m[_COMPONENT_FRAGMENT]));

  const Uri.fromComponents({this.scheme: "",
                            this.userInfo: "",
                            this.domain: "",
                            this.port: 0,
                            this.path: "",
                            this.query: "",
                            this.fragment: ""});

  Uri(String uri) : this._fromMatch(_splitRe.firstMatch(uri));

  static String _emptyIfNull(String val) => val != null ? val : '';

  static int _parseIntOrZero(String val) {
    if (val != null && val != '') {
      return int.parse(val);
    } else {
      return 0;
    }
  }

  static String _eitherOf(String val1, String val2) {
    if (val1 != null) return val1;
    if (val2 != null) return val2;
    return '';
  }

  // NOTE: This code was ported from: closure-library/closure/goog/uri/utils.js
  static final RegExp _splitRe = new RegExp(
      '^'
      '(?:'
        '([^:/?#.]+)'                   // scheme - ignore special characters
                                        // used by other URL parts such as :,
                                        // ?, /, #, and .
      ':)?'
      '(?://'
        '(?:([^/?#]*)@)?'               // userInfo
        '(?:'
          r'([\w\d\-\u0100-\uffff.%]*)'
                                        // domain - restrict to letters,
                                        // digits, dashes, dots, percent
                                        // escapes, and unicode characters.
          '|'
          // TODO(ajohnsen): Only allow a max number of parts?
          r'\[([A-Fa-f0-9:.]*)\])'
                                        // IPv6 domain - restrict to hex,
                                        // dot and colon.
        '(?::([0-9]+))?'                // port
      ')?'
      r'([^?#[]+)?'                     // path
      r'(?:\?([^#]*))?'                 // query
      '(?:#(.*))?'                      // fragment
      r'$');

  static const _COMPONENT_SCHEME = 1;
  static const _COMPONENT_USER_INFO = 2;
  static const _COMPONENT_DOMAIN = 3;
  static const _COMPONENT_DOMAIN_IPV6 = 4;
  static const _COMPONENT_PORT = 5;
  static const _COMPONENT_PATH = 6;
  static const _COMPONENT_QUERY_DATA = 7;
  static const _COMPONENT_FRAGMENT = 8;

  /**
   * Returns `true` if the URI is absolute.
   */
  bool get isAbsolute {
    if ("" == scheme) return false;
    if ("" != fragment) return false;
    return true;

    /* absolute-URI  = scheme ":" hier-part [ "?" query ]
     * hier-part   = "//" authority path-abempty
     *             / path-absolute
     *             / path-rootless
     *             / path-empty
     *
     * path          = path-abempty    ; begins with "/" or is empty
     *               / path-absolute   ; begins with "/" but not "//"
     *               / path-noscheme   ; begins with a non-colon segment
     *               / path-rootless   ; begins with a segment
     *               / path-empty      ; zero characters
     *
     * path-abempty  = *( "/" segment )
     * path-absolute = "/" [ segment-nz *( "/" segment ) ]
     * path-noscheme = segment-nz-nc *( "/" segment )
     * path-rootless = segment-nz *( "/" segment )
     * path-empty    = 0<pchar>
     * segment       = *pchar
     * segment-nz    = 1*pchar
     * segment-nz-nc = 1*( unreserved / pct-encoded / sub-delims / "@" )
     *               ; non-zero-length segment without any colon ":"
     *
     * pchar         = unreserved / pct-encoded / sub-delims / ":" / "@"
     */
  }

  Uri resolve(String uri) {
    return resolveUri(Uri.parse(uri));
  }

  Uri resolveUri(Uri reference) {
    // From RFC 3986.
    String targetScheme;
    String targetUserInfo;
    String targetDomain;
    int targetPort;
    String targetPath;
    String targetQuery;
    if (reference.scheme != "") {
      targetScheme = reference.scheme;
      targetUserInfo = reference.userInfo;
      targetDomain = reference.domain;
      targetPort = reference.port;
      targetPath = removeDotSegments(reference.path);
      targetQuery = reference.query;
    } else {
      if (reference.hasAuthority) {
        targetUserInfo = reference.userInfo;
        targetDomain = reference.domain;
        targetPort = reference.port;
        targetPath = removeDotSegments(reference.path);
        targetQuery = reference.query;
      } else {
        if (reference.path == "") {
          targetPath = this.path;
          if (reference.query != "") {
            targetQuery = reference.query;
          } else {
            targetQuery = this.query;
          }
        } else {
          if (reference.path.startsWith("/")) {
            targetPath = removeDotSegments(reference.path);
          } else {
            targetPath = removeDotSegments(merge(this.path, reference.path));
          }
          targetQuery = reference.query;
        }
        targetUserInfo = this.userInfo;
        targetDomain = this.domain;
        targetPort = this.port;
      }
      targetScheme = this.scheme;
    }
    return new Uri.fromComponents(scheme: targetScheme,
                                  userInfo: targetUserInfo,
                                  domain: targetDomain,
                                  port: targetPort,
                                  path: targetPath,
                                  query: targetQuery,
                                  fragment: reference.fragment);
  }

  bool get hasAuthority {
    return (userInfo != "") || (domain != "") || (port != 0);
  }

  /**
   * For http/https schemes returns URI's [origin][] - scheme://domain:port.
   * For all other schemes throws ArgumentError.
   * [origin]: http://www.w3.org/TR/2011/WD-html5-20110405/origin-0.html#origin
   */
  String get origin {
    if (scheme == "") {
      // TODO(aprelev@gmail.com): Use StateException instead
      throw new ArgumentError("Cannot use origin without a scheme");
    }
    if (scheme != "http" && scheme != "https") {
      // TODO(aprelev@gmail.com): Use StateException instead
      throw new ArgumentError(
        "origin is applicable to http/https schemes only. Not \'$scheme\'");
    }
    StringBuffer sb = new StringBuffer();
    sb.write(scheme);
    sb.write(":");
    if (domain == null || domain == "") {
      // TODO(aprelev@gmail.com): Use StateException instead
      throw new ArgumentError("Cannot use origin without a domain");
    }

    sb.write("//");
    sb.write(domain);
    if (port != 0) {
      sb.write(":");
      sb.write(port);
    }
    return sb.toString();
  }

  String toString() {
    StringBuffer sb = new StringBuffer();
    _addIfNonEmpty(sb, scheme, scheme, ':');
    if (hasAuthority || (scheme == "file")) {
      sb.write("//");
      _addIfNonEmpty(sb, userInfo, userInfo, "@");
      sb.write(domain == null ? "null" :
          domain.contains(':') ? '[$domain]' : domain);
      if (port != 0) {
        sb.write(":");
        sb.write(port.toString());
      }
    }
    sb.write(path == null ? "null" : path);
    _addIfNonEmpty(sb, query, "?", query);
    _addIfNonEmpty(sb, fragment, "#", fragment);
    return sb.toString();
  }

  bool operator==(other) {
    if (other is! Uri) return false;
    Uri uri = other;
    return scheme == uri.scheme &&
        userInfo == uri.userInfo &&
        domain == uri.domain &&
        port == uri.port &&
        path == uri.path &&
        query == uri.query &&
        fragment == uri.fragment;
  }

  int get hashCode {
    int combine(part, current) {
      // The sum is truncated to 30 bits to make sure it fits into a Smi.
      return (current * 31 + part.hashCode) & 0x3FFFFFFF;
    }
    return combine(scheme, combine(userInfo, combine(domain, combine(port,
        combine(path, combine(query, combine(fragment, 1)))))));
  }

  static void _addIfNonEmpty(StringBuffer sb, String test,
                             String first, String second) {
    if ("" != test) {
      sb.write(first == null ? "null" : first);
      sb.write(second == null ? "null" : second);
    }
  }
}