# -*- encoding : utf-8 -*-

describe Card::Content::Chunk::URI, "URI chunk tests" do
  it "should test_non_matches" do
    no_match_uri "There is no URI here"
    no_match_uri "One gemstone is the garnet:reddish in colour, like ruby"
  end

  it "works with simple uri" do
    # Simplest case
    match_http_uri "http://www.example.com",
                   host: "www.example.com", path: ""
  end
  it "works with trailing slash" do
    match_http_uri "http://www.example.com/",
                   host: "www.example.com", path: "/"
  end
  it "works with trailing slash inside html tags" do
    match_http_uri "<p>http://www.example.com/</p>",
                   host: "www.example.com", path: "/",
                   link_text: "http://www.example.com/"
  end
  it "works with trailing period (no longer suppressed .. spec?)" do
    match_http_uri "http://www.example.com/. ",
                   host: "www.example.com", path: "/",
                   link_text: "http://www.example.com/"
  end
  it "works with trailing period inside html tags (dot change?)" do
    match_http_uri "<p>http://www.example.com/.</p>",
                   host: "www.example.com", path: "/",
                   link_text: "http://www.example.com/"
  end
  it "works with trailing &nbsp;" do
    match_http_uri "http://www.example.com/&nbsp;",
                   host: "www.example.com", path: "/",
                   link_text: "http://www.example.com/"
  end
  it "works without http://" do
    match_http_uri "www.example.com",
                   host: "www.example.com",
                   text: "www.example.com",
                   link_text: "http://www.example.com"
    match_http_uri "example.com",
                   host: "example.com",
                   text: "example.com",
                   link_text: "http://example.com"
  end
  it 'should match "unusual" base domain (was a bug in an early version)' do
    match_http_uri "http://example.com.au/",
                   host: "example.com.au"
  end
  it 'works with "unusual" base domain without http://' do
    match_http_uri "example.com.au",
                   host: "example.com.au",
                   text: "example.com.au",
                   link_text: "http://example.com.au"
  end
  it 'works with another "unusual" base domain' do
    match_http_uri "http://www.example.co.uk/",
                   host: "www.example.co.uk"
    match_http_uri "example.co.uk",
                   host: "example.co.uk",
                   text: "example.co.uk",
                   link_text: "http://example.co.uk"
  end
  it "works with some path at the end" do
    match_http_uri "http://moinmoin.wikiwikiweb.de/HelpOnNavigation",
                   host: "moinmoin.wikiwikiweb.de",
                   path: "/HelpOnNavigation"
  end
  it "works with some path at the end, and without http:// prefix "\
     "(@link_text has prefix added)" do
    match_http_uri "moinmoin.wikiwikiweb.de/HelpOnNavigation",
                   host: "moinmoin.wikiwikiweb.de",
                   path: "/HelpOnNavigation",
                   text: "moinmoin.wikiwikiweb.de/HelpOnNavigation",
                   link_text: "http://moinmoin.wikiwikiweb.de/HelpOnNavigation"
  end
  it "works with a port number" do
    match_http_uri "http://www.example.com:80",
                   host: "www.example.com", port: 80,
                   path: ""
  end
  it "works with a port number and a path" do
    match_http_uri "http://www.example.com.tw:80/HelpOnNavigation",
                   host: "www.example.com.tw", port: 80,
                   path: "/HelpOnNavigation"
  end
  it "works with a query" do
    match_http_uri "http://www.example.com.tw:80/HelpOnNavigation?arg=val",
                   host: "www.example.com.tw", port: 80,
                   path: "/HelpOnNavigation", query: "arg=val"
  end
  it "works on Query with two arguments" do
    match_http_uri "http://www.example.com.tw:80/HelpOnNavigation"\
                   "?arg=val&arg2=val2",
                   host: "www.example.com.tw", port: 80,
                   path: "/HelpOnNavigation", query: "arg=val&arg2=val2"
  end
  it "works with IRC" do
    match_uri "irc://irc.freenode.net#recentchangescamp",
              scheme: "irc", host: "irc.freenode.net",
              fragment: "recentchangescamp",
              link_text: "irc://irc.freenode.net#recentchangescamp"
  end

  it "should see HTTPS" do
    match_uri "https://www.example.com",
              scheme: "https", host: "www.example.com", port: 443,
              path: "", query: nil
  end
  it "should see FTP" do
    match_uri "ftp://www.example.com",
              scheme: "ftp", host: "www.example.com", port: 21,
              path: "", query: nil
  end
  it "should handle mailto:" do
    match_uri "mailto:jdoe123@example.com",
              scheme: "mailto", host: nil, port: nil,
              path: nil, query: nil,
              to: "jdoe123@example.com"
  end

  it "should run more basic cases" do
    # from *css (with () around the URI)
    # so, now this doesn't even match because I fixed the suspiciou* stuff
    no_match_uri(
      "background: url('http://dl.dropbox.com/u/4657397/wikirate/" \
      "wikirate_files/wr-bg-menu-line.gif') repeat-x;"
    )

    # Soap opera (the most complex case imaginable... well, not really, there
    # should be more evil)
    match_http_uri(
      "http://www.example.com.tw:80/~jdoe123/Help%20Me%20?arg=val&arg2=val2",
      host: "www.example.com.tw", port: 80,
      path: "/~jdoe123/Help%20Me%20", query: "arg=val&arg2=val2"
    )

    # from 0.9 bug reports
    match_uri "http://www2.pos.to/~tosh/ruby/rdtool/en/doc/rd-draft.html",
              scheme: "http", host: "www2.pos.to",
              path: "/~tosh/ruby/rdtool/en/doc/rd-draft.html"

    match_uri "http://support.microsoft.com/default.aspx?scid=kb;en-us;234562",
              scheme: "http", host: "support.microsoft.com",
              path: "/default.aspx", query: "scid=kb;en-us;234562"
  end

  it "should test_email_uri" do
    match_uri "mail@example.com",
              to: "mail@example.com", host: nil,
              text: "mail@example.com",
              link_text: "mailto:mail@example.com"
  end

  it "should test_non_email" do
    # The @ is part of the normal text, but 'example.com' is marked up.
    match_uri "Not an email: @example.com", uri: "http://example.com"
  end

  it "should test_textile_image" do
    no_match_uri "This !http://hobix.com/sample.jpg! is a Textile image link."
  end

  it "should test_textile_link" do
    no_match_uri(
      'This "hobix (hobix)":http://hobix.com/sample.jpg is a Textile link.'
    )
    # just to be sure ...
    match_uri "This http://hobix.com/sample.jpg should match",
              link_text: "http://hobix.com/sample.jpg"
  end

  it "should test_inline_html" do
    no_match_uri "<img src='http://hobix.com/sample.jpg'/>"
    no_match_uri '<IMG SRC="http://hobix.com/sample.jpg">'
  end

  it "should test_non_uri" do
    # "so" is a valid country code; "libproxy.so" is a valid url
    match_uri "libproxy.so", host: "libproxy.so",
                             text: "libproxy.so",
                             link_text: "http://libproxy.so"

    no_match_uri "httpd.conf"
    # THIS ONE'S BUSTED.. Ethan fix??
    # no_match_uri 'ld.so.conf'
    no_match_uri "index.jpeg"
    no_match_uri "index.jpg"
    no_match_uri "file.txt"
    no_match_uri "file.doc"
    no_match_uri "file.pdf"
    no_match_uri "file.png"
    no_match_uri "file.ps"
  end

  it "should test_uri_in_text" do
    match_uri "Go to: http://www.example.com/",
              host: "www.example.com", path: "/"
    match_uri "http://www.example.com/ is a link.", host: "www.example.com"
    match_uri "Email david@loudthinking.com",
              scheme: "mailto", to: "david@loudthinking.com", host: nil
    # check that trailing punctuation is not included in the hostname
    match_uri "Hey dude, http://fake.link.com.",
              scheme: "http", host: "fake.link.com"
    # this is a textile link, no match please.
    no_match_uri '"link":http://fake.link.com.'
  end

  it "should test_uri_in_parentheses" do
    match_uri "URI (http://brackets.com.de) in brackets",
              host: "brackets.com.de"
    match_uri "because (as shown at research.net) the results",
              host: "research.net"
    match_uri "A wiki (http://wiki.org/wiki.cgi?WhatIsWiki) card",
              scheme: "http", host: "wiki.org", path: "/wiki.cgi",
              query: "WhatIsWiki"
  end

  it "should test_uri_list_item" do
    match_chunk(
      Card::Content::Chunk::URI,
      "* http://www.btinternet.com/~mail2minh/SonyEricssonP80xPlatform.sis",
      path: "/~mail2minh/SonyEricssonP80xPlatform.sis"
    )
  end

  it "should test_interesting_uri_with__comma" do
    # Counter-intuitively, this URL matches, but the query part includes the
    # trailing comma.
    # It has no way to know that the query does not include the comma.
    # The trailing , addition breaks this test, but is this test actually valid?
    # It seems better to exclude the comma from the uri, YMMV
    match_uri(
      "This text contains a URL http://someplace.org:8080/~person/stuff.cgi" \
      "?arg=val, doesn't it?",
      scheme: "http", host: "someplace.org", port: 8080,
      path: "/~person/stuff.cgi", query: "arg=val"
    )
  end

  describe Card::Content::Chunk::URI, "URI chunk tests" do
    it "should test_local_urls" do
      # normal
      match_http_uri "http://perforce:8001/toto.html",
                     host: "perforce", port: 8001
      # in parentheses
      match_uri "URI (http://localhost:2500) in brackets",
                host: "localhost", port: 2500
      match_uri "because (as shown at http://perforce:8001) the results",
                host: "perforce", port: 8001
      match_uri "A wiki (http://localhost:2500/wiki.cgi?WhatIsWiki) card",
                scheme: "http", host: "localhost", path: "/wiki.cgi",
                port: 2500, query: "WhatIsWiki"
    end
  end

  private

  DUMMY_CARD = Card.new(name: "dummy")

  # Asserts a number of tests for the given type and text.
  def no_match type, test_text
    expect(get_chunk(type, test_text)).to be_nil
  end

  def match_chunk type, test_text, expected
    chunk = get_chunk(type, test_text)
    expect(chunk).not_to be_nil

    expected.each_pair do |method_sym, value|
      # assert_respond_to(chunk, method_sym)
      cvalue = chunk.method(method_sym).call
      cvalue = cvalue.to_s if method_sym == :uri
      assert_equal(value, cvalue, "Checking value of '#{method_sym}'")
    end
  end

  def match_uri uri, opts
    match_chunk Card::Content::Chunk::URI, uri, opts
  end

  def no_match_uri text
    no_match Card::Content::Chunk::URI, text
  end

  def match_http_uri uri, opts
    match_uri uri, opts.reverse_merge(link_text: uri, scheme: "http")
  end

  def get_chunk type, test_text
    cont = Card::Content.new(test_text, DUMMY_CARD)
    cont = [cont] unless cont.respond_to?(:each)
    cont.find { |ck| ck.is_a? type }
  end
end