MyBookmark/Modules.Library.Database/GatewaysImplementations/AnimeSeasonGateway.cs

using Modules.Library.Application.Gateways;
using Modules.Library.Application.Models.Anime;
using Modules.Library.Database.GatewaysImplementations.Converters;
using Modules.Library.Database.Repositories;
using Modules.Library.Domain.Entities.MediaContent.Items.Anime;

namespace Modules.Library.Database.GatewaysImplementations;

public class AnimeSeasonGateway(AnimeTitleRepository context, LanguageRepository languageRepository, GenreRepository genreRepository) : IAnimeTitleGateway
{
    private readonly AnimeTitleConverter _converter = new(languageRepository, genreRepository);

    public async Task<List<Title>> GetList()
    {
        var list = await context.GetAllAsync();
        var result = new List<Title>();
        foreach (var title in list)
        {
            result.Add(await _converter.Convert(title));
        }

        return result;
    }

    public async Task<Title> GetDetail(Guid id)
    {
        var dbTitle = await context.GetByIdAsync(id);
        return await _converter.Convert(dbTitle);
    }

    public Task<Guid> Create(AnimeTitle title)
    {
        /*
        var dbTitle = new Database.Models.Anime.AnimeTitle
        {
            CommonProperties = new CommonProperties
            {
                Names = title.CommonProperties.Names.Select(q => new NameItem
                {
                    Value = q.Value,
                    Type = (NameType)q.Type,
                    LanguageId = q.Language.CodeIso2,
                }).ToList(),
                Preview = title.CommonProperties.Preview == null ? null : new MediaInfo
                {
                    //Id = 
                    Type = (MediaInfoType)title.CommonProperties.Preview.Type,
                    Url = title.CommonProperties.Preview.Url,
                },
                Descriptions = title.CommonProperties.Descriptions.Select(q => new DescriptionItem
                {
                    IsOriginal = q.IsOriginal,
                    Value = q.Value,
                }).ToList(),
                Genres = title.CommonProperties.Genres.Select(q => new GenreProportionItem
                {
                    GenreId = q.Genre.Id,
                    Proportion = q.Proportion,
                }).ToList(),
                RelatedContent = title.CommonProperties.RelatedContent.Select(q => new MediaInfo
                {
                    Type = (MediaInfoType)q.Type,
                    Url = q.Url,
                }).ToList(),
                AnnouncementDate = title.CommonProperties.AnnouncementDate,
                EstimatedReleaseDate = title.CommonProperties.EstimatedReleaseDate,
                ReleaseDate = title.CommonProperties.ReleaseDate,
            },
            Completed = title.Completed,
            Deleted = title.Deleted,
            ExpirationTime = title.ExpirationTime,
        };
        return context.AddAsync(dbTitle);
        */
        return context.AddAsync(_converter.Convert(title));
    }

    public async Task<AnimeTitle> GetById(Guid id)
    {
        var dbTitle = await context.GetByIdAsync(id);
        /*
        var commonPropertiesBuilder = new CommonPropertiesBuilder()
            .SetAnouncementDate(dbTitle.CommonProperties.AnnouncementDate)
            .SetEstimatedReleaseDate(dbTitle.CommonProperties.EstimatedReleaseDate)
            .SetReleaseDate(dbTitle.CommonProperties.ReleaseDate);
        foreach (var q in dbTitle.CommonProperties.Names)
        {
            var dbLanguage = await languageRepository.GetLanguage(q.LanguageId);
            var languageBuilder = new LanguageBuilder(dbLanguage.CodeIso2, dbLanguage.Name);
            if (dbLanguage.IconId.HasValue) languageBuilder.WithIcon(dbLanguage.IconId.Value);
            commonPropertiesBuilder.AddName(languageBuilder.Build(), (Domain.Entities.MediaContent.CommonProperties.NameType)q.Type, q.Value);
        }
        /*
        foreach (var q in dbTitle.CommonProperties.Genres)
        {
            var dbLanguage = await languageRepository.GetLanguage(q.LanguageId);
            var languageBuilder = new LanguageBuilder(dbLanguage.CodeIso2, dbLanguage.Name);
            if (dbLanguage.IconId.HasValue) languageBuilder.WithIcon(dbLanguage.IconId.Value);
            commonPropertiesBuilder.AddName(languageBuilder.Build(), (Domain.Entities.MediaContent.CommonProperties.NameType)q.Type, q.Value);
        }
        */
        /*
        foreach (var q in dbTitle.CommonProperties.Descriptions)
        {
            var dbLanguage = await languageRepository.GetLanguage(q.LanguageId);
            var languageBuilder = new LanguageBuilder(dbLanguage.CodeIso2, dbLanguage.Name);
            if (dbLanguage.IconId.HasValue) languageBuilder.WithIcon(dbLanguage.IconId.Value);
            commonPropertiesBuilder.AddName(languageBuilder.Build(), (Domain.Entities.MediaContent.CommonProperties.NameType)q.Type, q.Value);
        }
        */
        /*
        foreach (var q in dbTitle.CommonProperties.RelatedContent)
        {
            var dbLanguage = await languageRepository.GetLanguage(q.LanguageId);
            var languageBuilder = new LanguageBuilder(dbLanguage.CodeIso2, dbLanguage.Name);
            if (dbLanguage.IconId.HasValue) languageBuilder.WithIcon(dbLanguage.IconId.Value);
            commonPropertiesBuilder.AddName(languageBuilder.Build(), (Domain.Entities.MediaContent.CommonProperties.NameType)q.Type, q.Value);
        }
        */
        /*
        if (dbTitle.CommonProperties.Preview != null)
            commonPropertiesBuilder.SetPreview(dbTitle.CommonProperties.Preview.Url, (Domain.Entities.MediaInfoType)dbTitle.CommonProperties.Preview.Type);
        var builder = new AnimeTitleBuilder()
            .SetCommonProperties(commonPropertiesBuilder)
            .SetExpirationTime(dbTitle.ExpirationTime)
            .SetCompleted(dbTitle.Completed)
            .SetDeleted(dbTitle.Deleted);
        return builder.SetId(dbTitle.Id).Build();
        */
        return await _converter.ConvertToDomain(dbTitle);
    }

    public Task Update(AnimeTitle title) => context.UpdateAsync(_converter.Convert(title));


    /*
    public async Task AddAsync(Domain.Entities.MediaContent.Items.Anime.AnimeTitle entity, IUser user) =>
        await AddAsync(ToDbConverter.Title(entity));

    public Task<bool> AnyWhere(Expression<Func<Domain.Entities.MediaContent.Items.Anime.AnimeTitle, bool>> predicate)
    {
        var p = predicate.
    }

    public Task<bool> DeleteAsync(Domain.Entities.MediaContent.Items.Anime.AnimeTitle entity, IUser user)
    {
        throw new NotImplementedException();
    }

    public Task<Domain.Entities.MediaContent.Items.Anime.AnimeTitle> GetByIdAsync(string id)
    {
        throw new NotImplementedException();
    }

    public Task<Domain.Entities.MediaContent.Items.Anime.AnimeTitle?> GetByIdOrDefaultAsync(string id)
    {
        throw new NotImplementedException();
    }

    public Task<Domain.Entities.MediaContent.Items.Anime.AnimeTitle?> GetFirstOrDefaultWhere(Expression<Func<Domain.Entities.MediaContent.Items.Anime.AnimeTitle, bool>> predicate)
    {
        throw new NotImplementedException();
    }

    public Task<Domain.Entities.MediaContent.Items.Anime.AnimeTitle> GetFirstWhere(Expression<Func<Domain.Entities.MediaContent.Items.Anime.AnimeTitle, bool>> predicate)
    {
        throw new NotImplementedException();
    }

    public Task<List<Domain.Entities.MediaContent.Items.Anime.AnimeTitle>> GetRangeByIdsAsync(List<string> ids)
    {
        throw new NotImplementedException();
    }

    public Task<List<Domain.Entities.MediaContent.Items.Anime.AnimeTitle>> GetWhere(Expression<Func<Domain.Entities.MediaContent.Items.Anime.AnimeTitle, bool>> predicate)
    {
        throw new NotImplementedException();
    }

    public Task<bool> UpdateAsync(Domain.Entities.MediaContent.Items.Anime.AnimeTitle entity, IUser user)
    {
        throw new NotImplementedException();
    }

    Task<List<Domain.Entities.MediaContent.Items.Anime.AnimeTitle>> Application.Gateways.IRepository<Domain.Entities.MediaContent.Items.Anime.AnimeTitle, string>.GetAllAsync()
    {
        throw new NotImplementedException();
    }
    */
}