using System.Net.Http;
using System.Security.Cryptography;
using System.Text;
using System.Text.Json.Nodes;
using System.Text.RegularExpressions;

namespace Music;

public class AppleMusicDiscoveryProvider : IMusicDiscoveryProvider
{
    static readonly HttpClient httpClient = MusicHttp.CreateClient("applemusic");
    static readonly TimeSpan cacheTtl = TimeSpan.FromHours(6);

    public const string ProviderId = "applemusiccharts";
    const string defaultCountry = "us";
    const string userAgent = "LampacNextgenMusic/0.1 (https://github.com/lampac-nextgen/lampac)";

    public string Id => ProviderId;
    public string Name => "Apple Music Charts";
    public bool Enabled => true;

    static AppleMusicDiscoveryProvider()
    {
        httpClient.Timeout = TimeSpan.FromSeconds(20);
    }

    public async Task<List<MusicBrowseSection>> GetHomeSectionsAsync(int limit, CancellationToken cancellationToken = default)
    {
        var feed = await GetTopAlbumsAsync(cancellationToken);
        if (feed.Count == 0)
            return new List<MusicBrowseSection>();

        var sections = new List<MusicBrowseSection>
        {
            new MusicBrowseSection
            {
                id = "browse:top_albums",
                title = "Популярные альбомы",
                type = "album",
                source_provider = Id,
                has_more = feed.Count > limit,
                albums = feed.Take(limit).ToList()
            }
        };

        var fresh = feed
            .Where(i => TryParseDate(i.date, out var releaseDate) && releaseDate >= DateTime.UtcNow.Date.AddDays(-180))
            .OrderByDescending(i => i.date)
            .Take(limit)
            .ToList();

        if (fresh.Count > 0)
        {
            sections.Add(new MusicBrowseSection
            {
                id = "browse:fresh_releases",
                title = "Свежие релизы",
                type = "album",
                source_provider = Id,
                has_more = fresh.Count >= limit,
                albums = fresh
            });
        }

        sections.AddRange(BuildGenreSections(feed, limit));

        return sections;
    }

    public async Task<MusicBrowseSection> GetSectionAsync(string sectionId, int limit, CancellationToken cancellationToken = default)
    {
        var feed = await GetTopAlbumsAsync(cancellationToken);
        if (feed.Count == 0)
            return null;

        return sectionId switch
        {
            "browse:top_albums" => new MusicBrowseSection
            {
                id = sectionId,
                title = "Популярные альбомы",
                type = "album",
                source_provider = Id,
                has_more = false,
                albums = feed.Take(Math.Max(limit, 1)).ToList()
            },
            "browse:fresh_releases" => new MusicBrowseSection
            {
                id = sectionId,
                title = "Свежие релизы",
                type = "album",
                source_provider = Id,
                has_more = false,
                albums = feed
                    .Where(i => TryParseDate(i.date, out var releaseDate) && releaseDate >= DateTime.UtcNow.Date.AddDays(-180))
                    .OrderByDescending(i => i.date)
                    .Take(Math.Max(limit, 1))
                    .ToList()
            },
            _ when TryParseGenreSection(feed, sectionId, out var genre) => BuildGenreSection(feed, genre, Math.Max(limit, 1), hasMore: false),
            _ => null
        };
    }

    public static bool IsChartAlbum(string provider, string id)
        => string.Equals(provider, ProviderId, StringComparison.OrdinalIgnoreCase)
           || (id ?? string.Empty).StartsWith("applecharts:", StringComparison.OrdinalIgnoreCase);

    public Task<MusicAlbum> GetAlbumAsync(string id, CancellationToken cancellationToken = default)
    {
        string albumId = (id ?? string.Empty).StartsWith("applecharts:", StringComparison.OrdinalIgnoreCase)
            ? id["applecharts:".Length..]
            : id;

        return Regex.IsMatch(albumId ?? string.Empty, "^[0-9]+$")
            ? AppleMusicSupport.GetCatalogAlbumAsync(CurrentCountry, albumId, cancellationToken)
            : Task.FromResult<MusicAlbum>(null);
    }

    async Task<List<MusicAlbum>> GetTopAlbumsAsync(CancellationToken cancellationToken)
    {
        string country = GetCountry();
        var albums = await MusicMetadataCacheService.GetOrCreateAsync(
            ProviderId,
            "browse",
            $"{country}:top-albums",
            cacheTtl,
            () => LoadTopAlbumsAsync(country, cancellationToken),
            cancellationToken
        ) ?? new List<MusicAlbum>();

        string resolver = GetAlbumResolver();
        return albums.Select(album => CopyAlbumForResponse(album, resolver)).ToList();
    }

    static MusicAlbum CopyAlbumForResponse(MusicAlbum album, string resolver)
    {
        return new MusicAlbum
        {
            id = album.id,
            title = album.title,
            artist_id = album.artist_id,
            artist_name = album.artist_name,
            lookup_query = album.lookup_query,
            lookup_provider = resolver,
            year = album.year,
            date = album.date,
            type = album.type,
            release_id = album.release_id,
            description = album.description,
            search_score = album.search_score,
            secondary_types = album.secondary_types?.ToList() ?? new List<string>(),
            images = album.images?.ToList() ?? new List<MusicImage>(),
            provider_refs = album.provider_refs?.ToList() ?? new List<MusicProviderRef>(),
            tracks = album.tracks?.ToList() ?? new List<MusicTrack>()
        };
    }

    async Task<List<MusicAlbum>> LoadTopAlbumsAsync(string country, CancellationToken cancellationToken)
    {
        using var request = new HttpRequestMessage(HttpMethod.Get, $"https://rss.marketingtools.apple.com/api/v2/{country}/music/most-played/100/albums.json");
        request.Headers.TryAddWithoutValidation("User-Agent", userAgent);
        request.Headers.TryAddWithoutValidation("Accept", "application/json");

        using var response = await httpClient.SendAsync(request, cancellationToken);
        if (!response.IsSuccessStatusCode)
            return new List<MusicAlbum>();

        var json = await response.Content.ReadAsStringAsync(cancellationToken);
        var root = JsonNode.Parse(json) as JsonObject;
        var results = root?["feed"]?["results"] as JsonArray;

        if (results == null)
            return new List<MusicAlbum>();

        return results
            .Select(node => ParseAlbum(node as JsonObject))
            .Where(i => i != null)
            .ToList();
    }

    static string GetCountry()
    {
        string country = ModInit.conf?.applemusic_country;
        if (string.IsNullOrWhiteSpace(country))
            return defaultCountry;

        country = country.Trim().ToLowerInvariant();
        return Regex.IsMatch(country, "^[a-z]{2}$") ? country : defaultCountry;
    }

    public static string CurrentCountry => GetCountry();

    static string GetAlbumResolver()
    {
        string resolver = ModInit.conf?.applemusic_album_resolver?.Trim().ToLowerInvariant();
        return resolver is "applemusic" or "spotify" or "soundcloud" or "musicbrainz" ? resolver : "auto";
    }

    static MusicAlbum ParseAlbum(JsonObject item)
    {
        if (item == null)
            return null;

        string title = item["name"]?.GetValue<string>()?.Trim();
        string artistName = item["artistName"]?.GetValue<string>()?.Trim();

        if (string.IsNullOrWhiteSpace(title) || string.IsNullOrWhiteSpace(artistName))
            return null;

        string lookupQuery = $"{artistName} {title}";
        string artwork = UpgradeArtwork(item["artworkUrl100"]?.GetValue<string>());
        string date = item["releaseDate"]?.GetValue<string>();
        string appleId = item["id"]?.GetValue<string>();
        string externalId = string.IsNullOrWhiteSpace(appleId)
            ? StableId(lookupQuery)
            : appleId;

        return new MusicAlbum
        {
            id = $"applecharts:{externalId}",
            title = title,
            artist_name = artistName,
            lookup_query = lookupQuery,
            lookup_provider = GetAlbumResolver(),
            date = date,
            year = ParseYear(date),
            type = "Album",
            description = JoinGenres(item["genres"] as JsonArray),
            images = string.IsNullOrWhiteSpace(artwork)
                ? new List<MusicImage>()
                : new List<MusicImage> { new() { url = artwork, width = 600, height = 600 } },
            provider_refs = new List<MusicProviderRef>
            {
                new() { provider = ProviderId, external_id = externalId }
            }
        };
    }

    static string JoinGenres(JsonArray items)
    {
        if (items == null)
            return null;

        var genres = items
            .Select(node => node?["name"]?.GetValue<string>())
            .Where(name => !string.IsNullOrWhiteSpace(name))
            .Distinct()
            .ToList();

        return genres.Count == 0 ? null : string.Join(" · ", genres);
    }

    static List<MusicBrowseSection> BuildGenreSections(List<MusicAlbum> feed, int limit)
    {
        if (feed == null || feed.Count == 0)
            return new List<MusicBrowseSection>();

        return feed
            .Select(item => PrimaryGenre(item))
            .Where(genre => !string.IsNullOrWhiteSpace(genre))
            .GroupBy(genre => genre)
            .Where(group => group.Count() >= Math.Max(6, limit / 2))
            .OrderByDescending(group => group.Count())
            .ThenBy(group => group.Key)
            .Take(3)
            .Select(group => BuildGenreSection(feed, group.Key, limit, hasMore: group.Count() > limit))
            .Where(section => section != null && section.albums.Count > 0)
            .ToList();
    }

    static MusicBrowseSection BuildGenreSection(List<MusicAlbum> feed, string genre, int limit, bool hasMore)
    {
        if (feed == null || feed.Count == 0 || string.IsNullOrWhiteSpace(genre))
            return null;

        var albums = feed
            .Where(album => string.Equals(PrimaryGenre(album), genre, StringComparison.OrdinalIgnoreCase))
            .Take(Math.Max(limit, 1))
            .ToList();

        if (albums.Count == 0)
            return null;

        return new MusicBrowseSection
        {
            id = $"browse:genre:{GenreSlug(genre)}",
            title = $"Популярное: {LocalizeGenre(genre)}",
            type = "album",
            source_provider = ProviderId,
            has_more = hasMore,
            albums = albums
        };
    }

    static string PrimaryGenre(MusicAlbum album)
    {
        if (album == null || string.IsNullOrWhiteSpace(album.description))
            return null;

        return album.description
            .Split(" · ", StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries)
            .FirstOrDefault(genre => !string.Equals(genre, "Music", StringComparison.OrdinalIgnoreCase));
    }

    static string GenreSlug(string genre)
    {
        if (string.IsNullOrWhiteSpace(genre))
            return string.Empty;

        var slug = System.Text.RegularExpressions.Regex.Replace(genre.ToLowerInvariant(), @"[^a-z0-9]+", "-").Trim('-');
        return string.IsNullOrWhiteSpace(slug) ? StableId(genre) : slug;
    }

    static bool TryParseGenreSection(List<MusicAlbum> feed, string sectionId, out string genre)
    {
        genre = null;
        if (string.IsNullOrWhiteSpace(sectionId) || !sectionId.StartsWith("browse:genre:", StringComparison.OrdinalIgnoreCase))
            return false;

        var slug = sectionId.Substring("browse:genre:".Length);
        if (string.IsNullOrWhiteSpace(slug))
            return false;

        var feedGenres = feed?
            .Select(PrimaryGenre)
            .Where(item => !string.IsNullOrWhiteSpace(item))
            .Distinct(StringComparer.OrdinalIgnoreCase)
            .ToList() ?? new List<string>();

        genre = feedGenres.FirstOrDefault(item => string.Equals(GenreSlug(item), slug, StringComparison.OrdinalIgnoreCase));
        return !string.IsNullOrWhiteSpace(genre);
    }

    static string LocalizeGenre(string genre)
    {
        return genre switch
        {
            "Hip-Hop/Rap" => "Хип-хоп и рэп",
            "Pop" => "Поп",
            "Rock" => "Рок",
            "Country" => "Кантри",
            "Alternative" => "Альтернатива",
            "R&B/Soul" => "R&B и соул",
            "Dance" => "Танцевальная",
            "Singer/Songwriter" => "Авторская песня",
            "Latin" => "Латино",
            "Christian" => "Христианская музыка",
            "Jazz" => "Джаз",
            "Electronic" => "Электроника",
            "K-Pop" => "K-Pop",
            "Indie Rock" => "Инди-рок",
            "Hard Rock" => "Хард-рок",
            "Soundtrack" => "Саундтреки",
            _ => genre
        };
    }

    static string UpgradeArtwork(string url)
    {
        if (string.IsNullOrWhiteSpace(url))
            return null;

        return System.Text.RegularExpressions.Regex.Replace(
            url,
            "/\\d+x\\d+bb\\.",
            "/600x600bb.",
            System.Text.RegularExpressions.RegexOptions.IgnoreCase
        );
    }

    static int? ParseYear(string value)
    {
        if (string.IsNullOrWhiteSpace(value) || value.Length < 4)
            return null;

        return int.TryParse(value.Substring(0, 4), out var year) ? year : null;
    }

    static bool TryParseDate(string value, out DateTime date)
    {
        return DateTime.TryParse(value, out date);
    }

    static string StableId(string value)
    {
        var bytes = MD5.HashData(Encoding.UTF8.GetBytes(value ?? string.Empty));
        return Convert.ToHexString(bytes).ToLowerInvariant();
    }
}