/**
   * Find tv episodes.
   *
   * @param tvShow the tv show
   * @param dir the dir
   */
  private void findTvEpisodes(TvShow tvShow, File dir) {
    LOGGER.debug("parsing " + dir.getPath());
    // crawl this folder and try to find every episode and its corresponding files in it
    File[] content = dir.listFiles();
    if (content == null) {
      LOGGER.error("Whops. Cannot access directory: " + dir.getName());
      return;
    }

    Arrays.sort(content);
    for (File file : content) {
      if (file.isFile()) {
        if (!file.getName().startsWith(skipFilesStartingWith)) {
          MediaFile mf = new MediaFile(file);
          // check filetype - we only proceed here if it's a video file
          if (!mf.getType().equals(MediaFileType.VIDEO)) {
            continue;
          }

          // is this file already assigned to another episode?
          List<TvShowEpisode> episodes = tvShowList.getTvEpisodesByFile(tvShow, file);
          if (episodes.size() == 0) {
            // try to check what episode//season
            // EpisodeMatchingResult result =
            // TvShowEpisodeAndSeasonParser.detectEpisodeFromFilename(file);
            String relativePath =
                new File(tvShow.getPath()).toURI().relativize(file.toURI()).getPath();
            EpisodeMatchingResult result =
                TvShowEpisodeAndSeasonParser.detectEpisodeFromFilenameAlternative(
                    relativePath, tvShow.getTitle());

            // second check: is the detected episode (>-1; season >-1) already in tmm and any valid
            // stacking markers found?
            if (result.episodes.size() == 1 && result.season > -1 && result.stackingMarkerFound) {
              // get any assigned episode
              TvShowEpisode ep = tvShow.getEpisode(result.season, result.episodes.get(0));
              if (ep != null) {
                ep.setNewlyAdded(true);
                ep.addToMediaFiles(mf);
                continue;
              }
            }

            if (result.episodes.size() == 0) {
              // try to parse out episodes/season from parent directory
              result =
                  TvShowEpisodeAndSeasonParser.detectEpisodeFromDirectory(dir, tvShow.getPath());
            }

            if (result.season == -1) {
              // did the search find a season?
              // no -> search for it in the folder name (relative path between tv show root and the
              // current dir)
              result.season = TvShowEpisodeAndSeasonParser.detectSeason(relativePath);
            }

            List<TvShowEpisode> episodesInNfo = TvShowEpisode.parseNFO(file);

            // did we find any episodes in the NFO?
            if (episodesInNfo.size() > 0) {
              // these have priority!
              for (TvShowEpisode e : episodesInNfo) {
                e.setPath(dir.getPath());
                e.setTvShow(tvShow);
                e.addToMediaFiles(mf);
                e.setDateAddedFromMediaFile(mf);
                findAdditionalEpisodeFiles(e, file, content);
                e.setNewlyAdded(true);
                e.saveToDb();
                tvShow.addEpisode(e);
              }
            } else if (result.episodes.size() > 0) {
              // something found with the season detection?
              for (int ep : result.episodes) {
                TvShowEpisode episode = new TvShowEpisode();
                episode.setDvdOrder(Globals.settings.getTvShowSettings().isDvdOrder());
                episode.setEpisode(ep);
                episode.setSeason(result.season);
                episode.setFirstAired(result.date);

                if (result.name.isEmpty()) {
                  result.name = FilenameUtils.getBaseName(file.getName());
                }
                episode.setTitle(result.name);

                episode.setPath(dir.getPath());
                episode.setTvShow(tvShow);
                episode.addToMediaFiles(mf);
                episode.setDateAddedFromMediaFile(mf);
                findAdditionalEpisodeFiles(episode, file, content);
                episode.setNewlyAdded(true);
                episode.saveToDb();
                tvShow.addEpisode(episode);
              }
            } else {
              // episode detection found nothing - simply add this file
              TvShowEpisode episode = new TvShowEpisode();
              episode.setDvdOrder(Globals.settings.getTvShowSettings().isDvdOrder());
              episode.setEpisode(-1);
              episode.setSeason(-1);
              episode.setPath(dir.getPath());

              episode.setTitle(FilenameUtils.getBaseName(file.getName()));
              episode.setTvShow(tvShow);
              episode.setFirstAired(result.date);
              episode.addToMediaFiles(mf);
              episode.setDateAddedFromMediaFile(mf);
              findAdditionalEpisodeFiles(episode, file, content);
              episode.setNewlyAdded(true);
              episode.saveToDb();
              tvShow.addEpisode(episode);
            }
          } else {
            // episode already added; look if any new additional files have been added
            for (TvShowEpisode episode : episodes) {
              if (findAdditionalEpisodeFiles(episode, file, content)) {
                episode.saveToDb();
              }
            }
          }
        } // end skipFilesStartingWith
      } // end isFile

      if (file.isDirectory()
          && !skipFolders.contains(file.getName().toUpperCase())
          && !file.getName().matches(skipFoldersRegex)
          && !TvShowModuleManager.TV_SHOW_SETTINGS
              .getTvShowSkipFolders()
              .contains(file.getAbsolutePath())) {
        // check if that directory contains a .tmmignore file
        File tmmIgnore = new File(file, ".tmmignore");
        if (!tmmIgnore.exists()) {
          // dig deeper
          if (file.getName().toUpperCase().equals("VIDEO_TS")) {
            findTvEpisodesAsDisc(tvShow, file);
          } else if (file.getName().toUpperCase().equals("BDMV")) {
            findTvEpisodesAsDisc(tvShow, file);
          } else {
            findTvEpisodes(tvShow, file);
          }
        }
      }
    }
  }
  /**
   * Find tv episodes.
   *
   * @param tvShow the tv show
   * @param dir the dir
   */
  private void findTvEpisodesAsDisc(TvShow tvShow, File dir) {
    String parentDir = dir.getParent();
    LOGGER.debug("parsing disc structure in " + dir.getPath() + " parent: " + parentDir);
    // crawl this folder and try to find every episode in it

    List<MediaFile> videoFiles = new ArrayList<MediaFile>();
    File firstVideoFile = null;

    File[] content = dir.listFiles();
    if (content == null) {
      LOGGER.error("Whops. Cannot access directory: " + dir.getName());
      return;
    }

    for (File file : content) {
      if (file.isFile()) {
        // check filetype
        if (!Globals.settings
                .getVideoFileType()
                .contains("." + FilenameUtils.getExtension(file.getName()).toLowerCase())
            || file.getName().startsWith(skipFilesStartingWith)) { // MacOS ignore
          continue;
        }

        videoFiles.add(new MediaFile(file));
        if (firstVideoFile == null) {
          firstVideoFile = file;
        }
      }
    }

    List<TvShowEpisode> episodes = tvShowList.getTvEpisodesByFile(tvShow, firstVideoFile);
    if (episodes.size() == 0) {
      String relativePath =
          new File(tvShow.getPath()).toURI().relativize(firstVideoFile.toURI()).getPath();
      EpisodeMatchingResult result =
          TvShowEpisodeAndSeasonParser.detectEpisodeFromFilenameAlternative(
              relativePath, tvShow.getTitle());

      if (result.season == -1) {
        // did the search find a season?
        // no -> search for it in the folder name (relative path between tv show root and the
        // current dir)
        result.season = TvShowEpisodeAndSeasonParser.detectSeason(relativePath);
      }

      if (result.episodes.size() == 0) {
        // try to parse out episodes/season from parent directory
        result =
            TvShowEpisodeAndSeasonParser.detectEpisodeFromDirectory(
                dir.getParentFile(), tvShow.getPath());
      }

      List<TvShowEpisode> episodesInNfo = TvShowEpisode.parseNFO(firstVideoFile);

      // FIXME: Episode root is outside of disc folders ?!
      while (dir.getPath().toUpperCase().contains("BDMV")
          || dir.getPath().toUpperCase().contains("VIDEO_TS")) {
        dir = dir.getParentFile();
      }

      if (result.episodes.size() > 0) {
        // add it
        for (int ep : result.episodes) {
          TvShowEpisode episode = null;
          // search in the NFO list if an episode has been found
          for (int i = episodesInNfo.size() - 1; i >= 0; i--) {
            TvShowEpisode e = episodesInNfo.get(i);
            if (e.getSeason() == result.season && e.getEpisode() == ep) {
              episode = e;
              episodesInNfo.remove(i);
              break;
            }
          }
          if (episode == null) {
            episode = new TvShowEpisode();
            episode.setDvdOrder(Globals.settings.getTvShowSettings().isDvdOrder());
            episode.setEpisode(ep);
            episode.setSeason(result.season);
            episode.setNewlyAdded(true);
            episode.setFirstAired(result.date);
          }

          episode.setPath(dir.getPath());
          episode.setTvShow(tvShow);
          episode.setDisc(true);
          episode.setNewlyAdded(true);
          episode.addToMediaFiles(videoFiles);
          episode.setDateAddedFromMediaFile(new MediaFile(firstVideoFile));
          findAdditionalEpisodeFiles(episode, firstVideoFile, content);
          episode.saveToDb();
          tvShow.addEpisode(episode);
        }
      } else {
        // episode detection found nothing - simply add this file
        if (episodesInNfo.size() > 0) {
          for (TvShowEpisode e : episodesInNfo) {
            e.setPath(dir.getPath());
            e.setTvShow(tvShow);
            e.addToMediaFiles(videoFiles);
            e.setNewlyAdded(true);
            // e.findImages();
            e.setDateAddedFromMediaFile(new MediaFile(firstVideoFile));
            findAdditionalEpisodeFiles(e, firstVideoFile, content);
            e.saveToDb();
            tvShow.addEpisode(e);
          }
        } else {
          TvShowEpisode episode = new TvShowEpisode();
          episode.setPath(dir.getPath());
          episode.setDvdOrder(Globals.settings.getTvShowSettings().isDvdOrder());
          episode.setEpisode(-1);
          episode.setSeason(-1);
          episode.setTvShow(tvShow);
          episode.setFirstAired(result.date);
          episode.setDisc(true);
          episode.setNewlyAdded(true);
          episode.addToMediaFiles(videoFiles);
          episode.setDateAddedFromMediaFile(new MediaFile(firstVideoFile));
          findAdditionalEpisodeFiles(episode, firstVideoFile, content);
          episode.saveToDb();
          tvShow.addEpisode(episode);
        }
      }
    } else {
      // episode already added; look if any new additional files have been added
      for (TvShowEpisode episode : episodes) {
        if (findAdditionalEpisodeFiles(episode, firstVideoFile, content)) {
          episode.saveToDb();
        }
      }
    }
  }
  /**
   * Renames a MediaFiles<br>
   * gets all episodes of it, creates season folder, updates MFs & DB
   *
   * @param mf the MediaFile
   * @param show the tvshow (only needed for path)
   */
  public static void renameMediaFile(MediaFile mf, TvShow show) {
    // #######################################################
    // Assumption: all multi-episodes share the same season!!!
    // #######################################################

    List<TvShowEpisode> eps = TvShowList.getInstance().getTvEpisodesByFile(show, mf.getFile());
    if (eps == null || eps.size() == 0) {
      // this should not happen, but unluckily ODB does it sometimes; try a second time to get the
      // episode
      try {
        Thread.sleep(250);
      } catch (Exception e) {
      }
      eps = TvShowList.getInstance().getTvEpisodesByFile(show, mf.getFile());
    }
    if (eps == null || eps.size() == 0) {
      // FIXME: workaround for r1972
      // when moving video file, all NFOs get deleted and a new gets created.
      // so this OLD NFO is not found anylonger - just delete it
      if (mf.getType() == MediaFileType.NFO) {
        FileUtils.deleteQuietly(mf.getFile());
        return;
      }

      LOGGER.warn("No episodes found for file '" + mf.getFilename() + "' - skipping");
      return;
    }

    // get first, for isDisc and season
    TvShowEpisode ep = eps.get(0);

    // test access rights or return
    LOGGER.debug(
        "testing file S:"
            + ep.getSeason()
            + " E:"
            + ep.getEpisode()
            + " MF:"
            + mf.getFile().getAbsolutePath());
    File f = mf.getFile();
    boolean testRenameOk = false;
    for (int i = 0; i < 5; i++) {
      testRenameOk = f.renameTo(f); // haahaa, try to rename to itself :P
      if (testRenameOk) {
        break; // ok it worked, step out
      }
      try {
        if (!f.exists()) {
          LOGGER.debug("Hmmm... file " + f + " does not even exists; delete from DB");
          // delete from MF
          for (TvShowEpisode e : eps) {
            e.removeFromMediaFiles(mf);
            e.saveToDb();
            e.writeNFO();
          }
          return;
        }
        LOGGER.debug("rename did not work - sleep a while and try again...");
        Thread.sleep(1000);
      } catch (InterruptedException e) {
        LOGGER.warn("I'm so excited - could not sleep");
      }
    }
    if (!testRenameOk) {
      LOGGER.warn("File " + mf.getFile().getAbsolutePath() + " is not accessible!");
      MessageManager.instance.pushMessage(
          new Message(MessageLevel.ERROR, mf.getFilename(), "message.renamer.failedrename"));
      return;
    }

    // create SeasonDir
    // String seasonName = "Season " + String.valueOf(ep.getSeason());
    String seasonName = generateSeasonDir(SETTINGS.getRenamerSeasonFoldername(), ep);
    File seasonDir = null;
    if (StringUtils.isNotBlank(seasonName)) {
      seasonDir = new File(show.getPath(), seasonName);
      if (!seasonDir.exists()) {
        seasonDir.mkdir();
      }
    } else {
      seasonDir = new File(show.getPath());
    }

    // rename epFolder accordingly
    if (ep.isDisc() || mf.isDiscFile()) {
      // \Season 1\S01E02E03\VIDEO_TS\VIDEO_TS.VOB
      // ........ \epFolder \disc... \ file
      File disc = mf.getFile().getParentFile();
      File epFolder = disc.getParentFile();

      // sanity check
      if (!disc.getName().equalsIgnoreCase("BDMV")
          && !disc.getName().equalsIgnoreCase("VIDEO_TS")) {
        LOGGER.error(
            "Episode is labeled as 'on BD/DVD', but structure seems not to match. Better exit and do nothing... o_O");
        return;
      }

      String newFoldername =
          FilenameUtils.getBaseName(generateFolderename(show, mf)); // w/o extension
      if (newFoldername != null && !newFoldername.isEmpty()) {
        File newEpFolder = new File(seasonDir + File.separator + newFoldername);
        File newDisc = new File(newEpFolder + File.separator + disc.getName()); // old disc name

        try {
          // if (!epFolder.equals(newEpFolder)) {
          if (!epFolder.getAbsolutePath().equals(newEpFolder.getAbsolutePath())) {
            boolean ok = false;
            try {
              ok = Utils.moveDirectorySafe(epFolder, newEpFolder);
            } catch (Exception e) {
              LOGGER.error(e.getMessage());
              MessageManager.instance.pushMessage(
                  new Message(
                      MessageLevel.ERROR,
                      epFolder.getName(),
                      "message.renamer.failedrename",
                      new String[] {":", e.getLocalizedMessage()}));
            }
            if (ok) {
              // iterate over all EPs & MFs and fix new path
              LOGGER.debug("updating *all* MFs for new path -> " + newEpFolder);
              for (TvShowEpisode e : eps) {
                e.updateMediaFilePath(disc, newDisc);
                e.setPath(newEpFolder.getPath());
                e.saveToDb();
                e.writeNFO();
              }
            }
            // and cleanup
            cleanEmptyDir(epFolder);
          } else {
            // old and new folder are equal, do nothing
          }
        } catch (Exception e) {
          LOGGER.error("error moving video file " + disc.getName() + " to " + newFoldername, e);
          MessageManager.instance.pushMessage(
              new Message(
                  MessageLevel.ERROR,
                  mf.getFilename(),
                  "message.renamer.failedrename",
                  new String[] {":", e.getLocalizedMessage()}));
        }
      }
    } // end isDisc
    else {
      MediaFile newMF = new MediaFile(mf); // clone MF
      if (mf.getType().equals(MediaFileType.TRAILER)) {
        // move trailer into separate dir - not supported by XBMC
        File sample = new File(seasonDir, "sample");
        if (!sample.exists()) {
          sample.mkdir();
        }
        seasonDir = sample; // change directory storage
      }
      String filename = generateFilename(show, mf);
      LOGGER.debug("new filename should be " + filename);
      if (filename != null && !filename.isEmpty()) {
        File newFile = new File(seasonDir, filename);

        try {
          // if (!mf.getFile().equals(newFile)) {
          if (!mf.getFile().getAbsolutePath().equals(newFile.getAbsolutePath())) {
            File oldMfFile = mf.getFile();
            boolean ok = false;
            try {
              ok = Utils.moveFileSafe(oldMfFile, newFile);
            } catch (Exception e) {
              LOGGER.error(e.getMessage());
              MessageManager.instance.pushMessage(
                  new Message(
                      MessageLevel.ERROR,
                      oldMfFile.getPath(),
                      "message.renamer.failedrename",
                      new String[] {":", e.getLocalizedMessage()}));
            }
            if (ok) {
              newMF.setPath(seasonDir.getAbsolutePath());
              newMF.setFilename(filename);
              // iterate over all EPs and delete old / set new MF
              for (TvShowEpisode e : eps) {
                e.removeFromMediaFiles(mf);
                e.addToMediaFiles(newMF);
                e.setPath(seasonDir.getAbsolutePath());
                e.saveToDb();
                e.writeNFO();
              }
            }
            // and cleanup
            cleanEmptyDir(oldMfFile.getParentFile());
          } else {
            // old and new file are equal, keep MF
          }
        } catch (Exception e) {
          LOGGER.error(
              "error moving video file " + mf.getFilename() + " to " + newFile.getPath(), e);
          MessageManager.instance.pushMessage(
              new Message(
                  MessageLevel.ERROR,
                  mf.getFilename(),
                  "message.renamer.failedrename",
                  new String[] {":", e.getLocalizedMessage()}));
        }
      }
    }
  }