using Distribution.Data;
using Microsoft.EntityFrameworkCore;

namespace Distribution.Features.Scheme;

public class SchemeRepository(AppDBContext context) : ISchemeRepository
{
    public async Task<Models.Scheme?> GetByIdAsync(Guid id) =>
        await context.Schemes
            .Include(s => s.Region)
            .Include(s => s.TriggerItem)
            .Include(s => s.FreeItem)
            .Include(s => s.BundleComponents).ThenInclude(c => c.Item)
            .FirstOrDefaultAsync(s => s.Id == id);

    public async Task<List<Models.Scheme>> GetAllAsync(Guid? regionId = null)
    {
        var query = context.Schemes
            .Include(s => s.Region)
            .Include(s => s.TriggerItem)
            .Include(s => s.FreeItem)
            .Include(s => s.BundleComponents).ThenInclude(c => c.Item)
            .AsQueryable();

        if (regionId.HasValue) query = query.Where(s => s.FK_RegionId == regionId);

        return await query.ToListAsync();
    }

    public async Task AddAsync(Models.Scheme entity) =>
        await context.Schemes.AddAsync(entity);

    public void Update(Models.Scheme entity) =>
        context.Schemes.Update(entity);

    public void Remove(Models.Scheme entity)
    {
        entity.IsActive = false;
        context.Schemes.Update(entity);
    }

    public async Task<List<Models.SchemeRedemption>> GetRedemptionsAsync(Guid schemeId) =>
        await context.SchemeRedemptions
            .Include(r => r.FreeItem)
            .Include(r => r.ShopPO)
            .Where(r => r.FK_SchemeId == schemeId)
            .ToListAsync();

    public async Task AddRedemptionAsync(Models.SchemeRedemption entity) =>
        await context.SchemeRedemptions.AddAsync(entity);

    public async Task<List<Models.SchemeRedemption>> GetRedemptionsByShopPOAsync(Guid shopPOId)
    {
        var list = await context.SchemeRedemptions.Include(r => r.Scheme).Where(r => r.FK_ShopPOId == shopPOId).ToListAsync();
        // Rows added earlier in this unit of work are not in the database yet; rows removed are still there.
        foreach (var added in context.SchemeRedemptions.Local.Where(r => r.FK_ShopPOId == shopPOId && !list.Contains(r)))
            list.Add(added);
        return list.Where(r => context.Entry(r).State != EntityState.Deleted).ToList();
    }

    public void RemoveRedemption(Models.SchemeRedemption entity) =>
        context.SchemeRedemptions.Remove(entity);

    public async Task<bool> HasRedemptionAsync(Guid schemeId, Guid shopPOId) =>
        await context.SchemeRedemptions.AnyAsync(r => r.FK_SchemeId == schemeId && r.FK_ShopPOId == shopPOId);

    // An invoice past Draft (printed or finalized) has a fixed amount, so it can no longer take a discount.
    public async Task<bool> HasLockedInvoiceAsync(Guid shopPOId) =>
        await context.Invoices.AnyAsync(i => i.FK_ShopPOId == shopPOId && i.IsActive && i.Status != Models.InvoiceStatus.Draft);

    public async Task<Models.SchemeBundleComponent?> GetBundleComponentAsync(Guid schemeId, Guid itemId) =>
        await context.SchemeBundleComponents
            .FirstOrDefaultAsync(c => c.FK_SchemeId == schemeId && c.FK_ItemId == itemId);

    public async Task AddBundleComponentAsync(Models.SchemeBundleComponent entity) =>
        await context.SchemeBundleComponents.AddAsync(entity);

    public void UpdateBundleComponent(Models.SchemeBundleComponent entity) =>
        context.SchemeBundleComponents.Update(entity);

    public void RemoveBundleComponent(Models.SchemeBundleComponent entity) =>
        context.SchemeBundleComponents.Remove(entity);
}