public override IEnumerable <ExtraFile> ProcessFiles(Artist artist, List <string> filesOnDisk, List <string> importedFiles)
        {
            _logger.Debug("Looking for existing metadata in {0}", artist.Path);

            var metadataFiles = new List <MetadataFile>();
            var filterResult  = FilterAndClean(artist, filesOnDisk, importedFiles);

            foreach (var possibleMetadataFile in filterResult.FilesOnDisk)
            {
                // Don't process files that have known Subtitle file extensions (saves a bit of unecessary processing)

                if (LyricFileExtensions.Extensions.Contains(Path.GetExtension(possibleMetadataFile)))
                {
                    continue;
                }

                foreach (var consumer in _consumers)
                {
                    var metadata = consumer.FindMetadataFile(artist, possibleMetadataFile);

                    if (metadata == null)
                    {
                        continue;
                    }

                    if (metadata.Type == MetadataType.AlbumImage || metadata.Type == MetadataType.AlbumMetadata)
                    {
                        var localAlbum = _parsingService.GetLocalAlbum(possibleMetadataFile, artist);

                        if (localAlbum == null)
                        {
                            _logger.Debug("Extra file folder has multiple Albums: {0}", possibleMetadataFile);
                            continue;
                        }

                        metadata.AlbumId = localAlbum.Id;
                    }

                    if (metadata.Type == MetadataType.TrackMetadata)
                    {
                        var localTrack = new LocalTrack
                        {
                            FileTrackInfo = Parser.Parser.ParseMusicPath(possibleMetadataFile),
                            Artist        = artist,
                            Path          = possibleMetadataFile
                        };

                        try
                        {
                            _augmentingService.Augment(localTrack, false);
                        }
                        catch (AugmentingFailedException)
                        {
                            _logger.Debug("Unable to parse extra file: {0}", possibleMetadataFile);
                            continue;
                        }

                        if (localTrack.Tracks.Empty())
                        {
                            _logger.Debug("Cannot find related tracks for: {0}", possibleMetadataFile);
                            continue;
                        }

                        if (localTrack.Tracks.DistinctBy(e => e.TrackFileId).Count() > 1)
                        {
                            _logger.Debug("Extra file: {0} does not match existing files.", possibleMetadataFile);
                            continue;
                        }

                        metadata.TrackFileId = localTrack.Tracks.First().TrackFileId;
                    }

                    metadata.Extension = Path.GetExtension(possibleMetadataFile);

                    metadataFiles.Add(metadata);
                }
            }

            _logger.Info("Found {0} existing metadata files", metadataFiles.Count);
            _metadataFileService.Upsert(metadataFiles);

            // Return files that were just imported along with files that were
            // previously imported so previously imported files aren't imported twice

            return(metadataFiles.Concat(filterResult.PreviouslyImported));
        }
        public override IEnumerable <ExtraFile> ProcessFiles(Author author, List <string> filesOnDisk, List <string> importedFiles)
        {
            _logger.Debug("Looking for existing metadata in {0}", author.Path);

            var metadataFiles = new List <MetadataFile>();
            var filterResult  = FilterAndClean(author, filesOnDisk, importedFiles);

            foreach (var possibleMetadataFile in filterResult.FilesOnDisk)
            {
                foreach (var consumer in _consumers)
                {
                    var metadata = consumer.FindMetadataFile(author, possibleMetadataFile);

                    if (metadata == null)
                    {
                        continue;
                    }

                    if (metadata.Type == MetadataType.BookImage || metadata.Type == MetadataType.BookMetadata)
                    {
                        var localAlbum = _parsingService.GetLocalAlbum(possibleMetadataFile, author);

                        if (localAlbum == null)
                        {
                            _logger.Debug("Extra file folder has multiple Books: {0}", possibleMetadataFile);
                            continue;
                        }

                        metadata.BookId = localAlbum.Id;
                    }

                    if (metadata.Type == MetadataType.BookMetadata)
                    {
                        var localTrack = new LocalBook
                        {
                            FileTrackInfo = Parser.Parser.ParseMusicPath(possibleMetadataFile),
                            Author        = author,
                            Path          = possibleMetadataFile
                        };

                        try
                        {
                            _augmentingService.Augment(localTrack, false);
                        }
                        catch (AugmentingFailedException)
                        {
                            _logger.Debug("Unable to parse extra file: {0}", possibleMetadataFile);
                            continue;
                        }

                        if (localTrack.Book == null)
                        {
                            _logger.Debug("Cannot find related book for: {0}", possibleMetadataFile);
                            continue;
                        }
                    }

                    metadata.Extension = Path.GetExtension(possibleMetadataFile);

                    metadataFiles.Add(metadata);
                }
            }

            _logger.Info("Found {0} existing metadata files", metadataFiles.Count);
            _metadataFileService.Upsert(metadataFiles);

            // Return files that were just imported along with files that were
            // previously imported so previously imported files aren't imported twice
            return(metadataFiles.Concat(filterResult.PreviouslyImported));
        }