package net.filebot.format;

import static java.util.Arrays.*;
import static java.util.Collections.*;
import static java.util.stream.Collectors.*;
import static net.filebot.HistorySpooler.*;
import static net.filebot.Logging.*;
import static net.filebot.MediaTypes.*;
import static net.filebot.WebServices.*;
import static net.filebot.format.Define.*;
import static net.filebot.format.ExpressionFormatMethods.*;
import static net.filebot.hash.VerificationUtilities.*;
import static net.filebot.media.CachedMediaCharacteristics.*;
import static net.filebot.media.MediaDetection.*;
import static net.filebot.media.MediaFileUtilities.*;
import static net.filebot.media.XattrMetaInfo.*;
import static net.filebot.similarity.Normalization.*;
import static net.filebot.subtitle.SubtitleUtilities.*;
import static net.filebot.util.RegularExpressions.*;
import static net.filebot.util.StringUtilities.*;
import static net.filebot.web.EpisodeUtilities.*;

import java.io.File;
import java.io.IOException;
import java.math.BigDecimal;
import java.time.Duration;
import java.time.Instant;
import java.time.ZoneId;
import java.time.ZoneOffset;
import java.time.ZonedDateTime;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.function.Function;
import java.util.regex.Pattern;
import java.util.stream.Stream;

import net.filebot.ApplicationFolder;
import net.filebot.Language;
import net.filebot.MemoryCache;
import net.filebot.Resource;
import net.filebot.Settings;
import net.filebot.hash.HashType;
import net.filebot.media.ImageMetadata;
import net.filebot.media.LocalDatasource.PhotoFile;
import net.filebot.media.MediaCharacteristics;
import net.filebot.media.MediaInfoTable;
import net.filebot.media.MetaAttributes;
import net.filebot.media.NamingStandard;
import net.filebot.media.VideoFormat;
import net.filebot.media.XattrChecksum;
import net.filebot.mediainfo.MediaInfoException;
import net.filebot.mediainfo.StreamKind;
import net.filebot.similarity.Normalization;
import net.filebot.util.FileUtilities;
import net.filebot.vfs.VFS;
import net.filebot.web.AnimeLists;
import net.filebot.web.AudioTrack;
import net.filebot.web.Episode;
import net.filebot.web.EpisodeFormat;
import net.filebot.web.Link;
import net.filebot.web.Movie;
import net.filebot.web.MovieDetails;
import net.filebot.web.MoviePart;
import net.filebot.web.SeriesDetails;
import net.filebot.web.SeriesInfo;
import net.filebot.web.SimpleDate;
import net.filebot.web.SortOrder;
import net.filebot.web.XDB;
import net.filebot.web.XEM;

public class MediaBindingBean {

        private final Object infoObject;
        private final File mediaFile;
        private final Map<File, ?> context;

        public MediaBindingBean(Object infoObject, File mediaFile) {
                this(infoObject, mediaFile, singletonMap(mediaFile, infoObject));
        }

        public MediaBindingBean(Object infoObject, File mediaFile, Map<File, ?> context) {
                this.infoObject = infoObject;
                this.mediaFile = mediaFile;
                this.context = context;
        }

        @Define("object")
        public Object getInfoObject() {
                return infoObject;
        }

        @Define("file")
        public File getFileObject() {
                return mediaFile;
        }

        @Define(undefined)
        public <T> T undefined(String name) {
                // omit expressions that depend on undefined values
                throw new BindingException(name, "undefined", BindingException.Flag.UNDEFINED);
        }

        @Define("n")
        public String getName() {
                if (infoObject instanceof Episode)
                        return getEpisode().getSeriesName();
                if (infoObject instanceof Movie)
                        return getMovie().getName();
                if (infoObject instanceof AudioTrack)
                        return getAlbumArtist() != null ? getAlbumArtist() : getArtist();
                if (infoObject instanceof File)
                        return FileUtilities.getName((File) infoObject);

                return null;
        }

        @Define("y")
        public Integer getYear() throws Exception {
                if (infoObject instanceof Episode)
                        return getStartDate().getYear();
                if (infoObject instanceof Movie)
                        return getMovie().getYear();
                if (infoObject instanceof AudioTrack)
                        return getReleaseDate().getYear();
                if (infoObject instanceof PhotoFile)
                        return getPhoto().getDateTaken().map(ZonedDateTime::getYear).orElse(null); // use Date-Taken instead of Last-Modified
                if (infoObject instanceof File)
                        return getReleaseDate().getYear();

                return null;
        }

        @Define("ny")
        public String getNameWithYear() {
                String n = getName();

                // check if {n} already includes the year
                if (NamingStandard.isNameYear(n)) {
                        return n;
                }

                // account for TV Shows that contain the year in the series name, e.g. Doctor Who (2005)
                try {
                        return n + " (" + getYear() + ")";
                } catch (Exception e) {
                        debug.finest(cause(e));
                }

                // default to {n} if {y} is undefined
                return n;
        }

        @Define("s")
        public Integer getSeasonNumber() throws Exception {
                return getEpisode().getSeason();
        }

        @Define("sn")
        public String getSeasonName() {
                return getEpisode().getGroup();
        }

        @Define("e")
        public Integer getEpisodeNumber() {
                return getEpisode().getEpisode();
        }

        @Define("es")
        public List<Integer> getEpisodeNumbers() {
                return getEpisodes().stream().map(e -> {
                        return e.getEpisode() == null ? e.getSpecial() == null ? null : e.getSpecial() : e.getEpisode();
                }).filter(Objects::nonNull).collect(toList());
        }

        @Define("s00")
        public String getS00() {
                return EpisodeFormat.DEFAULT.formatMultiNumbers(getEpisodes(), "%02d", "", "");
        }

        @Define("e00")
        public String getE00() {
                return EpisodeFormat.DEFAULT.formatMultiNumbers(getEpisodes(), "", "%02d", "x");
        }

        @Define("sxe")
        public String getSxE() throws Exception {
                return EpisodeFormat.DEFAULT.formatSxE(getEpisode());
        }

        @Define("s00e00")
        public String getS00E00() throws Exception {
                return EpisodeFormat.DEFAULT.formatS00E00(getEpisode());
        }

        @Define("t")
        public String getTitle() {
                String t = null;

                if (infoObject instanceof Episode) {
                        t = getEpisode().getTitle();
                } else if (infoObject instanceof Movie) {
                        t = getMovieDetails().getTagline();
                } else if (infoObject instanceof AudioTrack) {
                        t = getMusic().getTrackTitle() != null ? getMusic().getTrackTitle() : getMusic().getTitle();
                }

                // enforce title length limit by default
                return truncateText(replaceSlash(t, " - ", " ", ".", ""), NamingStandard.TITLE_MAX_LENGTH);
        }

        @Define("d")
        public SimpleDate getReleaseDate() throws Exception {
                if (infoObject instanceof Episode)
                        return getEpisode().getAirdate();
                if (infoObject instanceof Movie)
                        return getMovieDetails().getReleased();
                if (infoObject instanceof AudioTrack)
                        return getMusic().getAlbumReleaseDate();
                if (infoObject instanceof PhotoFile)
                        return getPhoto().getDateTaken().map(SimpleDate::from).orElse(null);
                if (infoObject instanceof File)
                        return SimpleDate.from(getFileCreationTime());

                return null;
        }

        @Define("dt")
        public ZonedDateTime getMediaCreationTime() throws Exception {
                // use Encoded_Date for generic video files
                if (VIDEO_FILES.accept(getMediaFile())) {
                        return getVideoCharacteristics().map(MediaCharacteristics::getCreationTime).map(i -> i.atZone(ZoneOffset.UTC)).orElse(null);
                }

                // use EXIF Date-Taken for image files or File Last-Modified for generic files
                if (IMAGE_FILES.accept(getMediaFile()) || ImageMetadata.SUPPORTED_FILE_TYPES.accept(getMediaFile())) {
                        return getPhoto().getDateTaken().orElse(null);
                }

                // use file creation date for generic files
                return getFileCreationTime();
        }

        @Define("ct")
        public ZonedDateTime getFileCreationTime() throws Exception {
                // use file creation date for generic files
                return FileUtilities.getCreationDate(getMediaFile()).atZone(ZoneId.systemDefault());
        }

        @Define("airdate")
        public SimpleDate getAirdate() {
                return getEpisode().getAirdate();
        }

        @Define("age")
        public Long getAgeInDays() throws Exception {
                SimpleDate releaseDate = getReleaseDate();

                if (releaseDate != null) {
                        // avoid time zone issues by interpreting all dates and times as UTC
                        long days = ChronoUnit.DAYS.between(releaseDate.toLocalDate().atStartOfDay(ZoneOffset.UTC).toInstant(), Instant.now());

                        if (days >= 0) {
                                return days;
                        }
                }

                return null;
        }

        @Define("startdate")
        public SimpleDate getStartDate() throws Exception {
                SimpleDate startdate = getSeriesInfo().getStartDate();

                // use series metadata startdate if possible
                if (startdate != null) {
                        return startdate;
                }

                // access episode list and find minimum airdate if necessary
                return fetchEpisodeList(getEpisode()).stream().filter(e -> isRegularEpisode(e)).map(Episode::getAirdate).filter(Objects::nonNull).min(SimpleDate::compareTo).get();
        }

        @Define("absolute")
        public Integer getAbsoluteEpisodeNumber() {
                return getEpisode().getAbsolute();
        }

        @Define("special")
        public Integer getSpecialNumber() {
                return getEpisode().getSpecial();
        }

        @Define("series")
        public SeriesInfo getSeriesInfo() {
                return getEpisode().getSeriesInfo();
        }

        @Define("alias")
        public List<String> getAliasNames() {
                if (infoObject instanceof Movie)
                        return asList(getMovie().getAliasNames());
                if (infoObject instanceof Episode)
                        return getSeriesInfo().getAliasNames();

                return null;
        }

        @Define("primaryTitle")
        public String getPrimaryTitle() {
                if (infoObject instanceof Movie) {
                        return getMovieDetails().getOriginalName();
                }

                if (infoObject instanceof Episode) {
                        String romajiTitle = mapRomajiPrimaryTitle(getEpisode());
                        // e.g. Boku no Hero Academia (2021) -> Boku no Hero Academia
                        if (romajiTitle != null) {
                                return replaceTrailingBrackets(romajiTitle);
                        }

                        SeriesDetails details = getSeriesDetails();
                        // prefer original name field if available
                        if (details.getOriginalName() != null) {
                                return details.getOriginalName();
                        }
                        return details.getName();
                }

                return null;
        }

        @Define("id")
        public Object getId() throws Exception {
                if (infoObject instanceof Episode)
                        return getSeriesInfo().getId();
                if (infoObject instanceof Movie)
                        return getMovie().getId();
                if (infoObject instanceof AudioTrack)
                        return getMusic().getMBID();

                return null;
        }

        @Define("tmdbid")
        public Integer getTmdbId() throws Exception {
                if (infoObject instanceof Movie) {
                        if (getMovie().getTmdbId() > 0) {
                                return getMovie().getTmdbId();
                        }
                        if (getMovie().getImdbId() > 0) {
                                return getMovieDetails().getId(); // lookup IMDbID for TMDbID
                        }
                }

                if (infoObject instanceof Episode) {
                        if (isInstance(TheMovieDB_TV, getSeriesInfo())) {
                                return getSeriesInfo().getId();
                        }
                        return lookupExternalSeries(getSeriesInfo()).getExternalId(XDB.TheMovieDB);
                }

                return null;
        }

        @Define("tvdbid")
        public Integer getTvdbId() throws Exception {
                if (infoObject instanceof Episode) {
                        if (isInstance(TheTVDB, getSeriesInfo())) {
                                return getSeriesInfo().getId();
                        }
                        return lookupExternalSeries(getSeriesInfo()).getExternalId(XDB.TheTVDB);
                }

                return null;
        }

        @Define("imdbid")
        public String getImdbId() throws Exception {
                if (infoObject instanceof Movie) {
                        if (getMovie().getImdbId() > 0) {
                                return Link.IMDb.getID(getMovie());
                        }
                        if (getMovie().getTmdbId() > 0) {
                                return Link.IMDb.getID(getMovieDetails()); // lookup IMDbID for TMDbID
                        }
                }

                if (infoObject instanceof Episode) {
                        // request external IDs from TheMovieDB and TheTVDBv4
                        Map<String, String> ids = ExtendedMetadataMethods.getExternalIds(getSeriesInfo());
                        if (ids != null) {
                                for (String id : ids.values()) {
                                        Integer imdbid = Link.IMDb.parseID(id);
                                        if (imdbid != null) {
                                                return Link.IMDb.getID(imdbid);
                                        }
                                }
                        }
                        // request series details from TVmaze and TheTVDBv2
                        return Link.IMDb.getID(getSeriesDetails().getImdbId());
                }

                return null;
        }

        @Define("vcf")
        public String getVideoCompressionFormat() {
                // e.g. AVC, HEVC, etc.
                return getMediaInfo(StreamKind.Video, "Format");
        }

        @Define("vc")
        public String getVideoCodec() {
                // e.g. XviD, x264, DivX 5, MPEG-4 Visual, AVC, etc.
                String codec = getMediaInfo(StreamKind.Video, "Encoded_Library_Name", "Encoded_Library/Name", "CodecID/Hint", "Format");

                // get first token (e.g. DivX 5 => DivX)
                return tokenize(codec).findFirst().orElse(null);
        }

        @Define("ac")
        public String getAudioCodec() {
                // e.g. AC-3, DTS, AAC, Vorbis, MP3, etc.
                String codec = getMediaInfo(StreamKind.Audio, "CodecID/Hint", "Format/String", "Format");

                // take first word (e.g. AAC LC SBR => AAC)
                // remove punctuation (e.g. AC-3 => AC3)
                return tokenize(codec).findFirst().map(c -> normalizePunctuation(c, "", "")).orElse(null);
        }

        @Define("cf")
        public String getContainerFormat() {
                // container format extensions (e.g. avi, mkv mka mks, OGG, etc.)
                String extensions = getMediaInfo(StreamKind.General, "Codec/Extensions", "Format");

                // get first extension
                return tokenize(extensions).map(String::toLowerCase).findFirst().get();
        }

        @Define("vf")
        public String getVideoFormat() {
                int w = Integer.parseInt(getMediaInfo(StreamKind.Video, "Width"));
                int h = Integer.parseInt(getMediaInfo(StreamKind.Video, "Height"));

                // e.g. 720p, nobody actually wants files to be tagged as interlaced, e.g. 720i
                return VideoFormat.DEFAULT_GROUPS.guessFormat(w, h) + "p";
        }

        @Define("vk")
        public String getVideoFormatK() {
                int w = Integer.parseInt(getMediaInfo(StreamKind.Video, "Width"));

                // e.g. 4K, 8K, 16K, etc
                int k = (int) Math.floor((w / 800f) / 4) * 4;
                return k >= 4 ? k + "K" : null;
        }

        @Define("hpi")
        public String getExactVideoFormat() {
                String height = getMediaInfo(StreamKind.Video, "Height");
                String scanType = getMediaInfo(StreamKind.Video, "ScanType");

                // progressive by default if ScanType is undefined
                String p = scanType.codePoints().map(Character::toLowerCase).mapToObj(Character::toChars).map(String::valueOf).findFirst().orElse("p");

                // e.g. 720p
                return height + p;
        }

        @Define("af")
        public ChannelCount getAudioChannels() {
                // get first number, e.g. 6ch
                return getMediaInfo().find(StreamKind.Audio, "Channel(s)_Original", "Channel(s)").map(channels -> {
                        // e.g. 15 objects / 6 channels
                        return tokenize(channels, SLASH).map(s -> matchInteger(s)).filter(Objects::nonNull).min(Integer::compare).orElse(null);
                }).filter(Objects::nonNull).max(Integer::compare).map(ChannelCount::count).orElse(null);
        }

        @Define("channels")
        public ChannelCount getAudioChannelLayout() {
                // e.g. ChannelLayout: L R / L R C LFE Ls Rs / C L R LFE Lb Rb Lss Rss / Object Based
                return getMediaInfo().find(StreamKind.Audio, "ChannelLayout_Original", "ChannelLayout").map(layout -> {
                        if (layout.equals("Object Based")) {
                                return null;
                        }
                        return tokenize(layout, SPACE).map(c -> {
                                return !c.contains("LFE") ? "1" : "0.1";
                        }).map(BigDecimal::new).reduce(BigDecimal::add).orElse(null);
                }).filter(Objects::nonNull).max(BigDecimal::compareTo).map(ChannelCount::layout).orElseGet(() -> {
                        // e.g. 15 objects / 6 channels
                        return Optional.ofNullable(getAudioChannels()).map(ChannelCount::getValue).map(ChannelCount::layout).orElse(null);
                });
        }

        @Define("acf")
        public String getAudioChannelFormatTag() {
                // e.g. DD5.1 or DDP5.1
                String format = getMediaInfo(StreamKind.Audio, "Format_Commercial");
                ChannelCount channels = getAudioChannelLayout();

                if (format == null || channels == null) {
                        return null;
                }

                // keep only upper case letters (i.e. keep initials and acronyms)
                return format.replaceAll("\\P{Upper}", "") + channels;
        }

        @Define("aco")
        public String getAudioChannelObjects() {
                return getMediaInfo().stream(StreamKind.Audio, "Codec_Profile", "Format_Profile", "Format_Commercial").map(s -> {
                        // Format_Commercial: Dolby Digital Plus with Dolby Atmos
                        // Format_Profile: Blu-ray Disc
                        return SLASH.splitAsStream(s).map(String::trim).filter(v -> !v.isEmpty() && !v.contains("Disc")).findFirst().orElse(null);
                }).filter(Objects::nonNull).findFirst().orElse(null);
        }

        @Define("resolution")
        public Resolution getVideoResolution() {
                // collect value from Video Stream 0 or Image Stream 0
                return Stream.of(StreamKind.Video, StreamKind.Image).map(k -> {
                        String w = getMediaInfo().getString(k, "Width");
                        String h = getMediaInfo().getString(k, "Height");
                        return Resolution.parse(w, h);
                }).filter(Objects::nonNull).findFirst().orElse(null);
        }

        @Define("bitdepth")
        public Integer getBitDepth() {
                // collect value from Video Stream 0 or Audio Stream 0 or Image Stream 0
                return Stream.of(StreamKind.Video, StreamKind.Audio, StreamKind.Image).map(k -> {
                        return matchInteger(getMediaInfo().getString(k, "BitDepth"));
                }).filter(Objects::nonNull).findFirst().orElse(null);
        }

        @Define("hdr")
        public String getHighDynamicRange() {
                // try HDR_Format_Commercial (requires MediaInfo 19.04)
                String hdr = getMediaInfo().find(StreamKind.Video, "HDR_Format", "HDR_Format_Commercial").flatMap(SLASH::splitAsStream).filter(s -> {
                        // search for specific HDR type values
                        return s.contains("HDR") || s.contains("Dolby Vision");
                }).findFirst().orElse(null);

                // DV or DV+HDR10
                if (hdr != null && hdr.contains("Dolby Vision")) {
                        // try HDR_Format_Compatibility (requires MediaInfo 24.04)
                        if (getMediaInfo().find(StreamKind.Video, "HDR_Format_Compatibility").flatMap(SLASH::splitAsStream).anyMatch(s -> s.contains("HDR10"))) {
                                return "DV+HDR10";
                        } else {
                                return "DV";
                        }
                }

                // HDR10 or HDR10+ or SDR (i.e. HDR undefined)
                return hdr;
        }

        @Define("dovi")
        public String getDolbyVision() {
                return getMediaInfo().find(StreamKind.Video, "HDR_Format", "HDR_Format_Commercial").flatMap(SLASH::splitAsStream).filter(s -> {
                        return s.contains("Dolby Vision");
                }).findFirst().orElse(null);
        }

        @Define("ar")
        public String getAspectRatio() {
                // e.g. 16:9 or 2.35:1
                String ratio = getMediaInfo(StreamKind.Video, "DisplayAspectRatio/String");
                // use ratio (U+2236) instead of colon (U+003A)
                return colon(ratio, "∶");
        }

        @Define("ws")
        public String getWidescreen() {
                // width-to-height aspect ratio greater than 1.37:1
                float ratio = Float.parseFloat(getMediaInfo(StreamKind.Video, "DisplayAspectRatio"));
                return ratio > 1.37f ? "WS" : null;
        }

        @Define("hd")
        public String getVideoDefinitionCategory() {
                Resolution resolution = getVideoResolution();
                int w = resolution.getWidth();
                int h = resolution.getHeight();

                if (w > 2560 || h > 1440)
                        return "UHD";
                if (w > 1920 || h > 1080)
                        return "QHD";
                if (w > 1280 || h > 720)
                        return "FHD";
                if (w > 1024 || h > 576)
                        return "HD";

                return "SD";
        }

        @Define("width")
        public Integer getWidth() {
                return getVideoResolution().getWidth();
        }

        @Define("height")
        public Integer getHeight() {
                return getVideoResolution().getHeight();
        }

        @Define("original")
        public String getOriginalFileName() {
                // try xattr file name
                String originalName = xattr.getOriginalName(getMediaFile());
                if (originalName != null) {
                        return FileUtilities.getNameWithoutExtension(originalName);
                }

                // try historic file name
                File originalPath = HISTORY.getOriginalPath(getMediaFile());
                if (originalPath != null) {
                        return FileUtilities.getName(originalPath);
                }

                return null;
        }

        @Define("xattr")
        public Object getMetaAttributesObject() throws Exception {
                return xattr.getMetaInfo(getMediaFile());
        }

        @Define("crc32")
        public String getCRC32() throws Exception {
                // try to get checksum from file name
                Optional<String> embeddedChecksum = stream(getFileNames(inferredMediaFile.get())).map(Normalization::getEmbeddedChecksum).filter(Objects::nonNull).findFirst();
                if (embeddedChecksum.isPresent()) {
                        return embeddedChecksum.get();
                }

                // try to get checksum from sfv file
                String checksum = getHashFromVerificationFile(inferredMediaFile.get(), HashType.SFV, 3);
                if (checksum != null) {
                        return checksum;
                }

                // compute and store to xattr
                return XattrChecksum.CRC32.computeIfAbsent(inferredMediaFile.get());
        }

        @Define("fn")
        public String getFileName() {
                // name without file extension
                return FileUtilities.getName(getMediaFile());
        }

        @Define("ext")
        public String getExtension() {
                // file extension
                return FileUtilities.getExtension(getMediaFile());
        }

        @Define("edition")
        public String getVideoEdition() throws Exception {
                // use {edition-XYZ} marker
                String edition = matchLastOccurrence(getFileName(), Pattern.compile("(?<=[{]edition[-])[^{}]+(?=[}])"));
                if (edition != null) {
                        return edition;
                }

                // use first {tags} match
                return releaseInfo.getVideoTags(mediaTitles.get()).stream().findFirst().orElse(null);
        }

        @Define("tags")
        public List<String> getVideoTags() throws Exception {
                // reduce false positives by removing the know titles from the name
                Pattern[] nonTagPattern = { getKeywordExcludePattern() };

                // consider foldername, filename and original filename of inferred media file
                String[] filenames = stream(mediaTitles.get()).map(s -> releaseInfo.clean(s, nonTagPattern)).filter(s -> !s.isEmpty()).toArray(String[]::new);

                // look for video source patterns in media file and it's parent folder (use inferred media file)
                return releaseInfo.getVideoTags(filenames);
        }

        @Define("vs")
        public String getVideoSource() throws Exception {
                // look for video source patterns in media file and it's parent folder (use inferred media file)
                return releaseInfo.getVideoSource(mediaTitles.get()).keySet().stream().findFirst().orElse(null);
        }

        @Define("source")
        public String getVideoSourceMatch() throws Exception {
                // look for video source patterns in media file and it's parent folder (use inferred media file)
                return releaseInfo.getVideoSource(mediaTitles.get()).values().stream().findFirst().orElse(null);
        }

        @Define("s3d")
        public String getStereoscopic3D() throws Exception {
                return releaseInfo.getStereoscopic3D(mediaTitles.get());
        }

        @Define("group")
        public String getReleaseGroup() throws Exception {
                // reduce false positives by removing the know titles from the name
                Pattern[] nonGroupPattern = { getKeywordExcludePattern(), releaseInfo.getVideoSourcePattern(), releaseInfo.getVideoFormatPattern(true), releaseInfo.getResolutionPattern() };

                // consider foldername, filename and original filename of inferred media file
                String[] filenames = stream(mediaTitles.get()).map(s -> releaseInfo.clean(s, nonGroupPattern)).filter(s -> !s.isEmpty()).toArray(String[]::new);

                // look for release group names in media file and it's parent folder
                return releaseInfo.getReleaseGroup(filenames);
        }

        @Define("subt")
        public String getSubtitleTags() throws Exception {
                Language language = getLanguageTag();
                String category = releaseInfo.getSubtitleCategoryTag(getFileNames(getMediaFile()));

                // Plex only supports ISO 639-2/B language codes
                if (language != null && category != null) {
                        return '.' + language.getISO3B() + '.' + category;
                }
                if (language != null) {
                        return '.' + language.getISO3B();
                }
                if (category != null) {
                        return '.' + category;
                }
                return null;
        }

        @Define("lang")
        public Language getLanguageTag() throws Exception {
                File f = getMediaFile();

                // require subtitle files for language suffix bindings
                if (!SUBTITLE_FILES.accept(f)) {
                        throw new Exception("Subtitle language tag is only defined for subtitle files");
                }

                // grep language from filename
                String[] fn = getFileNames(f);
                Locale languageTag = releaseInfo.getSubtitleLanguageTag(fn);
                if (languageTag != null) {
                        return Language.getLanguage(languageTag);
                }

                // check if file name matches a language name (e.g. English.srt)
                Language languageName = stream(fn).map(s -> afterLast(s, '.').orElse(s)).map(Language::findLanguage).filter(Objects::nonNull).findFirst().orElse(null);
                if (languageName != null) {
                        return languageName;
                }

                // detect language from subtitle text content
                return detectSubtitleLanguage(f);
        }

        @Define("language")
        public Language getOriginalLanguage() {
                if (infoObject instanceof Movie) {
                        return Language.forName(getMovieDetails().getOriginalLanguage());
                }
                if (infoObject instanceof Episode) {
                        return Language.forName(getSeriesDetails().getOriginalLanguage());
                }
                return null;
        }

        @Define("languages")
        public List<Language> getSpokenLanguages() {
                if (infoObject instanceof Movie) {
                        List<String> languages = getMovieDetails().getSpokenLanguages();
                        return languages.stream().map(Language::findLanguage).filter(Objects::nonNull).collect(toList());
                }
                if (infoObject instanceof Episode) {
                        List<String> languages = getSeriesInfo().getSpokenLanguages();
                        return languages.stream().map(Language::findLanguage).filter(Objects::nonNull).collect(toList());
                }
                return null;
        }

        @Define("country")
        public String getOriginCountry() throws Exception {
                if (infoObject instanceof Movie) {
                        return getMovieDetails().getProductionCountries().stream().findFirst().orElse(null);
                }
                if (infoObject instanceof Episode) {
                        return getSeriesDetails().getCountry().stream().findFirst().orElse(null);
                }
                return null;
        }

        @Define("runtime")
        public Integer getRuntime() throws Exception {
                if (infoObject instanceof Movie) {
                        return getMovieDetails().getRuntime();
                }
                if (infoObject instanceof Episode) {
                        // use episode-specific runtime if possible
                        // use series-level average episode runtime if necessary
                        return getEpisode().getRuntime() != null ? getEpisode().getRuntime() : getSeriesInfo().getRuntime();
                }
                return null;
        }

        @Define("actors")
        public List<String> getActors() throws Exception {
                if (infoObject instanceof Movie)
                        return getMovieDetails().getActors();
                if (infoObject instanceof Episode)
                        return ExtendedMetadataMethods.getActors(getSeriesInfo()); // use TheTVDB API v2 to retrieve actors info

                return null;
        }

        @Define("genres")
        public List<String> getGenres() {
                if (infoObject instanceof Movie)
                        return getMovieDetails().getGenres();
                if (infoObject instanceof Episode)
                        return getSeriesInfo().getGenres();
                if (infoObject instanceof AudioTrack)
                        return Stream.of(getMusic().getGenre()).filter(Objects::nonNull).flatMap(SEMICOLON::splitAsStream).map(String::trim).filter(s -> !s.isEmpty()).collect(toList());

                return null;
        }

        @Define("genre")
        public String getPrimaryGenre() {
                List<String> genres = getGenres();
                if (genres.size() > 0) {
                        return genres.get(0);
                }
                return null;
        }

        @Define("director")
        public String getDirector() throws Exception {
                if (infoObject instanceof Movie)
                        return getMovieDetails().getDirector();
                if (infoObject instanceof Episode)
                        return ExtendedMetadataMethods.getInfo(getEpisode()).getDirector();

                return null;
        }

        @Define("certification")
        public String getCertification() {
                if (infoObject instanceof Movie)
                        return getMovieDetails().getCertification();
                if (infoObject instanceof Episode)
                        return getSeriesInfo().getCertification();

                return null;
        }

        @Define("rating")
        public Number getRating() {
                Number r = null;

                if (infoObject instanceof Movie)
                        r = getMovieDetails().getRating();
                else if (infoObject instanceof Episode)
                        r = getSeriesInfo().getRating();

                // round to 0.1 by default
                return r == null ? null : round(r, 1);
        }

        @Define("votes")
        public Integer getVotes() {
                if (infoObject instanceof Movie)
                        return getMovieDetails().getVotes();
                if (infoObject instanceof Episode)
                        return getSeriesInfo().getRatingCount();

                return null;
        }

        @Define("collection")
        public String getCollection() {
                if (infoObject instanceof Movie)
                        return getMovieDetails().getCollection();

                return null;
        }

        @Define("ci")
        public Integer getCollectionIndex() throws Exception {
                return ExtendedMetadataMethods.getCollection(getMovie()).indexOf(getMovie()) + 1;
        }

        @Define("cy")
        public List<Integer> getCollectionYears() throws Exception {
                List<Integer> years = ExtendedMetadataMethods.getCollection(getMovie()).stream().map(Movie::getYear).sorted().distinct().collect(toList());
                if (years.size() > 1) {
                        return asList(years.get(0), years.get(years.size() - 1));
                } else {
                        return years;
                }
        }

        @Define("info")
        public AssociativeScriptObject getMetaInfo() throws Exception {
                if (infoObject instanceof Movie)
                        return createPropertyBindings(getMovieDetails());
                if (infoObject instanceof Episode)
                        return createPropertyBindings(getSeriesDetails());

                return null;
        }

        @Define("omdb")
        public AssociativeScriptObject getOmdbApiInfo() throws Exception {
                Integer id = Link.IMDb.parseID(getImdbId());
                if (id != null) {
                        return createPropertyBindings(OMDb.getMovieInfo(Movie.IMDB(id)));
                }
                return null;
        }

        @Define("order")
        public DynamicBindings getSortOrderObject() {
                return new DynamicBindings(SortOrder::names, k -> {
                        if (infoObject instanceof Episode) {
                                SortOrder order = SortOrder.forName(k);
                                Episode episode = reorderEpisode(getEpisode(), order);
                                return createBindings(episode, null);
                        }
                        return undefined(k);
                });
        }

        @Define("localize")
        public DynamicBindings getLocalizedInfoObject() {
                return new DynamicBindings(Language::availableLanguages, k -> {
                        Language language = Language.findLanguage(k);
                        Locale locale = language != null ? language.getLocale() : Locale.forLanguageTag(k);

                        if (locale.getLanguage().length() == 2 && locale.getCountry().length() == 2) {
                                if (infoObject instanceof Movie) {
                                        Movie movie = TheMovieDB.getMovieDescriptor(getMovie(), locale);
                                        return createBindings(movie, null);
                                }
                                if (infoObject instanceof Episode) {
                                        Episode episode = fetchEpisode(getEpisode(), null, locale);
                                        return createBindings(episode, null);
                                }
                        }

                        return undefined(k);
                });
        }

        @Define("db")
        public DynamicBindings getDatabaseMapper() {
                SeriesInfo s = getSeriesInfo();

                if (isInstance(TheMovieDB_TV, s) || isInstance(AniDB, s) || isInstance(TheTVDB, s)) {
                        return new DynamicBindings(AnimeLists.DB::names, k -> {
                                Episode e = getEpisode();

                                AnimeLists.DB source = AnimeLists.DB.get(e);
                                AnimeLists.DB target = AnimeLists.DB.get(k);

                                if (source == target) {
                                        return createBindings(e, null);
                                }

                                // map TMDB to TVDB
                                if (source == AnimeLists.DB.TheMovieDB && target == AnimeLists.DB.TheTVDB) {
                                        return createBindings(XDB.map(XDB.TheMovieDB, e, XDB.TheTVDB, TheTVDB), null);
                                }

                                // map TVDB to TMDB
                                if (source == AnimeLists.DB.TheTVDB && target == AnimeLists.DB.TheMovieDB) {
                                        return createBindings(XDB.map(XDB.TheTVDB, e, XDB.TheMovieDB, TheMovieDB_TV), null);
                                }

                                // use AnimeList mappings
                                Episode mapping = AnimeList.map(e, source, target).orElse(null);
                                if (mapping == null) {
                                        throw new Exception("AniDB mapping not found");
                                }

                                // reload complete episode information based on mapped SxE numbers
                                return createBindings(hydrateEpisode(mapping, s.getLanguage()), null);
                        });
                }

                return null;
        }

        @Define("historic")
        public AssociativeScriptObject getHistoricBindings() throws Exception {
                File originalPath = HISTORY.getOriginalPath(getMediaFile());
                return originalPath == null ? null : createBindings(null, originalPath);
        }

        @Define("az")
        public String getSortInitial() {
                try {
                        return sortInitial(getCollection());
                } catch (Exception e) {
                        return sortInitial(getName());
                }
        }

        @Define("decade")
        public Integer getDecade() throws Exception {
                return (getYear() / 10) * 10;
        }

        @Define("anime")
        public boolean isAnime() throws Exception {
                // check database affiliation, genres, keywords, AnimeLists mappings, etc
                if (infoObject instanceof Episode) {
                        SeriesInfo series = getSeriesInfo();
                        // check type and database
                        if (SeriesInfo.TYPE_ANIME.equals(series.getType()) || isInstance(AniDB, series)) {
                                return true;
                        }
                        // check genres and keywords
                        if (series.getGenres().contains("Anime") || seriesDetails.get().getKeywords().contains("anime")) {
                                return true;
                        }
                        // check AnimeLists mappings
                        return AnimeList.find(AnimeLists.DB.get(series), series.getId()).findAny().isPresent();
                }

                // check keywords or guess based on genre and production country
                if (infoObject instanceof Movie) {
                        MovieDetails m = getMovieDetails();
                        return m.getKeywords().contains("anime") || (m.getGenres().contains("Animation") && m.getSpokenLanguages().contains("ja") && m.getProductionCountries().contains("JP"));
                }

                return false;
        }

        @Define("regular")
        public boolean isRegular() {
                return isRegularEpisode(getEpisode());
        }

        @Define("sy")
        public List<Integer> getSeasonYears() throws Exception {
                return fetchEpisodeList(getEpisode()).stream().filter(e -> {
                        return isRegularEpisode(e) && e.getAirdate() != null && Objects.equals(e.getSeason(), getEpisode().getSeason());
                }).map(e -> e.getAirdate().getYear()).sorted().distinct().collect(toList());
        }

        @Define("sc")
        public Integer getSeasonCount() throws Exception {
                return fetchEpisodeList(getEpisode()).stream().filter(e -> isRegularEpisode(e) && e.getSeason() != null).map(Episode::getSeason).max(Integer::compare).get();
        }

        @Define("mediaTitle")
        public String getMediaTitle() {
                return getVideoCharacteristics().map(MediaCharacteristics::getTitle).orElse(null);
        }

        @Define("mediaTags")
        public Object getMediaTags() {
                return getVideoCharacteristics().map(MediaCharacteristics::getMediaTags).orElse(null);
        }

        @Define("audioLanguages")
        public List<Language> getAudioLanguageList() {
                return getMediaInfo().stream(StreamKind.Audio, "Language").filter(Objects::nonNull).distinct().map(Language::findLanguage).filter(Objects::nonNull).collect(toList());
        }

        @Define("textLanguages")
        public List<Language> getTextLanguageList() {
                return getMediaInfo().stream(StreamKind.Text, "Language").filter(Objects::nonNull).distinct().map(Language::findLanguage).filter(Objects::nonNull).collect(toList());
        }

        @Define("chapters")
        public Map<String, String> getChapters() {
                return getMediaInfo().list(StreamKind.Menu).stream().map(m -> {
                        Map<String, String> chapters = new LinkedHashMap<String, String>();
                        m.forEach((k, v) -> {
                                // e.g. 00:00:00.000
                                if (k.contains(":") && k.contains(".")) {
                                        chapters.putIfAbsent(k, v);
                                }
                        });
                        return chapters;
                }).filter(m -> !m.isEmpty()).findFirst().orElse(null);
        }

        @Define("bitrate")
        public BitRate getOverallBitRate() {
                return BitRate.parse(getMediaInfo(StreamKind.General, "OverallBitRate"));
        }

        @Define("vbr")
        public BitRate getVideoBitRate() {
                return BitRate.parse(getMediaInfo(StreamKind.Video, "BitRate"));
        }

        @Define("abr")
        public BitRate getAudioBitRate() {
                return BitRate.parse(getMediaInfo(StreamKind.Audio, "BitRate"));
        }

        @Define("kbps")
        public BitRate getKiloBytesPerSecond() {
                return getOverallBitRate().getKbps();
        }

        @Define("mbps")
        public BitRate getMegaBytesPerSecond() {
                return getOverallBitRate().getMbps();
        }

        @Define("fps")
        public FrameRate getFrameRate() {
                return FrameRate.parse(getMediaInfo(StreamKind.Video, "FrameRate"));
        }

        @Define("khz")
        public String getSamplingRate() {
                return getMediaInfo(StreamKind.Audio, "SamplingRate/String");
        }

        @Define("duration")
        public Duration getDuration() {
                // video duration and media duration may be different (e.g. time lapse video)
                return Stream.of(StreamKind.Video, StreamKind.Audio, StreamKind.General).map(k -> {
                        return getMediaInfo().getString(k, "Duration");
                }).filter(Objects::nonNull).map(Double::parseDouble).map(Math::round).map(Duration::ofMillis).findFirst().orElse(null);
        }

        @Define("seconds")
        public long getSeconds() {
                return Math.round(getDuration().toMillis() / (double) 1000);
        }

        @Define("minutes")
        public long getMinutes() {
                return Math.round(getDuration().toMillis() / (double) (60 * 1000));
        }

        @Define("hours")
        public String getHours() {
                return String.format(Locale.ROOT, "%d∶%02d", getMinutes() / 60, getMinutes() % 60);
        }

        @Define("media")
        public AssociativeScriptObject getGeneralProperties() {
                return createMediaInfoBindings(StreamKind.General).findFirst().orElse(null);
        }

        @Define("video")
        public List<AssociativeScriptObject> getVideoPropertiesList() {
                return createMediaInfoBindings(StreamKind.Video).collect(toList());
        }

        @Define("audio")
        public List<AssociativeScriptObject> getAudioPropertiesList() {
                return createMediaInfoBindings(StreamKind.Audio).collect(toList());
        }

        @Define("text")
        public List<AssociativeScriptObject> getTextPropertiesList() {
                return createMediaInfoBindings(StreamKind.Text).collect(toList());
        }

        @Define("image")
        public AssociativeScriptObject getImageProperties() {
                return createMediaInfoBindings(StreamKind.Image).findFirst().orElse(null);
        }

        @Define("menu")
        public AssociativeScriptObject getMenuProperties() {
                return createMediaInfoBindings(StreamKind.Menu).findFirst().orElse(null);
        }

        @Define("exif")
        public AssociativeScriptObject getImageMetadata() throws Exception {
                return new AssociativeScriptObject(getPhoto().snapshot(), this::undefined);
        }

        @Define("camera")
        public AssociativeEnumObject getCamera() throws Exception {
                return getPhoto().getCameraModel().map(AssociativeEnumObject::new).orElse(null);
        }

        @Define("location")
        public AssociativeEnumObject getLocation() throws Exception {
                return getPhoto().getLocationTaken(GoogleMaps).map(AssociativeEnumObject::new).orElse(null);
        }

        @Define("medium")
        public Integer getMedium() {
                Integer index = getMusic().getMedium();
                Integer count = getMusic().getMediumCount();

                // ignore CD 1 of 1
                if (index != null && count != null && count > 1) {
                        return index;
                }
                return null;
        }

        @Define("artist")
        public String getArtist() {
                return getMusic().getArtist();
        }

        @Define("albumArtist")
        public String getAlbumArtist() {
                return getMusic().getAlbumArtist();
        }

        @Define("album")
        public String getAlbum() {
                return getMusic().getAlbum();
        }

        @Define("episode")
        public Episode getEpisode() {
                return asType(infoObject, Episode.class);
        }

        @Define("episodes")
        public List<Episode> getEpisodes() {
                return streamMultiEpisode(getEpisode()).collect(toList());
        }

        @Define("movie")
        public Movie getMovie() {
                return asType(infoObject, Movie.class);
        }

        @Define("music")
        public AudioTrack getMusic() {
                return asType(infoObject, AudioTrack.class);
        }

        @Define("photo")
        public ImageMetadata getPhoto() throws Exception {
                if (infoObject instanceof PhotoFile) {
                        return ((PhotoFile) infoObject).getMetadata();
                }
                return new ImageMetadata(getMediaFile());
        }

        @Define("pi")
        public Number getPartIndex() throws Exception {
                if (infoObject instanceof AudioTrack) {
                        return getMusic().getTrack();
                }
                if (infoObject instanceof Movie) {
                        return infoObject instanceof MoviePart ? ((MoviePart) infoObject).getPartIndex() : null;
                }
                // infer part index from context
                List<File> group = getDuplicateGroup(inferredMediaFile.get());
                return group.size() > 1 ? identityIndexOf(group, inferredMediaFile.get()) : null;
        }

        @Deprecated
        @Define("pn")
        public Number getPartCountNumber() throws Exception {
                debug.severe("[DEPRECATED] {pn} is deprecated. Please use {pc} instead.");
                return getPartCount();
        }

        @Define("pc")
        public Number getPartCount() throws Exception {
                if (infoObject instanceof AudioTrack) {
                        return getMusic().getTrackCount();
                }
                if (infoObject instanceof Movie) {
                        return infoObject instanceof MoviePart ? ((MoviePart) infoObject).getPartCount() : null;
                }
                // infer part count from context
                List<File> group = getDuplicateGroup(inferredMediaFile.get());
                return group.size() > 1 ? group.size() : null;
        }

        @Define("type")
        public String getInfoObjectType() {
                return infoObject.getClass().getSimpleName();
        }

        @Define("mediaFile")
        public File getInferredMediaFile() throws Exception {
                return inferredMediaFile.get();
        }

        @Define("mediaFileName")
        public String getInferredMediaFileName() throws Exception {
                return FileUtilities.getName(inferredMediaFile.get());
        }

        @Define("relativeFile")
        public File getRelativeFilePath() {
                File f = getMediaFile();
                try {
                        return getStructurePathTail(getMediaFile());
                } catch (Exception e) {
                        debug.warning(cause("Failed to detect relative library path", f, e));
                }
                return FileUtilities.getRelativePathTail(f, 2);
        }

        @Define("f")
        public File getMediaFile() {
                // make sure file is not null, and that it is an existing file
                if (mediaFile == null) {
                        throw new BindingException("file", "undefined", BindingException.Flag.SAMPLE_FILE_NOT_SET);
                }
                return mediaFile;
        }

        @Define("folder")
        public File getMediaParentFolder() {
                return getMediaFile().getParentFile();
        }

        @Define("files")
        public List<File> files() throws Exception {
                File mediaFile = inferredMediaFile.get();

                // list folder
                if (mediaFile.isDirectory()) {
                        return FileUtilities.listFiles(mediaFile, FileUtilities.FILES, FileUtilities.HUMAN_NAME_ORDER);
                }

                // list archive
                if (VFS.hasIndex(mediaFile) && mediaFile.isFile()) {
                        return VFS.getIndex(mediaFile).stream().map(path -> new File(mediaFile, path.toString())).collect(toList());
                }

                // list primary video file and derived files
                return FileUtilities.getChildren(mediaFile.getParentFile(), f -> isDerived(f, mediaFile), FileUtilities.HUMAN_NAME_ORDER);
        }

        @Define("bytes")
        public FileSize getFileSize() throws Exception {
                // sum size of all files
                if (getMediaFile().isDirectory()) {
                        long totalSize = FileUtilities.listFiles(getMediaFile(), FileUtilities.FILES).stream().mapToLong(File::length).sum();
                        return new FileSize(totalSize);
                }

                // size of inferred media file (e.g. video file size for subtitle file)
                long mediaSize = inferredMediaFile.get().length();
                return new FileSize(mediaSize);
        }

        @Define("megabytes")
        public FileSize getFileSizeInMegaBytes() throws Exception {
                return getFileSize().getMB();
        }

        @Define("gigabytes")
        public FileSize getFileSizeInGigaBytes() throws Exception {
                return getFileSize().getGB();
        }

        @Define("today")
        public SimpleDate getToday() {
                return SimpleDate.now();
        }

        @Define("root")
        public File getMediaRootFolder() throws Exception {
                return getStructureRoot(getMediaFile());
        }

        @Define("drive")
        public File getMountPoint() throws Exception {
                // find D:/ on Windows or /Volumes/Share on macOS
                return FileUtilities.getMountPoint(getMediaFile());
        }

        @Define("home")
        public File getUserHome() {
                return ApplicationFolder.UserHome.getDirectory();
        }

        @Define("output")
        public File getUserDefinedOutputFolder() throws IOException {
                return new File(Settings.getApplicationArguments().output).getCanonicalFile();
        }

        @Define("defines")
        public Map<String, String> getUserDefinedArguments() throws IOException {
                return unmodifiableMap(Settings.getApplicationArguments().defines);
        }

        @Define("label")
        public String getUserDefinedLabel() throws IOException {
                return getUserDefinedArguments().entrySet().stream().filter(it -> {
                        return it.getKey().endsWith("label") && it.getValue() != null && it.getValue().length() > 0;
                }).map(it -> it.getValue()).findFirst().orElse(null);
        }

        @Define("i")
        public Number getModelIndex() {
                return identityIndexOf(context.values(), getInfoObject());
        }

        @Define("di")
        public Number getDuplicateIndex() {
                List<Object> duplicates = getDuplicateContext(MediaBindingBean::getInfoObject, MediaBindingBean::getExtension).map(MediaBindingBean::getInfoObject).collect(toList());
                return identityIndexOf(duplicates, getInfoObject());
        }

        @Define("dc")
        public Number getDuplicateCount() {
                return getDuplicateContext(MediaBindingBean::getInfoObject, MediaBindingBean::getExtension).count();
        }

        @Define("plex")
        public StructuredFile getPlexStandardPath() throws Exception {
                return getStandardPath(NamingStandard.Plex);
        }

        @Define("kodi")
        public StructuredFile getKodiStandardPath() throws Exception {
                return getStandardPath(NamingStandard.Kodi);
        }

        @Define("emby")
        public StructuredFile getEmbyStandardPath() throws Exception {
                return getStandardPath(NamingStandard.Emby);
        }

        @Define("jellyfin")
        public StructuredFile getJellyfinStandardPath() throws Exception {
                return getStandardPath(NamingStandard.Jellyfin);
        }

        @Define("self")
        public AssociativeScriptObject getSelf() {
                return createNullableBindings(infoObject, mediaFile, context);
        }

        @Define("model")
        public List<AssociativeScriptObject> getModel() {
                return modelCache.get(context, c -> {
                        return context.entrySet().stream().map(m -> {
                                return createNullableBindings(m.getValue(), m.getKey(), context);
                        }).collect(toList());
                });
        }

        @Define("episodelist")
        public List<AssociativeScriptObject> getEpisodeList() throws Exception {
                // fetch episode list from cache
                List<Episode> episodes = fetchEpisodeList(getEpisode());

                // use first episode from the episode list as cache key
                Object key = episodes.get(0).getSeriesInfo();

                // cache via context values view object identity
                return modelCache.get(key, k -> {
                        try {
                                return episodes.stream().map(e -> {
                                        return createNullableBindings(e, null, emptyMap());
                                }).collect(toList());
                        } catch (Exception e) {
                                throw new BindingException("episodelist", cause("Failed to retrieve episode list", k, e), e);
                        }
                });
        }

        @Define("json")
        public String getInfoObjectDump() {
                return MetaAttributes.toJson(infoObject, false);
        }

        @Define("XEM")
        public DynamicBindings getXrossEntityMapper() {
                return new DynamicBindings(XEM::names, k -> {
                        if (infoObject instanceof Episode) {
                                Episode e = getEpisode();
                                XEM origin = XEM.forName(e.getSeriesInfo().getDatabase());
                                XEM destination = XEM.forName(k);
                                return origin == destination ? e : origin.map(e, destination);
                        }
                        return undefined(k);
                });
        }

        @Define("AnimeList")
        public DynamicBindings getAnimeLists() {
                return new DynamicBindings(AnimeLists.DB::names, k -> {
                        if (infoObject instanceof Episode) {
                                Episode e = getEpisode();
                                AnimeLists.DB source = AnimeLists.DB.get(e);
                                AnimeLists.DB target = AnimeLists.DB.get(k);
                                return source == target ? e : AnimeList.map(e, source, target).orElse(null);
                        }
                        return undefined(k);
                });
        }

        public StructuredFile getStandardPath(NamingStandard naming) throws Exception {
                StructuredFile path = StructuredFile.of(infoObject, naming);

                // add subtitle suffix
                if (path != null) {
                        try {
                                path = path.suffix(getSubtitleTags());
                        } catch (Exception e) {
                                // ignore => no language tags
                        }
                }

                return path;
        }

        private final Resource<SeriesDetails> seriesDetails = Resource.lazy(() -> ExtendedMetadataMethods.getDetails(getSeriesInfo()));

        public SeriesDetails getSeriesDetails() {
                try {
                        return seriesDetails.get();
                } catch (Exception e) {
                        throw new BindingException("details", cause("Failed to retrieve series details", e), e);
                }
        }

        private final Resource<MovieDetails> movieDetails = Resource.lazy(() -> ExtendedMetadataMethods.getInfo(getMovie()));

        public MovieDetails getMovieDetails() {
                try {
                        return movieDetails.get();
                } catch (Exception e) {
                        throw new BindingException("details", cause("Failed to retrieve movie details", e), e);
                }
        }

        // lazy initialize and then keep in memory
        private final Resource<File> inferredMediaFile = Resource.lazy(() -> getInferredMediaFile(getMediaFile()));

        private File getInferredMediaFile(File file) {
                // primary media file is the video file itself
                if (VIDEO_FILES.accept(file)) {
                        return file;
                }

                // never infere media info from nearby video files when processing music or photos
                if (infoObject instanceof AudioTrack || infoObject instanceof PhotoFile) {
                        return file;
                }

                // find primary video file (e.g. a video file with the same base name)
                return findPrimaryFile(file, VIDEO_FILES).orElseGet(() -> {
                        List<File> options = new ArrayList<File>();

                        // prefer equal match from current context if possible
                        if (infoObject instanceof Episode || infoObject instanceof Movie) {
                                context.forEach((f, i) -> {
                                        if (infoObject.equals(i) && VIDEO_FILES.accept(f)) {
                                                options.add(f);
                                        }
                                });
                        }

                        // just pick any nearby video file for lack of better options
                        if (options.isEmpty() && (TEXT_FILES.accept(file) || IMAGE_FILES.accept(file))) {
                                try {
                                        options.addAll(findSiblingFiles(file, VIDEO_FILES));
                                } catch (Exception e) {
                                        debug.warning(cause("Failed to find sibling files", e));
                                }
                        }

                        // find first best match or default to itself for lack of better options
                        return findPrimaryFile(file, options).orElse(file);
                });
        }

        // lazy initialize and then keep in memory
        private final Resource<MediaInfoTable> mediaInfo = Resource.lazy(() -> {
                // use inferred media file (e.g. actual movie file instead of subtitle file)
                try {
                        return MediaInfoTable.read(inferredMediaFile.get());
                } catch (BindingException e) {
                        throw e;
                } catch (Exception e) {
                        throw new MediaInfoException(e.getMessage(), e);
                }
        });

        public MediaInfoTable getMediaInfo() {
                try {
                        return mediaInfo.get();
                } catch (BindingException e) {
                        throw e;
                } catch (Exception e) {
                        throw new BindingException("media", cause("Failed to read media info", e), e);
                }
        }

        private String getMediaInfo(StreamKind streamKind, String... keys) {
                String value = getMediaInfo().stream(streamKind, keys).filter(s -> {
                        // ignore fake media properties
                        return s.length() < NamingStandard.TITLE_MAX_LENGTH;
                }).findFirst().orElse(null);

                return value != null ? value : undefined(streamKind.name() + asList(keys));
        }

        private Stream<MediaBindingBean> getDuplicateContext(Function<MediaBindingBean, Object>... key) {
                return context.entrySet().stream().filter(e -> e.getKey() != null && e.getValue() != null).map(e -> new MediaBindingBean(e.getValue(), e.getKey())).filter(m -> {
                        return stream(key).allMatch(k -> Objects.equals(k.apply(this), k.apply(m)));
                });
        }

        private List<File> getDuplicateGroup(File object) throws Exception {
                // use duplicate matches
                List<File> files = getDuplicateContext(MediaBindingBean::getInfoObject).map(MediaBindingBean::getFileObject).collect(toList());
                // group by media file characteristics
                if (files.size() > 1) {
                        for (List<File> group : groupByMediaCharacteristics(files)) {
                                if (identityIndexOf(group, object) != null) {
                                        return group;
                                }
                        }
                }
                return emptyList();
        }

        private Integer identityIndexOf(Collection<?> collection, Object object) {
                int i = 0;
                for (Object item : collection) {
                        i++;
                        if (item == object) {
                                return i;
                        }
                }
                return null;
        }

        private AssociativeScriptObject createBindings(Object info, File file) {
                return new AssociativeScriptObject(new ExpressionBindings(new MediaBindingBean(info, file)), this::undefined);
        }

        private AssociativeScriptObject createNullableBindings(Object info, File file, Map<File, ?> context) {
                return new AssociativeScriptObject(new ExpressionBindings(new MediaBindingBean(info, file, context)), property -> null);
        }

        private AssociativeScriptObject createPropertyBindings(Object object) {
                return new AssociativeScriptObject(new PropertyBindings(object), this::undefined);
        }

        private Stream<AssociativeScriptObject> createMediaInfoBindings(StreamKind kind) {
                return getMediaInfo().list(kind).stream().map(m -> new AssociativeScriptObject(m, property -> null));
        }

        private final Resource<String[]> mediaTitles = Resource.lazy(() -> {
                // try to place embedded media title first
                String prime = getVideoCharacteristics().map(MediaCharacteristics::getTitle).orElse(null);
                String[] names = getFileNames(inferredMediaFile.get());

                if (prime != null && !prime.isEmpty()) {
                        return Stream.concat(Stream.of(prime), stream(names)).distinct().toArray(String[]::new);
                }

                // default to file name and xattr
                return names;
        });

        private Optional<MediaCharacteristics> getVideoCharacteristics() {
                try {
                        switch (getMediaCharacteristicsParser()) {
                                case mediainfo:
                                        return Optional.of(getMediaInfo());
                                case none:
                                        return Optional.empty();
                                default:
                                        return getMediaCharacteristics(inferredMediaFile.get());
                        }
                } catch (Exception e) {
                        debug.finest(cause("Failed to read video characteristics", e));
                }
                return Optional.empty();
        }

        private String[] getFileNames(File file) {
                List<String> names = new ArrayList<String>();

                // original file name via xattr
                String original = xattr.getOriginalName(file);
                if (original != null) {
                        names.add(FileUtilities.getNameWithoutExtension(original));
                }

                // current file name
                names.add(FileUtilities.getNameWithoutExtension(file.getName()));

                // current folder name
                File parent = file.getParentFile();
                if (parent != null && parent.getParent() != null) {
                        names.add(parent.getName());
                }

                return names.toArray(new String[0]);
        }

        private Pattern getKeywordExcludePattern() {
                // collect key information
                List<Object> keys = new ArrayList<Object>();

                if (infoObject instanceof Episode || infoObject instanceof Movie) {
                        keys.add(getName());
                        keys.addAll(getAliasNames());

                        if (infoObject instanceof Episode) {
                                for (Episode e : getEpisodes()) {
                                        keys.add(e.getTitle());
                                }
                        } else if (infoObject instanceof Movie) {
                                keys.add(getMovie().getYear());
                        }
                }

                // word list for exclude pattern
                String pattern = keys.stream().filter(Objects::nonNull).map(Objects::toString).map(s -> {
                        return normalizePunctuation(s, " ", "\\P{Alnum}+");
                }).filter(s -> !s.isEmpty()).collect(joining("|", "\\b(?:", ")\\b"));

                return Pattern.compile(pattern, Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CHARACTER_CLASS);
        }

        private <T> T asType(Object object, Class<T> type) {
                if (type.isInstance(object)) {
                        return type.cast(object);
                }
                throw new ClassCastException(type.getSimpleName() + " type bindings are not available for " + object.getClass().getSimpleName() + " type objects");
        }

        @Override
        public String toString() {
                return String.format(Locale.ROOT, "%s ⇔ %s", infoObject, mediaFile == null ? null : mediaFile.getName());
        }

        /**
         * Cache {model} binding value for each context (by object identity)
         */
        private static final MemoryCache<Object, List<AssociativeScriptObject>> modelCache = MemoryCache.weak();

}