MyBookmark/Modules.Library.Database/GatewaysImplementations/Converters/AnimeTitleConverter.cs

using Modules.Library.Database.Database.Models.Anime;
using Modules.Library.Database.Database.Models.CommonProperties;
using Modules.Library.Database.Repositories;
using System.Linq;

namespace Modules.Library.Database.GatewaysImplementations.Converters;

internal class AnimeTitleConverter
{
    private readonly LanguageRepository _languageRepository;
    private readonly GenreRepository _genreRepository;
    private readonly CommonPropertiesConverter _commonPropertiesConverter;
    private readonly AnimeSeasonConverter _animeSeasonConverter;
    private readonly AnimeEpisodeConverter _animeEpisodeConverter;

    internal AnimeTitleConverter(LanguageRepository languageRepository, GenreRepository genreRepository)
    {
        _languageRepository = languageRepository;
        _genreRepository = genreRepository;
        _commonPropertiesConverter = new CommonPropertiesConverter(languageRepository, genreRepository);
        _animeSeasonConverter = new AnimeSeasonConverter(_commonPropertiesConverter);
        _animeEpisodeConverter = new AnimeEpisodeConverter(_commonPropertiesConverter);
    }

    internal async Task<Application.Models.Anime.Title> Convert(AnimeTitle title)
    {
        var dto = new Application.Models.Anime.Title
        {
            Id = title.Id,
            Deleted = title.Deleted,
            Rate = null,
            MyRate = null,
            Completed = title.Completed,
            CommonProperties = await _commonPropertiesConverter.Convert(title.CommonProperties),
            ExpirationTime = title.ExpirationTime,
        };
        foreach (var season in title.Items.OfType<AnimeSeason>())
        {
            dto.Seasons.Add(await _animeSeasonConverter.Convert(season));
        }
        foreach (var episode in title.Items.OfType<AnimeEpisode>())
        {
            dto.Episodes.Add(await _animeEpisodeConverter.Convert(episode));
        }
        return dto;
    }

    internal async Task<Domain.Entities.MediaContent.Items.Anime.AnimeTitle> ConvertToDomain(AnimeTitle title)
    {
        var dto = new Domain.Models.AnimeTitle
        {
            Id = title.Id,
            Deleted = title.Deleted,
            Completed = title.Completed,
            CommonProperties = await Convert(title.CommonProperties),
            ExpirationTime = title.ExpirationTime,
        };
        foreach (var season in title.Items.OfType<AnimeSeason>())
        {
            dto.Items.Add(await Convert(season));
        }
        foreach (var episode in title.Items.OfType<AnimeEpisode>())
        {
            dto.Items.Add(await Convert(episode));
        }
        return Domain.Entities.MediaContent.Items.Anime.AnimeTitle.New(dto);
    }


    internal async Task<Domain.Models.AnimeSeason> Convert(AnimeSeason season)
    {
        var result = new Domain.Models.AnimeSeason
        {
            Id = season.Id,
            Deleted = season.Deleted,
            Completed = season.Completed,

            CommonProperties = await Convert(season.CommonProperties),
            Number = season.Number,
            Order = season.Order,
            //Variant = season.Variant,
            ExpirationTime = season.ExpirationTime,

            Director = season.Director,
            OriginCountry = season.OriginCountry,
        };
        foreach (var episode in season.Episodes)
        {
            result.Episodes.Add(await Convert(episode));
        }
        return result;
    }


    private async Task<Domain.Models.CommonProperties> Convert(CommonProperties commonProperties)
    {
        var commonPropertiesLanguageIds = commonProperties.Names.Select(q => q.LanguageId).ToList();
        commonPropertiesLanguageIds.AddRange(commonProperties.Descriptions.Select(q => q.LanguageId));

        var languages = await _languageRepository.GetWhere(q => commonPropertiesLanguageIds.Distinct().Contains(q.Id));
        var genres = await _genreRepository.GetWhere(q => commonProperties.Genres.Select(q => q.Id).Distinct().Contains(q.Id));

        return new Domain.Models.CommonProperties
        {
            Names = commonProperties.Names.Select(q => new Domain.Models.NameItem
            {
                LanguageId = q.LanguageId,
                Type = (Domain.Entities.MediaContent.CommonProperties.NameType)q.Type,
                Value = q.Value,
            }),
            Preview = commonProperties.Preview == null ? null : new Domain.Models.MediaInfo
            {
                Type = (Domain.Entities.MediaInfoType)commonProperties.Preview.Type,
                ObjectId = commonProperties.Preview.ObjectId,
                ContentType = commonProperties.Preview.ContentType,
            },
            Descriptions = commonProperties.Descriptions.Select(q => new Domain.Models.Description
            {
                LanguageId = q.LanguageId,
                IsOriginal = q.IsOriginal,
                Value = q.Value,
            }),
            Genres = commonProperties.Genres.Select(q => new Domain.Models.GenreProportion
            {
                GenreId = q.GenreId,
                Proportion = q.Proportion,
            }),
            RelatedContent = commonProperties.RelatedContent.Select(q => new Domain.Models.MediaInfo
            {
                Type = (Domain.Entities.MediaInfoType)q.Type,
                ObjectId = q.ObjectId,
                ContentType = q.ContentType,
            }),
            AnnouncementDate = commonProperties.AnnouncementDate,
            EstimatedReleaseDate = commonProperties.EstimatedReleaseDate,
            ReleaseDate = commonProperties.ReleaseDate,
        };
    }


    private async Task<Domain.Models.AnimeEpisode> Convert(AnimeEpisode episode)
    {
        return new Domain.Models.AnimeEpisode
        {
            Id = episode.Id,
            Deleted = episode.Deleted,
            Completed = episode.Completed,

            CommonProperties = await Convert(episode.CommonProperties),
            Number = episode.Number,
            Order = episode.Order,
            Variant = episode.Variant,
            ExpirationTime = episode.ExpirationTime,

            Type = (Domain.Entities.MediaContent.Items.Anime.AnimeEpisodeType)episode.Type,
            Duration = episode.Duration,
        };
    }

    internal AnimeTitle Convert(Domain.Entities.MediaContent.Items.Anime.AnimeTitle title)
    {
        var dbTitle = new AnimeTitle
        {
            Id = title.Id,
            CommonProperties = _commonPropertiesConverter.Convert(title.CommonProperties),
            Completed = title.Completed,
            Deleted = title.Deleted,
            ExpirationTime = title.ExpirationTime,
        };
        if (!title.IsTransient()) dbTitle.Id = title.Id;
        foreach (var season in title.Items.OfType<Domain.Entities.MediaContent.Items.Anime.AnimeSeason>())
        {
            dbTitle.Items.Add(_animeSeasonConverter.Convert(season));
        }
        foreach (var episode in title.Items.OfType<Domain.Entities.MediaContent.Items.Anime.AnimeEpisode>())
        {
            dbTitle.Items.Add(_animeEpisodeConverter.Convert(episode));
        }
        return dbTitle;

    }
}