#nullable disable

#pragma warning disable CS1591

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Jellyfin.Extensions;
using MediaBrowser.Common.Extensions;
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Entities.Movies;
using MediaBrowser.Controller.Entities.TV;
using MediaBrowser.Controller.Library;
using MediaBrowser.Controller.Persistence;
using MediaBrowser.Controller.Providers;
using MediaBrowser.Controller.Subtitles;
using MediaBrowser.Model.Configuration;
using MediaBrowser.Model.Entities;
using MediaBrowser.Model.Globalization;
using MediaBrowser.Model.IO;
using MediaBrowser.Model.Providers;
using Microsoft.Extensions.Logging;

namespace MediaBrowser.Providers.Subtitles
{
    public class SubtitleManager : ISubtitleManager
    {
        private readonly ILogger<SubtitleManager> _logger;
        private readonly IFileSystem _fileSystem;
        private readonly ILibraryMonitor _monitor;
        private readonly IMediaSourceManager _mediaSourceManager;
        private readonly ILocalizationManager _localization;

        private ISubtitleProvider[] _subtitleProviders;

        public SubtitleManager(
            ILogger<SubtitleManager> logger,
            IFileSystem fileSystem,
            ILibraryMonitor monitor,
            IMediaSourceManager mediaSourceManager,
            ILocalizationManager localizationManager)
        {
            _logger = logger;
            _fileSystem = fileSystem;
            _monitor = monitor;
            _mediaSourceManager = mediaSourceManager;
            _localization = localizationManager;
        }

        /// <inheritdoc />
        public event EventHandler<SubtitleDownloadFailureEventArgs> SubtitleDownloadFailure;

        /// <inheritdoc />
        public void AddParts(IEnumerable<ISubtitleProvider> subtitleProviders)
        {
            _subtitleProviders = subtitleProviders
                .OrderBy(i => i is IHasOrder hasOrder ? hasOrder.Order : 0)
                .ToArray();
        }

        /// <inheritdoc />
        public async Task<RemoteSubtitleInfo[]> SearchSubtitles(SubtitleSearchRequest request, CancellationToken cancellationToken)
        {
            if (request.Language != null)
            {
                var culture = _localization.FindLanguageInfo(request.Language);

                if (culture != null)
                {
                    request.TwoLetterISOLanguageName = culture.TwoLetterISOLanguageName;
                }
            }

            var contentType = request.ContentType;
            var providers = _subtitleProviders
                .Where(i => i.SupportedMediaTypes.Contains(contentType) && !request.DisabledSubtitleFetchers.Contains(i.Name, StringComparison.OrdinalIgnoreCase))
                .OrderBy(i =>
                {
                    var index = request.SubtitleFetcherOrder.ToList().IndexOf(i.Name);
                    return index == -1 ? int.MaxValue : index;
                })
                .ToArray();

            // If not searching all, search one at a time until something is found
            if (!request.SearchAllProviders)
            {
                foreach (var provider in providers)
                {
                    try
                    {
                        var searchResults = await provider.Search(request, cancellationToken).ConfigureAwait(false);

                        var list = searchResults.ToArray();

                        if (list.Length > 0)
                        {
                            Normalize(list);
                            return list;
                        }
                    }
                    catch (Exception ex)
                    {
                        _logger.LogError(ex, "Error downloading subtitles from {Provider}", provider.Name);
                    }
                }

                return Array.Empty<RemoteSubtitleInfo>();
            }

            var tasks = providers.Select(async i =>
            {
                try
                {
                    var searchResults = await i.Search(request, cancellationToken).ConfigureAwait(false);

                    var list = searchResults.ToArray();
                    Normalize(list);
                    return list;
                }
                catch (Exception ex)
                {
                    _logger.LogError(ex, "Error downloading subtitles from {0}", i.Name);
                    return Array.Empty<RemoteSubtitleInfo>();
                }
            });

            var results = await Task.WhenAll(tasks).ConfigureAwait(false);

            return results.SelectMany(i => i).ToArray();
        }

        /// <inheritdoc />
        public Task DownloadSubtitles(Video video, string subtitleId, CancellationToken cancellationToken)
        {
            var libraryOptions = BaseItem.LibraryManager.GetLibraryOptions(video);

            return DownloadSubtitles(video, libraryOptions, subtitleId, cancellationToken);
        }

        /// <inheritdoc />
        public async Task DownloadSubtitles(
            Video video,
            LibraryOptions libraryOptions,
            string subtitleId,
            CancellationToken cancellationToken)
        {
            var parts = subtitleId.Split('_', 2);
            var provider = GetProvider(parts[0]);

            try
            {
                var response = await GetRemoteSubtitles(subtitleId, cancellationToken).ConfigureAwait(false);

                await TrySaveSubtitle(video, libraryOptions, response).ConfigureAwait(false);
            }
            catch (RateLimitExceededException)
            {
                throw;
            }
            catch (Exception ex)
            {
                SubtitleDownloadFailure?.Invoke(this, new SubtitleDownloadFailureEventArgs
                {
                    Item = video,
                    Exception = ex,
                    Provider = provider.Name
                });

                throw;
            }
        }

        /// <inheritdoc />
        public Task UploadSubtitle(Video video, SubtitleResponse response)
        {
            var libraryOptions = BaseItem.LibraryManager.GetLibraryOptions(video);
            return TrySaveSubtitle(video, libraryOptions, response);
        }

        private async Task TrySaveSubtitle(
            Video video,
            LibraryOptions libraryOptions,
            SubtitleResponse response)
        {
            var saveInMediaFolder = libraryOptions.SaveSubtitlesWithMedia;

            await using var stream = response.Stream;
            await using var memoryStream = new MemoryStream();
            await stream.CopyToAsync(memoryStream).ConfigureAwait(false);
            memoryStream.Position = 0;

            var savePaths = new List<string>();
            var saveFileName = Path.GetFileNameWithoutExtension(video.Path) + "." + response.Language.ToLowerInvariant();

            if (response.IsForced)
            {
                saveFileName += ".forced";
            }

            saveFileName += "." + response.Format.ToLowerInvariant();

            if (saveInMediaFolder)
            {
                var mediaFolderPath = Path.GetFullPath(Path.Combine(video.ContainingFolderPath, saveFileName));
                // TODO: Add some error handling to the API user: return BadRequest("Could not save subtitle, bad path.");
                if (mediaFolderPath.StartsWith(video.ContainingFolderPath, StringComparison.Ordinal))
                {
                    savePaths.Add(mediaFolderPath);
                }
            }

            var internalPath = Path.GetFullPath(Path.Combine(video.GetInternalMetadataPath(), saveFileName));

            // TODO: Add some error to the user: return BadRequest("Could not save subtitle, bad path.");
            if (internalPath.StartsWith(video.GetInternalMetadataPath(), StringComparison.Ordinal))
            {
                savePaths.Add(internalPath);
            }

            if (savePaths.Count > 0)
            {
                await TrySaveToFiles(memoryStream, savePaths).ConfigureAwait(false);
            }
            else
            {
                _logger.LogError("An uploaded subtitle could not be saved because the resulting paths were invalid.");
            }
        }

        private async Task TrySaveToFiles(Stream stream, List<string> savePaths)
        {
            List<Exception> exs = null;

            foreach (var savePath in savePaths)
            {
                _logger.LogInformation("Saving subtitles to {SavePath}", savePath);

                _monitor.ReportFileSystemChangeBeginning(savePath);

                try
                {
                    Directory.CreateDirectory(Path.GetDirectoryName(savePath));

                    var fileOptions = AsyncFile.WriteOptions;
                    fileOptions.Mode = FileMode.CreateNew;
                    fileOptions.PreallocationSize = stream.Length;
                    using var fs = new FileStream(savePath, fileOptions);
                    await stream.CopyToAsync(fs).ConfigureAwait(false);

                    return;
                }
                catch (Exception ex)
                {
// Bug in analyzer -- https://github.com/dotnet/roslyn-analyzers/issues/5160
#pragma warning disable CA1508
                    (exs ??= new List<Exception>()).Add(ex);
#pragma warning restore CA1508
                }
                finally
                {
                    _monitor.ReportFileSystemChangeComplete(savePath, false);
                }

                stream.Position = 0;
            }

            if (exs != null)
            {
                throw new AggregateException(exs);
            }
        }

        /// <inheritdoc />
        public Task<RemoteSubtitleInfo[]> SearchSubtitles(Video video, string language, bool? isPerfectMatch, bool isAutomated, CancellationToken cancellationToken)
        {
            if (video.VideoType != VideoType.VideoFile)
            {
                return Task.FromResult(Array.Empty<RemoteSubtitleInfo>());
            }

            VideoContentType mediaType;

            if (video is Episode)
            {
                mediaType = VideoContentType.Episode;
            }
            else if (video is Movie)
            {
                mediaType = VideoContentType.Movie;
            }
            else
            {
                // These are the only supported types
                return Task.FromResult(Array.Empty<RemoteSubtitleInfo>());
            }

            var request = new SubtitleSearchRequest
            {
                ContentType = mediaType,
                IndexNumber = video.IndexNumber,
                Language = language,
                MediaPath = video.Path,
                Name = video.Name,
                ParentIndexNumber = video.ParentIndexNumber,
                ProductionYear = video.ProductionYear,
                ProviderIds = video.ProviderIds,
                RuntimeTicks = video.RunTimeTicks,
                IsPerfectMatch = isPerfectMatch ?? false,
                IsAutomated = isAutomated
            };

            if (video is Episode episode)
            {
                request.IndexNumberEnd = episode.IndexNumberEnd;
                request.SeriesName = episode.SeriesName;
            }

            return SearchSubtitles(request, cancellationToken);
        }

        private void Normalize(IEnumerable<RemoteSubtitleInfo> subtitles)
        {
            foreach (var sub in subtitles)
            {
                sub.Id = GetProviderId(sub.ProviderName) + "_" + sub.Id;
            }
        }

        private string GetProviderId(string name)
        {
            return name.ToLowerInvariant().GetMD5().ToString("N", CultureInfo.InvariantCulture);
        }

        private ISubtitleProvider GetProvider(string id)
        {
            return _subtitleProviders.First(i => string.Equals(id, GetProviderId(i.Name), StringComparison.Ordinal));
        }

        /// <inheritdoc />
        public Task DeleteSubtitles(BaseItem item, int index)
        {
            var stream = _mediaSourceManager.GetMediaStreams(new MediaStreamQuery
            {
                Index = index,
                ItemId = item.Id,
                Type = MediaStreamType.Subtitle
            })[0];

            var path = stream.Path;
            _monitor.ReportFileSystemChangeBeginning(path);

            try
            {
                _fileSystem.DeleteFile(path);
            }
            finally
            {
                _monitor.ReportFileSystemChangeComplete(path, false);
            }

            return item.RefreshMetadata(CancellationToken.None);
        }

        /// <inheritdoc />
        public Task<SubtitleResponse> GetRemoteSubtitles(string id, CancellationToken cancellationToken)
        {
            var parts = id.Split('_', 2);

            var provider = GetProvider(parts[0]);
            id = parts[^1];

            return provider.GetSubtitles(id, cancellationToken);
        }

        /// <inheritdoc />
        public SubtitleProviderInfo[] GetSupportedProviders(BaseItem item)
        {
            VideoContentType mediaType;

            if (item is Episode)
            {
                mediaType = VideoContentType.Episode;
            }
            else if (item is Movie)
            {
                mediaType = VideoContentType.Movie;
            }
            else
            {
                // These are the only supported types
                return Array.Empty<SubtitleProviderInfo>();
            }

            return _subtitleProviders
                .Where(i => i.SupportedMediaTypes.Contains(mediaType))
                .Select(i => new SubtitleProviderInfo
                {
                    Name = i.Name,
                    Id = GetProviderId(i.Name)
                }).ToArray();
        }
    }
}