webzine/Webzine.Business/Mappers/Spotify/SpotifyMapper.cs

namespace Webzine.Business.Mappers.Spotify
{
    using System.Globalization;

    using Webzine.Business.DTOs.Spotify;
    using Webzine.Entity;

    /// <summary>
    /// Mapper pour transformer les objets de Spotify (DTOs) en Entity.
    /// </summary>
    public static class SpotifyMapper
    {
        /// <summary>
        /// Permet d'ajouter ou de creer un style.
        /// </summary>
        /// <param name="styles">Dictionnaire string, Style.</param>
        /// <param name="genre">Genre.</param>
        /// <param name="nextStyleId">Id du style.</param>
        /// <returns>Le style.</returns>
        public static Style GetOrCreateStyle(Dictionary<string, Style> styles, string genre, ref int nextStyleId)
        {
            // On verifie si le genre est présent dans la liste de styles.
            if (!styles.TryGetValue(genre, out var style))
            {
                // Creation d'un nouveau style.
                style = new Style
                {
                    IdStyle = nextStyleId++,
                    Libelle = genre,
                    Titres = new List<Titre>(),
                };

                // Ajout dans la liste.
                styles.Add(style.Libelle, style);
            }

            return style;
        }

        /// <summary>
        /// Creation d'un nouvel artiste a l'aide des infos Spotify.
        /// </summary>
        /// <param name="artisteSpotify">Artiste spotify.</param>
        /// <param name="stylesTitre">Style spotify.</param>
        /// <param name="idArtiste">Id de l'artiste.</param>
        /// <returns>Artiste.</returns>
        public static Artiste ToArtiste(SpotifyArtistDto artisteSpotify, List<Style> stylesTitre, int idArtiste)
        {
            // Spotify ne possède pas de Biographie pour les artistes.
            // On affiche donc son nom, et les styles qui lui sont associés.
            return new Artiste
            {
                IdArtiste = idArtiste,
                Nom = artisteSpotify.Name,
                Biographie = $"{artisteSpotify.Name} est un artiste present sur Spotify, associe aux styles {string.Join(", ", stylesTitre.Select(s => s.Libelle))}.",
                Titres = new List<Titre>(),
            };
        }

        /// <summary>
        /// Permet de creer un titre depuis les donn<6E>es de Spotify.
        /// </summary>
        /// <param name="track">Titre de spotify.</param>
        /// <param name="album">Album de spotify.</param>
        /// <param name="artiste">Artiste mappe.</param>
        /// <param name="stylesTitre">Style du titre.</param>
        /// <param name="idTitre">Id du titre.</param>
        /// <returns>Nouveau Titre.</returns>
        public static Titre ToTitre(SpotifyTrackDto track, SpotifyAlbumDto album, Artiste artiste, List<Style> stylesTitre, int idTitre)
        {
            // Spotify ne fournit pas les elements suivants : Chronique, DateCreation, NbLectures, NbLikes.
            return new Titre
            {
                IdTitre = idTitre,
                IdArtiste = artiste.IdArtiste,
                Artiste = artiste,
                Libelle = track.Name,
                Chronique = $"{track.Name} est un titre de {artiste.Nom}, issu de l'album {album.Name}. Cette fiche a ete generee depuis Spotify.",
                DateCreation = DateTime.UtcNow,
                DateSortie = ParseDate(album.ReleaseDate),
                Duree = Math.Max(1, track.DurationMs / 1000),
                UrlJaquette = album.Images.FirstOrDefault()?.Url,
                UrlEcoute = Trim(track.ExternalUrls?.Spotify ?? $"https://open.spotify.com/track/{track.Id}", 250, string.Empty),
                NbLectures = Random.Shared.Next(500, 50000),
                NbLikes = Random.Shared.Next(50, 5000),
                Album = album.Name,
                Commentaires = new List<Commentaire>(),
                Styles = new List<Style>(stylesTitre),
            };
        }

        private static string Trim(string? value, int maxLength, string fallback)
        {
            var result = string.IsNullOrWhiteSpace(value) ? fallback : value.Trim();
            return result.Length > maxLength ? result[..maxLength] : result;
        }

        /// <summary>
        /// Permet de transformer une date recu en chaine de caractere en type DateTime.
        /// </summary>
        /// <param name="value">Date en chaine de caractere.</param>
        /// <returns>DateTime.</returns>
        private static DateTime ParseDate(string? value)
        {
            if (string.IsNullOrWhiteSpace(value))
            {
                return DateTime.UtcNow;
            }

            if (DateTime.TryParse(value, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal, out var date))
            {
                return DateTime.SpecifyKind(date, DateTimeKind.Utc);
            }

            if (DateTime.TryParseExact(value, "yyyy-MM", CultureInfo.InvariantCulture, DateTimeStyles.None, out date))
            {
                return DateTime.SpecifyKind(date, DateTimeKind.Utc);
            }

            if (DateTime.TryParseExact(value, "yyyy", CultureInfo.InvariantCulture, DateTimeStyles.None, out date))
            {
                return DateTime.SpecifyKind(date, DateTimeKind.Utc);
            }

            return DateTime.UtcNow;
        }
    }
}