using System.Reflection;
using DBConnection.Models;
using DBConnection.Repositories.Interfaces;
using Microsoft.EntityFrameworkCore;
using NuGet.Configuration;

namespace DBConnection.Repositories;

public abstract class BaseRepository<TEntityType> : IRepository<TEntityType> where TEntityType : BaseEntity
{
    protected readonly AppDbContext DbContext;

    private object?[]? GetPrimaryKey(TEntityType entity)
    {
        var keyProperties = DbContext.Model.FindEntityType(typeof(TEntityType))?.FindPrimaryKey()?.Properties.Select(p => p.Name);
        var ret = keyProperties?.Select(p => entity.GetType().GetProperty(p)?.GetValue(entity, null)).ToArray();
        return ret;
    }

    protected abstract IQueryable<TEntityType> GetAllIncludedQueryable();
    
    public BaseRepository(AppDbContext dbContext)
    {
        DbContext = dbContext;
    }

    public virtual TEntityType Delete(TEntityType entity)
    {
        DbContext.Set<TEntityType>().Remove(entity);
        return entity;
    }

    public virtual async Task<TEntityType> Upsert(TEntityType entity)
    {
        bool exists = await DbContext.Set<TEntityType>().ContainsAsync(entity);
        if (!exists)
        {
            DbContext.Set<TEntityType>().Add(entity);
        }
        else
        {
            var dbEntry = await GetIncluded(entity);
            DbContext.Entry(dbEntry).CurrentValues.SetValues(entity);
        }

        await DbContext.SaveChangesAsync();
        return entity;
    }

    public virtual async Task<IEnumerable<TEntityType>> GetAllIncluded()
    {
        return await GetWhereIncluded(i => true);
    }

    public virtual async Task<TEntityType?> GetIncluded(TEntityType entity)
    {
        return await GetIncluded(dbEntity => GetPrimaryKey(dbEntity).SequenceEqual(GetPrimaryKey(entity)));
    }

    public virtual async Task<TEntityType?> GetIncluded(Func<TEntityType, bool> predicate)
    {
        return GetAllIncludedQueryable().FirstOrDefault(predicate);
    }

    public virtual async Task<IEnumerable<TEntityType>> GetWhereIncluded(Func<TEntityType, bool> predicate)
    {
        return GetAllIncludedQueryable().AsEnumerable().Where(predicate);
    }
}