import 'dart:core';
import 'dart:io';

import 'package:test/test.dart';
import 'package:webfeed/webfeed.dart';

import 'package:webfeed/domain/rss_itunes_type.dart';
import 'package:webfeed/domain/rss_itunes_episode_type.dart';

void main() {
  test("parse Invalid.xml", () {
    var xmlString = new File("test/xml/Invalid.xml").readAsStringSync();

    try {
      new RssFeed.parse(xmlString);
      fail("Should throw Argument Error");
    } on ArgumentError {}
  });
  test("parse RSS.xml", () {
    var xmlString = new File("test/xml/RSS.xml").readAsStringSync();

    var feed = new RssFeed.parse(xmlString);

    expect(feed.title, "News - Foo bar News");
    expect(feed.description,
        "Foo bar News and Updates feed provided by Foo bar, Inc.");
    expect(feed.link, "https://foo.bar.news/");
    expect(feed.author, "hello@world.net");
    expect(feed.language, "en-US");
    expect(feed.lastBuildDate, "Mon, 26 Mar 2018 14:00:00 PDT");
    expect(feed.generator, "Custom");
    expect(feed.copyright, "Copyright 2018, Foo bar Inc.");
    expect(feed.docs, "https://foo.bar.news/docs");
    expect(feed.managingEditor, "alice@foo.bar.news");
    expect(feed.rating, "The PICS rating of the feed");
    expect(feed.webMaster, "webmaster@foo.bar.news");
    expect(feed.ttl, 60);

    expect(feed.image.title, "Foo bar News");
    expect(feed.image.url, "https://foo.bar.news/logo.gif");
    expect(feed.image.link, "https://foo.bar.news/");

    expect(feed.cloud.domain, "radio.foo.bar.news");
    expect(feed.cloud.port, "80");
    expect(feed.cloud.path, "/RPC2");
    expect(feed.cloud.registerProcedure, "foo.bar.rssPleaseNotify");
    expect(feed.cloud.protocol, "xml-rpc");

    expect(feed.categories.length, 2);
    expect(feed.categories[0].domain, null);
    expect(feed.categories[0].value, "Ipsum");
    expect(feed.categories[1].domain, "news");
    expect(feed.categories[1].value, "Lorem Ipsum");

    expect(feed.skipDays.length, 3);
    expect(feed.skipDays.contains("Monday"), true);
    expect(feed.skipDays.contains("Tuesday"), true);
    expect(feed.skipDays.contains("Sunday"), true);

    expect(feed.skipHours.length, 5);
    expect(feed.skipHours.contains(0), true);
    expect(feed.skipHours.contains(1), true);
    expect(feed.skipHours.contains(2), true);
    expect(feed.skipHours.contains(3), true);
    expect(feed.skipHours.contains(4), true);

    expect(feed.items.length, 2);

    expect(feed.items.first.title,
        "The standard Lorem Ipsum passage, used since the 1500s");
    expect(feed.items.first.description,
        "Lorem ipsum dolor sit amet, consectetur adipiscing elit");
    expect(feed.items.first.link, "https://foo.bar.news/1");
    expect(feed.items.first.guid, "https://foo.bar.news/1?guid");
    expect(feed.items.first.pubDate, "Mon, 26 Mar 2018 14:00:00 PDT");
    expect(feed.items.first.categories.first.domain, "news");
    expect(feed.items.first.categories.first.value, "Lorem");
    expect(feed.items.first.author, "alice@foo.bar.news");
    expect(feed.items.first.source.url, "https://foo.bar.news/1?source");
    expect(feed.items.first.source.value, "Foo Bar");
    expect(feed.items.first.comments, "https://foo.bar.news/1/comments");
    expect(feed.items.first.enclosure.url,
        "http://www.scripting.com/mp3s/weatherReportSuite.mp3");
    expect(feed.items.first.enclosure.length, 12216320);
    expect(feed.items.first.enclosure.type, "audio/mpeg");

    expect(feed.items.first.content.value,
        "<img width=\"1000\" height=\"690\" src=\"https://test.com/image_link\"/> Test content<br />");
    expect(
        feed.items.first.content.images.first, "https://test.com/image_link");
  });
  test("parse RSS-Media.xml", () {
    var xmlString = new File("test/xml/RSS-Media.xml").readAsStringSync();

    var feed = new RssFeed.parse(xmlString);
    expect(feed.title, "Song Site");
    expect(
        feed.description, "Media RSS example with new fields added in v1.5.0");

    expect(feed.items.length, 1);

    var item = feed.items.first;
    expect(item.title, null);
    expect(item.link, "http://www.foo.com");
    expect(item.pubDate, "Mon, 27 Aug 2001 16:08:56 PST");

    expect(item.media.group.contents.length, 5);
    expect(item.media.group.credits.length, 2);
    expect(item.media.group.category.value, "music/artist name/album/song");
    expect(item.media.group.rating.value, "nonadult");

    expect(item.media.contents.length, 2);
    var mediaContent = item.media.contents.first;
    expect(mediaContent.url, "http://www.foo.com/video.mov");
    expect(mediaContent.type, "video/quicktime");
    expect(mediaContent.fileSize, 2000);
    expect(mediaContent.medium, "video");
    expect(mediaContent.isDefault, true);
    expect(mediaContent.expression, "full");
    expect(mediaContent.bitrate, 128);
    expect(mediaContent.framerate, 25);
    expect(mediaContent.samplingrate, 44.1);
    expect(mediaContent.channels, 2);

    expect(item.media.credits.length, 2);
    var mediaCredit = item.media.credits.first;
    expect(mediaCredit.role, "owner1");
    expect(mediaCredit.scheme, "urn:yvs");
    expect(mediaCredit.value, "copyright holder of the entity");

    expect(item.media.category.scheme,
        "http://search.yahoo.com/mrss/category_ schema");
    expect(item.media.category.label, "Music");
    expect(item.media.category.value, "music/artist/album/song");

    expect(item.media.rating.scheme, "urn:simple");
    expect(item.media.rating.value, "adult");

    expect(item.media.title.type, "plain");
    expect(item.media.title.value, "The Judy's -- The Moo Song");

    expect(item.media.description.type, "plain");
    expect(item.media.description.value,
        "This was some really bizarre band I listened to as a young lad.");

    expect(item.media.keywords, "kitty, cat, big dog, yarn, fluffy");

    expect(item.media.thumbnails.length, 2);
    var mediaThumbnail = item.media.thumbnails.first;
    expect(mediaThumbnail.url, "http://www.foo.com/keyframe1.jpg");
    expect(mediaThumbnail.width, "75");
    expect(mediaThumbnail.height, "50");
    expect(mediaThumbnail.time, "12:05:01.123");

    expect(item.media.hash.algo, "md5");
    expect(item.media.hash.value, "dfdec888b72151965a34b4b59031290a");

    expect(item.media.player.url, "http://www.foo.com/player?id=1111");
    expect(item.media.player.width, 400);
    expect(item.media.player.height, 200);
    expect(item.media.player.value, "");

    expect(item.media.copyright.url, "http://blah.com/additional-info.html");
    expect(item.media.copyright.value, "2005 FooBar Media");

    expect(item.media.text.type, "plain");
    expect(item.media.text.lang, "en");
    expect(item.media.text.start, "00:00:03.000");
    expect(item.media.text.end, "00:00:10.000");
    expect(item.media.text.value, " Oh, say, can you see");

    expect(item.media.restriction.relationship, "allow");
    expect(item.media.restriction.type, "country");
    expect(item.media.restriction.value, "au us");

    expect(item.media.community.starRating.average, 3.5);
    expect(item.media.community.starRating.count, 20);
    expect(item.media.community.starRating.min, 1);
    expect(item.media.community.starRating.max, 10);
    expect(item.media.community.statistics.views, 5);
    expect(item.media.community.statistics.favorites, 4);
    expect(item.media.community.tags.tags, "news: 5, abc:3");
    expect(item.media.community.tags.weight, 1);

    expect(item.media.comments.length, 2);
    expect(item.media.comments.first, "comment1");
    expect(item.media.comments.last, "comment2");

    expect(item.media.embed.url, "http://www.foo.com/player.swf");
    expect(item.media.embed.width, 512);
    expect(item.media.embed.height, 323);
    expect(item.media.embed.params.length, 5);
    expect(item.media.embed.params.first.name, "type");
    expect(
        item.media.embed.params.first.value, "application/x-shockwave-flash");

    expect(item.media.responses.length, 2);
    expect(item.media.responses.first, "http://www.response1.com");
    expect(item.media.responses.last, "http://www.response2.com");

    expect(item.media.backLinks.length, 2);
    expect(item.media.backLinks.first, "http://www.backlink1.com");
    expect(item.media.backLinks.last, "http://www.backlink2.com");

    expect(item.media.status.state, "active");
    expect(item.media.status.reason, null);

    expect(item.media.prices.length, 2);
    expect(item.media.prices.first.price, 19.99);
    expect(item.media.prices.first.type, "rent");
    expect(
        item.media.prices.first.info, "http://www.dummy.jp/package_info.html");
    expect(item.media.prices.first.currency, "EUR");

    expect(item.media.license.type, "text/html");
    expect(item.media.license.href, "http://www.licensehost.com/license");
    expect(item.media.license.value, " Sample license for a video");

    expect(item.media.peerLink.type, "application/x-bittorrent");
    expect(item.media.peerLink.href, "http://www.foo.org/sampleFile.torrent");
    expect(item.media.peerLink.value, "");

    expect(item.media.rights.status, "official");

    expect(item.media.scenes.length, 2);
    expect(item.media.scenes.first.title, "sceneTitle1");
    expect(item.media.scenes.first.description, "sceneDesc1");
    expect(item.media.scenes.first.startTime, "00:15");
    expect(item.media.scenes.first.endTime, "00:45");
  });
  test("parse RSS-DC.xml", () {
    var xmlString = File("test/xml/RSS-DC.xml").readAsStringSync();

    var feed = RssFeed.parse(xmlString);

    expect(feed.dc.title, "title");
    expect(feed.dc.creator, "creator");
    expect(feed.dc.subject, "subject");
    expect(feed.dc.description, "description");
    expect(feed.dc.publisher, "publisher");
    expect(feed.dc.contributor, "contributor");
    expect(feed.dc.date, "2000-01-01T12:00+00:00");
    expect(feed.dc.type, "type");
    expect(feed.dc.format, "format");
    expect(feed.dc.identifier, "identifier");
    expect(feed.dc.source, "source");
    expect(feed.dc.language, "language");
    expect(feed.dc.relation, "relation");
    expect(feed.dc.coverage, "coverage");
    expect(feed.dc.rights, "rights");

    expect(feed.items.first.dc.title, "title");
    expect(feed.items.first.dc.creator, "creator");
    expect(feed.items.first.dc.subject, "subject");
    expect(feed.items.first.dc.description, "description");
    expect(feed.items.first.dc.publisher, "publisher");
    expect(feed.items.first.dc.contributor, "contributor");
    expect(feed.items.first.dc.date, "2000-01-01T12:00+00:00");
    expect(feed.items.first.dc.type, "type");
    expect(feed.items.first.dc.format, "format");
    expect(feed.items.first.dc.identifier, "identifier");
    expect(feed.items.first.dc.source, "source");
    expect(feed.items.first.dc.language, "language");
    expect(feed.items.first.dc.relation, "relation");
    expect(feed.items.first.dc.coverage, "coverage");
    expect(feed.items.first.dc.rights, "rights");
  });

  test("parse RSS-Empty.xml", () {
    var xmlString = File("test/xml/RSS-Empty.xml").readAsStringSync();

    var feed = RssFeed.parse(xmlString);

    expect(feed.title, null);
    expect(feed.description, null);
    expect(feed.link, null);
    expect(feed.language, null);
    expect(feed.lastBuildDate, null);
    expect(feed.generator, null);
    expect(feed.copyright, null);
    expect(feed.docs, null);
    expect(feed.managingEditor, null);
    expect(feed.rating, null);
    expect(feed.webMaster, null);
    expect(feed.ttl, 0);

    expect(feed.image, null);

    expect(feed.cloud, null);

    expect(feed.categories.length, 0);

    expect(feed.skipDays.length, 0);

    expect(feed.skipHours.length, 0);

    expect(feed.items.length, 1);

    expect(feed.items.first.title, null);
    expect(feed.items.first.description, null);
    expect(feed.items.first.link, null);
    expect(feed.items.first.guid, null);
    expect(feed.items.first.pubDate, null);
    expect(feed.items.first.categories.length, 0);
    expect(feed.items.first.author, null);
    expect(feed.items.first.source, null);
    expect(feed.items.first.comments, null);
    expect(feed.items.first.enclosure, null);

    expect(feed.items.first.content, null);
  });

  test("parse RSS-Itunes.xml", () {
    var xmlString = File("test/xml/RSS-Itunes.xml").readAsStringSync();

    var feed = RssFeed.parse(xmlString);

    expect(feed.itunes.author, "Changelog Media");
    expect(feed.itunes.summary, "Foo");
    expect(feed.itunes.explicit, false);
    expect(feed.itunes.image.href,
        "https://cdn.changelog.com/uploads/covers/go-time-original.png?v=63725770357");
    expect(feed.itunes.keywords,
        "go,golang,open source,software,development".split(","));
    expect(feed.itunes.owner.name, "Changelog Media");
    expect(feed.itunes.owner.email, "editors@changelog.com");
    expect(
        Set.from([
          feed.itunes.categories[0].category,
          feed.itunes.categories[1].category
        ]),
        ["Technology", "Foo"]);
    for (var category in feed.itunes.categories) {
      switch (category.category) {
        case "Foo":
          expect(category.subCategories, ["Bar", "Baz"]);
          break;
        case "Technology":
          expect(category.subCategories, ["Software How-To", "Tech News"]);
          break;
      }
    }
    expect(feed.itunes.title, "Go Time");
    expect(feed.itunes.type, RssItunesType.serial);
    expect(feed.itunes.newFeedUrl, "wubawuba");
    expect(feed.itunes.block, true);
    expect(feed.itunes.complete, true);

    var item = feed.items[0];
    expect(item.itunes.episodeType, RssItunesEpisodeType.full);
    expect(item.itunes.episode, 1);
    expect(item.itunes.season, 1);
    expect(item.itunes.image.href,
        "https://cdn.changelog.com/uploads/covers/go-time-original.png?v=63725770357");
    expect(item.itunes.duration, Duration(minutes: 32, seconds: 30));
    expect(item.itunes.explicit, false);
    expect(item.itunes.keywords,
        "go,golang,open source,software,development".split(","));
    expect(item.itunes.subtitle, "with Erik, Carlisia, and Brian");
    expect(item.itunes.summary, "Foo");
    expect(item.itunes.author,
        "Erik St. Martin, Carlisia Pinto, and Brian Ketelsen");
    expect(item.itunes.explicit, false);
    expect(item.itunes.title, "awesome title");
    expect(item.itunes.block, false);
  });
}