private static boolean addHuluOrCBSTvEpisodeMetaData(
      MyLibraryFile video, String seasonEpisodeNaming) {
    // parse season/episode numbers
    try {
      // get the series and title
      boolean normalMethodSuccess = Archiver.addTVMetaDataFromSxxExx(video, seasonEpisodeNaming);
      if (!normalMethodSuccess) {
        // This means the series title comes before this in the fileLabel
        // looks like: "Pretty Little Liars - s1e1 - Pilot" or "Pretty Little Liars - s1e1: Pilot"
        String[] splitters =
            new String[] {" - " + seasonEpisodeNaming + " - ", " - " + seasonEpisodeNaming + ": "};
        for (String matchOn : splitters) {
          int matchIndex = video.getFileLabel().indexOf(matchOn);
          if (matchIndex != -1) {
            video.setSeries(video.getFileLabel().substring(0, matchIndex));
            // get the title
            video.setTitle(
                video
                    .getFileLabel()
                    .substring(matchIndex + matchOn.length(), video.getFileLabel().length()));
            break;
          }
        }
      }

      if (!valid(video.getSeries())) {
        Logger.WARN("Series cannot be found from Hulu/CBS path: " + video.getFullPathEscaped());
        return false;
      }

      // get the title (not required for scraping
      if (!valid(video.getTitle())) {
        Logger.INFO(
            "Title cannot be parsed for this video, it will be set to the file name: \""
                + video.getFileLabel()
                + "\"");
        video.setTitle(video.getFileLabel());
      }
      return true;
    } catch (Exception x) {
      Logger.WARN(
          "This Hulu/CBS video was thought to be a TV show, but the season/episode numbers and/or title could not be parsed: "
              + video.getFullPathEscaped(),
          x);
      return false;
    }
  }
  public static boolean doHuluCBS(MyLibraryFile video, boolean isHulu, boolean isCBS) {
    String matchingPattern = null;
    if (!video.knownType() || video.isTvShow()) {
      Pattern seasonEpisodePattern = Pattern.compile("s[0-9]+e[0-9]+", Pattern.CASE_INSENSITIVE);
      Matcher seasonEpisodeMatcher = seasonEpisodePattern.matcher(video.getFullPath());
      boolean match = seasonEpisodeMatcher.find();
      if (match) {
        matchingPattern = seasonEpisodeMatcher.group();
        video.setType(TV_SHOW);
      } else if (!video.isTvShow()) // dont over-ride config param
      video.setType(MOVIE);
    }

    boolean success;
    if (video.isTvShow()) success = addHuluOrCBSTvEpisodeMetaData(video, matchingPattern);
    else if (video.isMovie()) {
      video.setTitle(video.getFileLabel());
      success = valid(video.getTitle());
    } else // do hulu/cbs have music videos?
    {
      Logger.WARN(
          "Cannot Archive: Type of content cannot be auto-determined for Hulu video: "
              + video.getFullPathEscaped());
      success = false;
    }

    Logger.DEBUG(
        (isCBS ? "CBS" : "Hulu")
            + ": success="
            + success
            + "; "
            + (video.isTvShow()
                ? "TV: series="
                    + video.getSeries()
                    + "; title="
                    + video.getTitle()
                    + ", "
                    + "season="
                    + video.getSeasonNumber()
                    + ", episode="
                    + video.getEpisodeNumber()
                : "Movie: " + video.getTitle())
            + " --- "
            + video.getFullPathEscaped());
    return success;
  }
Beispiel #3
0
  public static boolean lookupTVShow(MyLibraryFile video) {
    video.setHasBeenLookedUpOnTVDB(true);
    boolean lookupWasSuccessful = false;

    // determine if this has already been looked up successfully and skip the query
    if (video.getSubfolder() == null
        || !video.getSubfolder().forceTVDBLookup()) { // tvdb lookup is NOT forced true
      Logger.DEBUG(
          "Checking if this video has already been looked up on TVDB based on original path of: "
              + video.getFullPathEscaped());
      MyLibraryFile previouslyLookedupVideo =
          tools.getVideoFromOriginalLocation(video.getFullPath()); // not escaped

      if (previouslyLookedupVideo == null || !previouslyLookedupVideo.hasBeenLookedUpOnTVDB()) {
        Logger.INFO(
            "This video has not been succesfully looked up on the TVDB before, will attempt lookup now.");
      } else {
        if (previouslyLookedupVideo.hasValidMetaData()) {
          Logger.INFO(
              "This video has previously been successfully looked up on the TVDB, will use saved meta-data instead of querying TVDB.com");
          // copy over all data
          // make sure we keep the original sufolder and don't use the dummy subfolder
          Subfolder subf = video.getSubfolder();
          MyLibraryFile.copyVideoMetaData(previouslyLookedupVideo, video);
          video.setSubfolder(subf);
          return true;
        } else
          Logger.INFO(
              "This video has been queried on the TVDB before, but it was unsuccessful. Will try again now: "
                  + video.getFullPathEscaped());
      }
    } else
      Logger.DEBUG(
          "Force TVDB lookup is true, skipping DB data check and continuing with TVDB lookup.");

    String seriesTitle = video.getSeries();
    String episodeTitle = video.getTitle();
    String originalAirDate = video.getOriginalAirDate();

    boolean canLookupSeriedId = valid(seriesTitle) || video.isTVDBIdOverridden();
    if (!canLookupSeriedId) {
      Logger.WARN(
          "Cannot lookup TV series because series name is unknown: " + video.getFullPathEscaped());
      return false;
    }

    boolean canLookupEpisode = valid(episodeTitle) || valid(originalAirDate);
    if (!canLookupEpisode) {
      Logger.WARN(
          "Cannot lookup TV episode because neither episode title nor original air date are known: "
              + video.getFullPathEscaped());
      return false;
    }

    String tvdbURL = null;
    List<String> seriesIds = new ArrayList<String>();
    try // tvdb lookup
    {
      int maxSeries = 3;
      if (!video.isTVDBIdOverridden()) {
        tvdbURL =
            "http://www.thetvdb.com/api/GetSeries.php?seriesname="
                + java.net.URLEncoder.encode(seriesTitle, "UTF-8");
        Logger.DEBUG(
            "Attempting to get series IDs (max of "
                + maxSeries
                + ") based on seriesname of '"
                + seriesTitle
                + "', url = "
                + tvdbURL);
        java.net.URL URL = new java.net.URL(tvdbURL);
        Document xml = tools.getXMLFromURL(URL);
        List<Element> children = xml.getRootElement().getChildren();
        int seriesCount = 0;
        for (Element series : children) {
          seriesCount++;
          String seriesId = series.getChildText("seriesid");
          seriesIds.add(seriesId);
          String seriesName = series.getChildText("SeriesName");
          Logger.DEBUG(
              "Adding Series #"
                  + seriesCount
                  + " found from thetvdb: seriesName= \""
                  + seriesName
                  + "\" id = \""
                  + seriesId
                  + "\"");
          if (seriesCount == maxSeries) break;
        }
        if (seriesIds.isEmpty()) {
          Logger.WARN(
              "Ending lookup. No series could be found by querying TheTVDB: "
                  + tvdbURL
                  + ". Will try to archive this video again later.");
          return false; // unsuccessful lookup
        }
      } else {
        seriesIds.add(video.getTVDBId());
        Logger.INFO(
            "TheTVDB series ID is already known, no need to look it up. Using ID of: \""
                + video.getTVDBId()
                + "\"");
      }

      boolean originalAirDateIsAvailable = valid(tools.normalize(video.getOriginalAirDate()));
      if (!originalAirDateIsAvailable)
        Logger.DEBUG("Original air date is not known, will not try to match on it.");
      boolean episodeTitleIsAvailable = valid(tools.normalize(video.getTitle()));
      if (!episodeTitleIsAvailable)
        Logger.DEBUG("No episode title is available, will not try to match on it.");

      if (!originalAirDateIsAvailable && !episodeTitleIsAvailable) {
        Logger.WARN(
            "Neither title nor original air date are available. Need at least 1 to lookup on thetvdb.com. File = "
                + video.getFullPathEscaped()
                + ".");
        return false;
      }

      for (String seriesId : seriesIds) {
        // get episode info by orig air date and title
        tvdbURL =
            "http://www.thetvdb.com/api/"
                + Config.TVDB_API_KEY
                + "/series/"
                + seriesId
                + "/all/en.xml";

        Logger.INFO(
            "Attempting to find matching episode with"
                + (originalAirDateIsAvailable
                    ? " original air date = \"" + tools.normalize(originalAirDate) + "\""
                    : "")
                + (episodeTitleIsAvailable
                    ? " title = \"" + tools.normalize(episodeTitle) + "\""
                    : "")
                + " from thetvdb, url = "
                + tvdbURL.replace(Config.TVDB_API_KEY, Config.TVDB_API_KEY_OBSCURED));

        java.net.URL URL = new java.net.URL(tvdbURL);
        Document xml = tools.getXMLFromURL(URL);

        // TODO: implement
        // if(xml != null && xml.getRootElement() != null)
        //  addTVDBQuery(video.getFullPathToOriginalRecording(),System.currentTimeMillis());//track
        // query time to prevent overly-frequent queries

        List<Element> episodes = xml.getRootElement().getChildren("Episode");

        // if both can not be matched on, will use a single match if it exists. single match means 1
        // and only 1 episode matched on 1 of the criteria
        boolean singleMatch = false;
        boolean hasTVDBImage = false;
        String criteriaUsedForSingleMatch = null;
        String singleMatchTVDBFullInfo = null;
        Element singleMatchEpisode = null;

        Logger.DEBUG(
            "Found "
                + episodes.size()
                + " episodes for series id "
                + seriesId
                + ". Will look for match now...");
        if (episodes == null || episodes.isEmpty()) {
          Logger.WARN(
              "No episodes found on TheTVDB for series "
                  + seriesTitle
                  + " ("
                  + seriesId
                  + "). "
                  + "You may need to add the series/episodes on TheTVDB.com, or manually provide the correct TVDB id in the config file.");
          return false;
        } else // look for matching episode
        for (Iterator<Element> i = episodes.iterator(); i.hasNext(); ) {
            boolean isFuzzyMatch = false; // dfault
            boolean titleMatch = false; // dfault
            boolean dateMatch = false; // dfault
            Element episode = i.next();
            String tvdbFirstAired = episode.getChildText("FirstAired");
            String tvdbEpisodeTitle = episode.getChildText("EpisodeName");
            String tvdbSeasonNumber = episode.getChildText("SeasonNumber");
            String tvdbEpisodeNumber = episode.getChildText("EpisodeNumber");
            hasTVDBImage =
                valid(
                    episode.getChildText(
                        "filename")); // <filename> stores the path to the .jpg image for the
            // episode

            String tvdbFullInfo =
                " Season "
                    + tvdbSeasonNumber
                    + ", Episode "
                    + tvdbEpisodeNumber
                    + ", Titled \""
                    + tvdbEpisodeTitle
                    + "\", "
                    + "first aired on "
                    + tvdbFirstAired
                    + ", has episode image: "
                    + hasTVDBImage;

            if (originalAirDateIsAvailable) {
              if (tools
                  .normalize(video.getOriginalAirDate())
                  .equalsIgnoreCase(tools.normalize(tvdbFirstAired))) {
                dateMatch = true;
                Logger.DEBUG("DATE MATCH: " + tvdbFullInfo);

                if (!singleMatch) {
                  singleMatch = true;
                  criteriaUsedForSingleMatch = "Original Air Date";
                  singleMatchTVDBFullInfo = tvdbFullInfo;
                  singleMatchEpisode = episode;
                } else // single match was already found, this is another match, means not a single
                // match anymore
                {
                  singleMatch =
                      false; // a second (or greater) match was found. There is no longer a single
                  // episode match
                }
              } else
                Logger.DEBUG(
                    "NO DATE MATCH: \""
                        + tools.normalize(video.getOriginalAirDate())
                        + "\" != \""
                        + tools.normalize(tvdbFirstAired)
                        + "\"");
            } else // no orig air date avail, dont need to find a match for it
            {
              dateMatch = true;
            }

            if (episodeTitleIsAvailable) {
              boolean exactMatch =
                  tools.normalize(episodeTitle).equalsIgnoreCase(tools.normalize(tvdbEpisodeTitle));

              boolean fuzzyMatch = false;
              if (!exactMatch)
                fuzzyMatch =
                    tools.fuzzyTitleMatch(
                        episodeTitle, tvdbEpisodeTitle, 15); // allow 15 percent discrepency

              if (exactMatch || fuzzyMatch) {
                if (fuzzyMatch) isFuzzyMatch = true;
                titleMatch = true;
                Logger.DEBUG((fuzzyMatch ? "FUZZY " : "") + "TITLE MATCH: " + tvdbFullInfo);
                if (!singleMatch) {
                  singleMatch = true;
                  criteriaUsedForSingleMatch = "Episode Title";
                  singleMatchTVDBFullInfo = tvdbFullInfo;
                  singleMatchEpisode = episode;
                } else // single match was already found, this is another match, means not a single
                // match anymore
                {
                  singleMatch =
                      false; // a second (or greater) match was found. There is no longer a single
                  // episode match
                }
              }
            } else // no title is available, dont need to find a match for it
            {
              titleMatch = true;
            }

            if (titleMatch && dateMatch) {
              Logger.INFO("Title and date match, saving data for this match...");
              // add the season/episode numbers
              if (!video.addTVDBSeriesEpisodeNumbers(tvdbSeasonNumber, tvdbEpisodeNumber)) {
                Logger.ERROR(
                    "Found a match on thetvdb.com for "
                        + video.getFullPathEscaped()
                        + ", "
                        + "but the season and episode numbers are invalid (\""
                        + tvdbSeasonNumber
                        + "\", \""
                        + tvdbEpisodeNumber
                        + "\"). "
                        + "Skipping...");
                return false;
              }

              if (!valid(episodeTitle)) {
                if (valid(tvdbEpisodeTitle)) {
                  Logger.DEBUG(
                      "Setting video title to title from the TVDB: \"" + tvdbEpisodeTitle + "\"");
                  video.setTitle(tvdbEpisodeTitle);
                }
              }
              lookupWasSuccessful = true;
              Logger.INFO(
                  "SUCCESSFUL LOOKUP"
                      + (isFuzzyMatch ? " (fuzzy match)" : " (exact match)")
                      + ": Found matching episdode on thetvdb: "
                      + tvdbFullInfo);

              if (tvdbSeasonNumber.equals("0") || isFuzzyMatch) {
                if (isFuzzyMatch)
                  Logger.DEBUG(
                      "Since this was a fuzzy match, will continue to search for exact matches and only use this match if no exact matches exist.");
                else
                  Logger.DEBUG(
                      "Since the season number is zero, will continue to look for matching episodes, and use a 'regular' season matching episode if it exists. "
                          + "Otherwise will fall back to this 'special' episode.");
              } else break; // end loop
            }
          } // end looking for matching episode

        if (!lookupWasSuccessful) // if there was no traditional match, check for single criteria
        // match
        {
          if (singleMatch) {
            Logger.INFO(
                "Could not match on all criteria, but a single match was found based on "
                    + criteriaUsedForSingleMatch
                    + ". "
                    + "Will use episode info: "
                    + singleMatchTVDBFullInfo);
            String seasonNum = singleMatchEpisode.getChildText("SeasonNumber");
            String episodeNum = singleMatchEpisode.getChildText("EpisodeNumber");
            if (!video.addTVDBSeriesEpisodeNumbers(seasonNum, episodeNum)) {
              Logger.ERROR(
                  "Found a multi-part match on thetvdb.com for "
                      + video.getFullPathEscaped()
                      + ", "
                      + "but the season and episode numbers are invalid (\""
                      + seasonNum
                      + "\", \""
                      + episodeNum
                      + "\"). "
                      + "Skipping and trying again later.");
              return false;
            }
            lookupWasSuccessful = true;
          } else {
            Logger.INFO(
                "NOT FOUND: Could not find any episode that matched "
                    + (originalAirDateIsAvailable
                        ? "original air date (" + video.getOriginalAirDate() + "), "
                        : "")
                    + (episodeTitleIsAvailable ? " episode title (" + video.getTitle() + ")" : "")
                    + " for TVDB series id "
                    + seriesId
                    + "."
                    + " For video at: "
                    + video.getFullPathEscaped());
            lookupWasSuccessful = false;
          }
        } // end if lookup was unsuccessful and check for multi episode / single parameter match

        if (lookupWasSuccessful) {
          video.setTVDBId(seriesId);
          // video.setHasTVDBImage(hasTVDBImage);
          return lookupWasSuccessful;
        }
      } // end looping through series ids
      return lookupWasSuccessful; // looped through all series ids
    } catch (Exception x) {
      Logger.ERROR(
          "Failed to get episode information from the TVDB for "
              + video.getFullPathEscaped()
              + ", URL = "
              + tvdbURL,
          x);
      return false;
    }
  }
  private static boolean addNetflixTVSeriesAndTitle(MyLibraryFile video) {

    try {
      // find series and title
      String series = null, title = null;
      try // this method must be tried first (even though it matches less files); try using the
          // filename spit at ":"... catches things line Bob the Builder: Call in the Crew
      {

        if (video
            .getFileLabel()
            .contains(": ")) // somethign like /Bob the Builder: Call in the Crew
        {
          String[] sa = video.getFileLabel().split(": ");
          if (sa.length != 2)
            throw new Exception("File label contains more than one ':'. Cannot parse.");
          series = sa[0];
          title = sa[1].trim();
          boolean is24 =
              (series.trim().equals("24") || video.getFullPathEscaped().contains("/24/"))
                  && (title.toLowerCase().contains("a.m") || title.toLowerCase().contains("p.m"));
          if (!is24) // exclude 24 becuase the series should be an integer
          {
            series = "24";
            if (isInt(series)) // this is actually the episode number, not the series.
            {
              series = null;
              throw new Exception("Incorrect series (Integer found as series name)");
            }
          }
        } else throw new Exception("No colon in file label, try secondary method");
      } catch (
          Exception
              x) // try secondary method, getting series as the parent folder and the file label
                 // being the title
      {

        series = null;
        // Netflix/Instant Queue/#/30 Days/30 Days: Season 3/S03E03 - Animal Rights
        String[] folders = video.getFullPath().split(com.bradvido.xbmc.util.Constants.DELIM);
        if (folders.length > 1) {
          String parentFolder = folders[folders.length - 2]; // 30 Days: Season 3
          if (valid(parentFolder) && parentFolder.contains(": ")) {
            series = parentFolder.substring(0, parentFolder.indexOf(": "));
          }
        }

        // try looking in the folder(s) above this show for the series
        if (series == null) { // couldn't find it the conventional way
          if (Archiver.getSeriesFromParentFolder(video)) {
            series =
                video
                    .getSeries(); // series was  set in getSeriesFromParentFolder(). get it back
                                  // here for further checks
          } else {
            // didn't work try secondary method
            String[] serieses = video.getFullPath().split(com.bradvido.xbmc.util.Constants.DELIM);
            series = serieses[serieses.length - 2]; // the folder above the file name
            if (series.contains(
                ":")) // catches folders named like so: /Busytown Mysteries: Series 2/
            series = series.substring(0, series.indexOf(":"));
          }
        }

        // get title (usually split from SxxExx by one of these)
        title = video.getFileLabel(); // S03E01 - Working in a Coal Mine
        String[] splitters = new String[] {" - ", ":"};
        for (String splitter : splitters) {
          if (title.contains(splitter)) {
            title = title.substring(title.indexOf(splitter) + splitter.length(), title.length());
            break;
          }
        }
      }

      if (!valid(series)) throw new Exception("Series cannot be parsed...");
      video.setSeries(series.trim());

      if (!valid(title)) throw new Exception("Title cannot be parsed...");
      video.setTitle(title.trim());

      return true; // successfully got the series and title
      // Logger.INFO( "Netflix episode meta data: series="+file.getSeries()+";
      // title="+file.getTitle()+", season="+file.getSeasonNumber()+",
      // episode="+file.getEpidoseNumber());
    } catch (Exception x) {
      if (!valid(video.getSeries()) || !valid(video.getTitle())) {
        Logger.WARN(
            "Cannot parse, and cannot lookup Netflix TV show (series="
                + video.getSeries()
                + ", title="
                + video.getTitle()
                + ")"
                + LINE_BRK
                + video.getFullPathEscaped()
                + LINE_BRK
                + x.getMessage());
        return false;
      } else {
        Logger.INFO(
            "Cannot parse, but can lookup Netflix TV show (series="
                + video.getSeries()
                + ", title="
                + video.getTitle()
                + ")"
                + LINE_BRK
                + video.getFullPathEscaped()
                + LINE_BRK
                + x.getMessage());
        Logger.INFO("Attempting to find metadata on TheTVDB.com");
        return TVDB.lookupTVShow(video);
      }
    }
  }
  public static boolean doNetflix(MyLibraryFile video) {
    // pattern one, matches most normal TV season/episode patterns for netflix
    Pattern seasonEpisodePattern =
        Pattern.compile(
            "^S[0-9]+E[0-9]+",
            Pattern
                .CASE_INSENSITIVE); // Netflix/Instant Queue/#/30 Days/30 Days: Season 3/S03E01 -
                                    // Working in a Coal Mine
    Matcher seasonEpisodeMatcher =
        seasonEpisodePattern.matcher(video.getFileLabel()); // S03E01 - Working in a Coal Mine

    // another pattern to find when no season/series word is specified
    Pattern seasonEpisodePattern2 =
        Pattern.compile(
            "/[0-9]+/S?[0-9]+E?[0-9]+"); // Netflix/Instant Queue/Alphabetical/B/Blue's Clues/5/28:
                                         // Our Neighborhood Festival
    Matcher seasonEpisodeMatcher2 = seasonEpisodePattern2.matcher(video.getFullPathEscaped());

    // pattern that matches absolutely numbered TV shows (no season)
    Pattern absoluteEpisodePattern =
        Pattern.compile(
            "^[0-9][0-9]:"); // Netflix/Instant Queue/Alphabetical/B/The Blue Planet: Tidal Seas/01:
                             // Tidal Seas
    Matcher absoluteEpisodeMatcher =
        absoluteEpisodePattern.matcher(
            video
                .getFileLabel()); // only chck the file name because we are using the ^ start of
                                  // string regex identifier

    if (!video.knownType() || video.isTvShow()) {
      // get season and episode numbers
      try {
        if (seasonEpisodeMatcher.find()) // looks like "S03E01"
        {
          video.setType(TV_SHOW);

          String SxxExx = seasonEpisodeMatcher.group();
          Archiver.addTVMetaDataFromSxxExx(video, SxxExx);
        } else if (seasonEpisodeMatcher2.find()) {
          video.setType(TV_SHOW);
          String match = seasonEpisodeMatcher2.group(); // "/5/28:"
          String[] parts = (match.substring(1, match.indexOf(":"))).split("/"); // "5/28"
          int seasonNum = Integer.parseInt(parts[0]);
          int episodeNum = Integer.parseInt(parts[1]);
          video.setSeasonNumber(seasonNum);
          video.setEpisodeNumber(episodeNum);
        } else if (absoluteEpisodeMatcher.find()) {
          // catch something like this, which is really TV, but has no season number
          Logger.INFO(
              "This appears to be a TV episode with no Season info. Will attempt TVDB lookup, and if it fails, default to season zero: "
                  + video.getFullPathEscaped());
          video.setType(TV_SHOW);
          addNetflixTVSeriesAndTitle(video); // need series/title before lookup
          if (!TVDB.lookupTVShow(video)) {
            video.setSeasonNumber(0);
            // TODO: generate info for this automatically since it will not be scraped successfully
            String match = absoluteEpisodeMatcher.group(); // "01:"
            video.setEpisodeNumber(
                Integer.parseInt(
                    match.substring(
                        0, match.indexOf(":")))); // parse the number from something like "01:"
          }
        } else {
          Logger.DEBUG(
              "This netflix source does not match any known TV patterns. assuming it is a movie: "
                  + video.getFullPathEscaped());
          video.setType(MOVIE);
        }
      } catch (
          Exception
              x) // Netflix/Instant Queue/H/Heroes/Heroes: Season 4/S04E01 - Orientation/S04E11 -
                 // Thanksgiving
      {
        Logger.WARN(
            "Cannot parse season/episode numbers for netflix TV source: "
                + video.getFullPathEscaped(),
            x);
      }
    }

    // netflix doesn't have music videos afaik
    Logger.DEBUG(
        "Found PlayOn Netflix: "
            + (video.isTvShow() ? "TV   " : "Movie")
            + ": "
            + video.getFullPathEscaped());

    if (video.isTvShow())
      return addNetflixTVSeriesAndTitle(video); // parse netflix info from label/path
    else if (video.isMovie()) {
      video.setTitle(video.getFileLabel()); // just use the label as the title
      return valid(video.getFileLabel());
    } else {
      Logger.WARN(
          "Cannot Arvhive Playon Netflix video: Type of content cannot be auto-determined for: "
              + video.getFullPathEscaped());
      return false;
    }
  }
  public static boolean doComedyCentral(MyLibraryFile video) {
    // parse dailyshow/colbert report dates from label. Looks like "February 15, 2011 - January
    // Jones"
    String fullPath = video.getFullPathEscaped();
    boolean dailyShow = fullPath.toLowerCase().contains("/the daily show with jon stewart/");
    boolean colbert = fullPath.toLowerCase().contains("/the colbert report/");
    boolean southpark = fullPath.toLowerCase().contains("/south park/");
    if (dailyShow || colbert) {
      if (dailyShow) {
        video.setTVDBId("71256");
        video.setSeries("The Daily Show with Jon Stewart");
      }
      if (colbert) {
        video.setTVDBId("79274");
        video.setSeries("The Colbert Report");
      }
      if (!video.getFileLabel().contains(" - ")) {
        Logger.WARN(
            "Cannot parse Daily Show/Colbert Report episode because ' - ' was not found in the title");
        return false;
      }

      SimpleDateFormat dailyShowSDF = new SimpleDateFormat("MMMM dd, yyyy");
      String[] labelParts = video.getFileLabel().split(" - ");
      String textDate = labelParts[0];
      String title = labelParts[1];
      video.setTitle(title);
      Date airDate = null;
      try {
        airDate = dailyShowSDF.parse(textDate);
        video.setOriginalAirDate(tools.toTVDBAiredDate(airDate));
        Logger.DEBUG("Original Air date = " + video.getOriginalAirDate());
      } catch (Exception x) {
        Logger.WARN(
            "The PlayOn Comedy Central Daily Show/Colbert Report episode named \""
                + video.getFileLabel()
                + "\" cannot be looked up "
                + "because a date could be parsed from the title using date format: "
                + dailyShowSDF.toPattern(),
            x);
      }
      boolean successfulLookup = TVDB.lookupTVShow(video);
      if (!successfulLookup)
        Logger.WARN(
            "TVDB lookup failed for Daily Show/Cobert report episode: "
                + video.getFullPathEscaped());
      return successfulLookup;
    } else if (southpark) {
      // like: /South Park/Season 02/s02e13 - Cow Days
      Pattern seasonEpisodePattern =
          Pattern.compile("^s[0-9]+e[0-9]+ - ", Pattern.CASE_INSENSITIVE);
      Matcher seasonMatcher = seasonEpisodePattern.matcher(video.getFileLabel().trim());
      if (seasonMatcher.find()) {
        try {
          video.setType(TV_SHOW);
          String match = seasonMatcher.group();
          video.setSeasonNumber(
              Integer.parseInt(
                  match.toLowerCase().substring(match.indexOf("s") + 1, match.indexOf("e"))));
          video.setEpisodeNumber(
              Integer.parseInt(
                  match.toLowerCase().substring(match.indexOf("e") + 1, match.indexOf(" - "))));
          video.setTitle(
              video
                  .getFileLabel()
                  .substring(
                      video.getFileLabel().indexOf(match) + match.length(),
                      video.getFileLabel().length()));
          video.setSeries("South Park");
          return true;
        } catch (Exception x) {
          Logger.WARN(
              "Failed to parse PlayOn Comedy Central South park episode: "
                  + video.getFullPathEscaped(),
              x);
          return false;
        }
      } else {
        Logger.INFO(
            "Cannot find SxxExx pattern in PlayOn Comedy Central SouthPark filename, cannot archive: "
                + video.getFileLabel());
        return false;
      }
    } else // unknown type
    {
      Logger.INFO(
          "This PlayOn Comedy Central video does not have custom parsing available, will try standard parse: "
              + video.getFullPathEscaped());
      return false;
    }
  }