using Microsoft.EntityFrameworkCore;

namespace ApplianceRepair
{
    public class HomePageReader(DatabaseContext db)
    {
        public async Task<HomePageRecord?> ReadLatestRecord()
        {
            var records = await db.HomePage.OrderByDescending(page => page.Id).FirstOrDefaultAsync();
            return records;
        }

        public async Task AddRecord(HomePageRecord record)
        {
            record.CreatedAt = DateTime.Now;
            record.UpdatedAt = DateTime.Now;
            await db.AddAsync(record);
            await db.SaveChangesAsync();
        }

        public async Task UpdateRecord(HomePageRecord record)
        {
            var found = db.HomePage.Where((page) => page.Id == record.Id).FirstOrDefault();
            if (found == null)
            {
                await AddRecord(record);
            }
            else
            {
                db.Entry(found).CurrentValues.SetValues(record);
            }
            await db.SaveChangesAsync();
        }
    }

    public class ContentCardReader(DatabaseContext db)
    {
        public async Task<List<ContentCardRecord>?> ReadAllByPageAndGroup(string belongsToPage, string group)
        {
            return await db.ContentCards.Where(card => card.BelongsToPage == belongsToPage && card.Group == group).ToListAsync();
        }

        public async Task<List<ContentCardRecord>?> ReadAllByPage(string belongsToPage)
        {
            return await db.ContentCards.Where(card => card.BelongsToPage == belongsToPage).ToListAsync();
        }

        public async Task AddRecord(ContentCardRecord record)
        {
            await db.ContentCards.AddAsync(record);
            await db.SaveChangesAsync();
        }

        public async Task UpdateRecord(ContentCardRecord record)
        {
            var found = db.ContentCards.Where((card) => card.Id == record.Id).FirstOrDefault();
            if (found == null)
            {
                await AddRecord(record);
            }
            else
            {
                db.Entry(found).CurrentValues.SetValues(record);
            }
            await db.SaveChangesAsync();
        }

        public async Task DeleteRecord(ContentCardRecord record)
        {
            var found = db.ContentCards.Where((card) => card.Id == record.Id).FirstOrDefault();
            if (found != null)
            {
                db.ContentCards.Remove(found);
                await db.SaveChangesAsync();
            }
        }
    }

    public class BusinessConfigReader(DatabaseContext db)
    {
        public async Task<BusinessConfigRecord?> ReadLatestRecord()
        {
            return await db.BusinessConfig.OrderByDescending(page => page.Id).FirstOrDefaultAsync();
        }

        public async Task AddRecord(BusinessConfigRecord record)
        {
            await db.BusinessConfig.AddAsync(record);
            await db.SaveChangesAsync();
        }

        public async Task UpdateRecord(BusinessConfigRecord record)
        {
            var found = db.BusinessConfig.Where((config) => config.Id == record.Id).FirstOrDefault();
            if (found == null)
            {
                await AddRecord(record);
            }
            else
            {
                db.Entry(found).CurrentValues.SetValues(record);
            }
            await db.SaveChangesAsync();
        }
    }

    public class RepairRequestReader(DatabaseContext db)
    {
        public async Task<RepairRequestRecord?> ReadByRequestNumber(string requestNumber)
        {
            return await db.RepairRequests.Where((record) => record.RequestNumber == requestNumber).FirstOrDefaultAsync();
        }

        public async Task<List<RepairRequestRecord>> ReadAll()
        {
            return await db.RepairRequests.ToListAsync();
        }

        public async Task AddRecord(RepairRequestRecord record)
        {
            await db.RepairRequests.AddAsync(record);
            await db.SaveChangesAsync();
        }

        public async Task UpdateRecord(RepairRequestRecord record)
        {
            var found = db.RepairRequests.Where((config) => config.Id == record.Id).FirstOrDefault();
            if (found == null)
            {
                await AddRecord(record);
            }
            else
            {
                db.Entry(found).CurrentValues.SetValues(record);
            }
            await db.SaveChangesAsync();
        }
    }

    public class RepairRequestMediaReader(DatabaseContext db)
    {
        public async Task<List<RepairRequestMediaRecord>> ReadAllByRequestNumber(string requestNumber)
        {
            return await db.RepairRequestMedia.Where((record) => record.RequestNumber == requestNumber).ToListAsync();
        }

        public async Task AddRecord(RepairRequestMediaRecord record)
        {
            await db.RepairRequestMedia.AddAsync(record);
            await db.SaveChangesAsync();
        }
    }
}