using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Emby.Naming.Common;
using Emby.Naming.ExternalFiles;
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Entities.Audio;
using MediaBrowser.Controller.MediaEncoding;
using MediaBrowser.Controller.Providers;
using MediaBrowser.Model.Dlna;
using MediaBrowser.Model.Dto;
using MediaBrowser.Model.Entities;
using MediaBrowser.Model.Globalization;
using MediaBrowser.Model.IO;
using MediaBrowser.Model.MediaInfo;
using Microsoft.Extensions.Logging;

namespace MediaBrowser.Providers.MediaInfo
{
    /// <summary>
    /// Resolves external files for <see cref="Video"/>.
    /// </summary>
    public abstract class MediaInfoResolver
    {
        /// <summary>
        /// The <see cref="ExternalPathParser"/> instance.
        /// </summary>
        private readonly ExternalPathParser _externalPathParser;

        /// <summary>
        /// The <see cref="IMediaEncoder"/> instance.
        /// </summary>
        private readonly IMediaEncoder _mediaEncoder;

        private readonly ILogger _logger;
        private readonly IFileSystem _fileSystem;

        /// <summary>
        /// The <see cref="NamingOptions"/> instance.
        /// </summary>
        private readonly NamingOptions _namingOptions;

        /// <summary>
        /// The <see cref="DlnaProfileType"/> of the files this resolver should resolve.
        /// </summary>
        private readonly DlnaProfileType _type;

        /// <summary>
        /// Initializes a new instance of the <see cref="MediaInfoResolver"/> class.
        /// </summary>
        /// <param name="logger">The logger.</param>
        /// <param name="localizationManager">The localization manager.</param>
        /// <param name="mediaEncoder">The media encoder.</param>
        /// <param name="fileSystem">The file system.</param>
        /// <param name="namingOptions">The <see cref="NamingOptions"/> object containing FileExtensions, MediaDefaultFlags, MediaForcedFlags and MediaFlagDelimiters.</param>
        /// <param name="type">The <see cref="DlnaProfileType"/> of the parsed file.</param>
        protected MediaInfoResolver(
            ILogger logger,
            ILocalizationManager localizationManager,
            IMediaEncoder mediaEncoder,
            IFileSystem fileSystem,
            NamingOptions namingOptions,
            DlnaProfileType type)
        {
            _logger = logger;
            _mediaEncoder = mediaEncoder;
            _fileSystem = fileSystem;
            _namingOptions = namingOptions;
            _type = type;
            _externalPathParser = new ExternalPathParser(namingOptions, localizationManager, _type);
        }

        /// <summary>
        /// Retrieves the external streams for the provided video.
        /// </summary>
        /// <param name="video">The <see cref="Video"/> object to search external streams for.</param>
        /// <param name="startIndex">The stream index to start adding external streams at.</param>
        /// <param name="directoryService">The directory service to search for files.</param>
        /// <param name="clearCache">True if the directory service cache should be cleared before searching.</param>
        /// <param name="cancellationToken">The cancellation token.</param>
        /// <returns>The external streams located.</returns>
        public async Task<IReadOnlyList<MediaStream>> GetExternalStreamsAsync(
            Video video,
            int startIndex,
            IDirectoryService directoryService,
            bool clearCache,
            CancellationToken cancellationToken)
        {
            if (!video.IsFileProtocol)
            {
                return Array.Empty<MediaStream>();
            }

            var pathInfos = GetExternalFiles(video, directoryService, clearCache);

            if (!pathInfos.Any())
            {
                return Array.Empty<MediaStream>();
            }

            var mediaStreams = new List<MediaStream>();

            foreach (var pathInfo in pathInfos)
            {
                if (!pathInfo.Path.AsSpan().EndsWith(".strm", StringComparison.OrdinalIgnoreCase))
                {
                    try
                    {
                        var mediaInfo = await GetMediaInfo(pathInfo.Path, _type, cancellationToken).ConfigureAwait(false);

                        if (mediaInfo.MediaStreams.Count == 1)
                        {
                            MediaStream mediaStream = mediaInfo.MediaStreams[0];

                            if ((mediaStream.Type == MediaStreamType.Audio && _type == DlnaProfileType.Audio)
                                || (mediaStream.Type == MediaStreamType.Subtitle && _type == DlnaProfileType.Subtitle))
                            {
                                mediaStream.Index = startIndex++;
                                mediaStream.IsDefault = pathInfo.IsDefault;
                                mediaStream.IsForced = pathInfo.IsForced || mediaStream.IsForced;
                                mediaStream.IsHearingImpaired = pathInfo.IsHearingImpaired || mediaStream.IsHearingImpaired;

                                mediaStreams.Add(MergeMetadata(mediaStream, pathInfo));
                            }
                        }
                        else
                        {
                            foreach (MediaStream mediaStream in mediaInfo.MediaStreams)
                            {
                                if ((mediaStream.Type == MediaStreamType.Audio && _type == DlnaProfileType.Audio)
                                    || (mediaStream.Type == MediaStreamType.Subtitle && _type == DlnaProfileType.Subtitle))
                                {
                                    mediaStream.Index = startIndex++;

                                    mediaStreams.Add(MergeMetadata(mediaStream, pathInfo));
                                }
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        _logger.LogError(ex, "Error getting external streams from {Path}", pathInfo.Path);

                        continue;
                    }
                }
            }

            return mediaStreams;
        }

        /// <summary>
        /// Retrieves the external streams for the provided audio.
        /// </summary>
        /// <param name="audio">The <see cref="Audio"/> object to search external streams for.</param>
        /// <param name="startIndex">The stream index to start adding external streams at.</param>
        /// <param name="directoryService">The directory service to search for files.</param>
        /// <param name="clearCache">True if the directory service cache should be cleared before searching.</param>
        /// <returns>The external streams located.</returns>
        public IReadOnlyList<MediaStream> GetExternalStreams(
            Audio audio,
            int startIndex,
            IDirectoryService directoryService,
            bool clearCache)
        {
            if (!audio.IsFileProtocol)
            {
                return Array.Empty<MediaStream>();
            }

            var pathInfos = GetExternalFiles(audio, directoryService, clearCache);

            if (pathInfos.Count == 0)
            {
                return Array.Empty<MediaStream>();
            }

            var mediaStreams = new MediaStream[pathInfos.Count];

            for (var i = 0; i < pathInfos.Count; i++)
            {
                mediaStreams[i] = new MediaStream
                {
                    Type = MediaStreamType.Lyric,
                    Path = pathInfos[i].Path,
                    Language = pathInfos[i].Language,
                    Index = startIndex++
                };
            }

            return mediaStreams;
        }

        /// <summary>
        /// Returns the external file infos for the given video.
        /// </summary>
        /// <param name="video">The <see cref="Video"/> object to search external files for.</param>
        /// <param name="directoryService">The directory service to search for files.</param>
        /// <param name="clearCache">True if the directory service cache should be cleared before searching.</param>
        /// <returns>The external file paths located.</returns>
        public IReadOnlyList<ExternalPathParserResult> GetExternalFiles(
            Video video,
            IDirectoryService directoryService,
            bool clearCache)
        {
            if (!video.IsFileProtocol)
            {
                return Array.Empty<ExternalPathParserResult>();
            }

            // Check if video folder exists
            string folder = video.ContainingFolderPath;
            if (!_fileSystem.DirectoryExists(folder))
            {
                return Array.Empty<ExternalPathParserResult>();
            }

            var files = directoryService.GetFilePaths(folder, clearCache).ToList();
            files.Remove(video.Path);
            var internalMetadataPath = video.GetInternalMetadataPath();
            if (_fileSystem.DirectoryExists(internalMetadataPath))
            {
                files.AddRange(directoryService.GetFilePaths(internalMetadataPath, clearCache));
            }

            if (files.Count == 0)
            {
                return Array.Empty<ExternalPathParserResult>();
            }

            // VobSub .sub payloads only carry per-track language metadata when read via
            // their paired .idx file, so probe the .idx instead and skip the .sub. Pairing
            // requires the same directory (ffprobe can't resolve a split pair) and an
            // ordinal comparison (ffprobe matches the .sub by exact case on case-sensitive
            // filesystems, so a looser match could suppress a .sub with no working .idx).
            // An .idx file with no paired .sub cannot be probed at all, so it is left out
            // entirely rather than surfaced (which would otherwise fail every probe and,
            // since the .idx would keep "existing" from Jellyfin's point of view, prevent
            // stale subtitle stream metadata from ever being cleared once the .sub is gone).
            HashSet<string>? pairedVobSubKeys = _type == DlnaProfileType.Subtitle
                ? GetPairedVobSubKeys(files)
                : null;

            var externalPathInfos = new List<ExternalPathParserResult>();
            ReadOnlySpan<char> prefix = video.FileNameWithoutExtension;
            foreach (var file in files)
            {
                if (IsSuppressedVobSubFile(file, pairedVobSubKeys))
                {
                    continue;
                }

                var fileNameWithoutExtension = Path.GetFileNameWithoutExtension(file.AsSpan());
                if (fileNameWithoutExtension.Length >= prefix.Length
                    && prefix.Equals(fileNameWithoutExtension[..prefix.Length], StringComparison.OrdinalIgnoreCase)
                    && (fileNameWithoutExtension.Length == prefix.Length || _namingOptions.MediaFlagDelimiters.Contains(fileNameWithoutExtension[prefix.Length])))
                {
                    var externalPathInfo = _externalPathParser.ParseFile(file, fileNameWithoutExtension[prefix.Length..].ToString());

                    if (externalPathInfo is not null)
                    {
                        externalPathInfos.Add(externalPathInfo);
                    }
                }
            }

            return externalPathInfos;
        }

        /// <summary>
        /// Returns the external file infos for the given audio.
        /// </summary>
        /// <param name="audio">The <see cref="Audio"/> object to search external files for.</param>
        /// <param name="directoryService">The directory service to search for files.</param>
        /// <param name="clearCache">True if the directory service cache should be cleared before searching.</param>
        /// <returns>The external file paths located.</returns>
        public IReadOnlyList<ExternalPathParserResult> GetExternalFiles(
            Audio audio,
            IDirectoryService directoryService,
            bool clearCache)
        {
            if (!audio.IsFileProtocol)
            {
                return Array.Empty<ExternalPathParserResult>();
            }

            string folder = audio.ContainingFolderPath;
            var files = directoryService.GetFilePaths(folder, clearCache).ToList();
            files.Remove(audio.Path);
            var internalMetadataPath = audio.GetInternalMetadataPath();
            if (_fileSystem.DirectoryExists(internalMetadataPath))
            {
                files.AddRange(directoryService.GetFilePaths(internalMetadataPath, clearCache));
            }

            if (files.Count == 0)
            {
                return Array.Empty<ExternalPathParserResult>();
            }

            var externalPathInfos = new List<ExternalPathParserResult>();
            ReadOnlySpan<char> prefix = audio.FileNameWithoutExtension;
            foreach (var file in files)
            {
                var fileNameWithoutExtension = Path.GetFileNameWithoutExtension(file.AsSpan());
                if (fileNameWithoutExtension.Length >= prefix.Length
                    && prefix.Equals(fileNameWithoutExtension[..prefix.Length], StringComparison.OrdinalIgnoreCase)
                    && (fileNameWithoutExtension.Length == prefix.Length || _namingOptions.MediaFlagDelimiters.Contains(fileNameWithoutExtension[prefix.Length])))
                {
                    var externalPathInfo = _externalPathParser.ParseFile(file, fileNameWithoutExtension[prefix.Length..].ToString());

                    if (externalPathInfo is not null)
                    {
                        externalPathInfos.Add(externalPathInfo);
                    }
                }
            }

            return externalPathInfos;
        }

        /// <summary>
        /// Determines whether a candidate file is part of a VobSub .idx/.sub pair that
        /// should be resolved to only its .idx file, or an .idx file with no paired .sub
        /// that cannot be probed at all.
        /// </summary>
        /// <param name="file">The full path to the candidate file.</param>
        /// <param name="pairedVobSubKeys">The set of pairing keys with both an .idx and .sub present, or null if not applicable.</param>
        /// <returns><c>true</c> if the file should be suppressed; otherwise, <c>false</c>.</returns>
        private static bool IsSuppressedVobSubFile(string file, HashSet<string>? pairedVobSubKeys)
        {
            if (pairedVobSubKeys is null)
            {
                return false;
            }

            var extension = Path.GetExtension(file.AsSpan());
            if (extension.Equals(".sub", StringComparison.OrdinalIgnoreCase))
            {
                // A paired .idx exists; probe it instead of the .sub payload.
                return pairedVobSubKeys.Contains(GetVobSubPairingKey(file));
            }

            if (extension.Equals(".idx", StringComparison.OrdinalIgnoreCase))
            {
                // Without its .sub payload, the .idx cannot be probed for any data.
                return !pairedVobSubKeys.Contains(GetVobSubPairingKey(file));
            }

            return false;
        }

        /// <summary>
        /// Builds the set of directory+basename keys that have both an .idx and a .sub
        /// file present, in a single pass over the candidate files.
        /// </summary>
        /// <param name="files">The candidate files to search.</param>
        /// <returns>The set of pairing keys with both an .idx and .sub present.</returns>
        private static HashSet<string> GetPairedVobSubKeys(IEnumerable<string> files)
        {
            var idxKeys = new HashSet<string>(StringComparer.Ordinal);
            var subKeys = new HashSet<string>(StringComparer.Ordinal);
            foreach (var file in files)
            {
                var extension = Path.GetExtension(file.AsSpan());
                if (extension.Equals(".idx", StringComparison.OrdinalIgnoreCase))
                {
                    idxKeys.Add(GetVobSubPairingKey(file));
                }
                else if (extension.Equals(".sub", StringComparison.OrdinalIgnoreCase))
                {
                    subKeys.Add(GetVobSubPairingKey(file));
                }
            }

            idxKeys.IntersectWith(subKeys);
            return idxKeys;
        }

        /// <summary>
        /// Builds a directory+basename key used to pair a VobSub .idx file with its .sub
        /// payload only when both live in the same directory.
        /// </summary>
        /// <param name="file">The full path to the file.</param>
        /// <returns>A key combining the containing directory and file name without extension.</returns>
        private static string GetVobSubPairingKey(string file)
        {
            var directory = Path.GetDirectoryName(file) ?? string.Empty;
            var baseName = Path.GetFileNameWithoutExtension(file);
            return Path.Combine(directory, baseName);
        }

        /// <summary>
        /// Returns the media info of the given file.
        /// </summary>
        /// <param name="path">The path to the file.</param>
        /// <param name="type">The <see cref="DlnaProfileType"/>.</param>
        /// <param name="cancellationToken">The cancellation token to cancel operation.</param>
        /// <returns>The media info for the given file.</returns>
        private Task<Model.MediaInfo.MediaInfo> GetMediaInfo(string path, DlnaProfileType type, CancellationToken cancellationToken)
        {
            cancellationToken.ThrowIfCancellationRequested();

            return _mediaEncoder.GetMediaInfo(
                new MediaInfoRequest
                {
                    MediaType = type,
                    MediaSource = new MediaSourceInfo
                    {
                        Path = path,
                        Protocol = MediaProtocol.File
                    }
                },
                cancellationToken);
        }

        /// <summary>
        /// Merges path metadata into stream metadata.
        /// </summary>
        /// <param name="mediaStream">The <see cref="MediaStream"/> object.</param>
        /// <param name="pathInfo">The <see cref="ExternalPathParserResult"/> object.</param>
        /// <returns>The modified mediaStream.</returns>
        private MediaStream MergeMetadata(MediaStream mediaStream, ExternalPathParserResult pathInfo)
        {
            mediaStream.Path = pathInfo.Path;
            mediaStream.IsExternal = true;
            mediaStream.Title = string.IsNullOrEmpty(mediaStream.Title) ? (string.IsNullOrEmpty(pathInfo.Title) ? null : pathInfo.Title) : mediaStream.Title;
            mediaStream.Language = string.IsNullOrEmpty(mediaStream.Language) ? (string.IsNullOrEmpty(pathInfo.Language) ? null : pathInfo.Language) : mediaStream.Language;

            return mediaStream;
        }
    }
}