using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Jellyfin.Plugin.MediaCleaner.Helpers;
using Jellyfin.Plugin.MediaCleaner.Models;
using MediaBrowser.Controller.Library;
using Microsoft.Extensions.Logging;
using Jellyfin.Plugin.MediaCleaner.Enums;
using System.Net.Http;
using System;
using System.Text.Json;
using System.Globalization;
using MediaBrowser.Model.Tasks;
using Microsoft.AspNetCore.Mvc;

namespace Jellyfin.Plugin.MediaCleaner.Data;

public class MediaCleanerState(ILogger<StaleMediaScanner> logger, ILibraryManager libraryManager, ITaskManager taskManager)
{
    private readonly Lock _lock = new();
    private IEnumerable<MediaInfo> _mediaInfo = [];
    private readonly StaleMediaScanner _staleMediaScanner = new(logger, libraryManager);
    // private readonly ILibraryManager _libraryManager = libraryManager;
    private readonly ITaskManager _taskManager = taskManager;

    public async Task UpdateState()
    {
        // First re-scan library and then scan for stale media.
        IScheduledTaskWorker? refreshLibraryWorker = _taskManager.ScheduledTasks.FirstOrDefault(task => task.ScheduledTask.Key == "RefreshLibrary");

        if(refreshLibraryWorker != null)
        {
            await _taskManager.Execute(refreshLibraryWorker, new TaskOptions()).ConfigureAwait(false);
        }

        _mediaInfo = await _staleMediaScanner.ScanStaleMedia().ConfigureAwait(false);

        return;
    }

    public async Task<IEnumerable<SeriesInfo>> GetTvSeriesInfo()
    {
        // Filter only TV
        // Get all series on tv sonarr server
        HttpHelper httpHelper = new HttpHelper(ServerType.Sonarr);
        JsonElement tvSeriesResponse = new JsonElement();
        try
        {
            tvSeriesResponse = await httpHelper.SendHttpRequestAsync(HttpMethod.Get,"/api/v3/series").ConfigureAwait(false);
        }
        catch
        {
            return [];
        }

        var tvSeries = JsonSerializer.Deserialize<IEnumerable<SonarrSeries>>(tvSeriesResponse.GetRawText());
        if(tvSeries == null)
        {
            return [];
        }

        lock (_lock)
        {
            var allSeries = _mediaInfo.OfType<SeriesInfo>();

            var tvSeriesInfo = allSeries
            .Where(series => tvSeries.Any(tv => tv.TvdbId == int.Parse(series.TvdbId, CultureInfo.InvariantCulture)));

            return [.. tvSeriesInfo];
        }
    }

    public async Task<IEnumerable<SeriesInfo>> GetAnimeSeriesInfo()
    {
        // Get all series on anime sonarr server
        HttpHelper animeHttpHelper = new HttpHelper(ServerType.SonarrAnime);
        JsonElement animeSeriesResponse = new JsonElement();
        try
        {
            animeSeriesResponse = await animeHttpHelper.SendHttpRequestAsync(HttpMethod.Get,"/api/v3/series").ConfigureAwait(false);
        }
        catch
        {
            return [];
        }

        var animeSeries = JsonSerializer.Deserialize<List<SonarrSeries>>(animeSeriesResponse.GetRawText());

        if(animeSeries == null)
        {
            return Enumerable.Empty<SeriesInfo>();
        }

        lock (_lock)
        {
            var allSeries = _mediaInfo.OfType<SeriesInfo>();

            var animeSeriesInfo = allSeries
            .Where(series => animeSeries.Any(anime => anime.TvdbId == int.Parse(series.TvdbId, CultureInfo.InvariantCulture)));

            return animeSeriesInfo;
        }
    }

    public IEnumerable<MovieInfo> GetMovieInfo()
    {
        lock (_lock)
        {
            return _mediaInfo.OfType<MovieInfo>();
        }
    }
}