Singer-BE/Singer_Hexdive/Repositories/MerchantRepository.cs

using Microsoft.EntityFrameworkCore;
using Singer_Hexdive.Exceptions;
using Singer_Hexdive.Interfaces.RepositoryInterfaces;
using Singer_Hexdive.Models;

namespace Singer_Hexdive.Repositories
{
    public class MerchantRepository : IMerchantRepository
    {
        private readonly ApplicationDbContext _context;

        public MerchantRepository(ApplicationDbContext applicationDbContext)
        {
            _context = applicationDbContext;
        }

        //-------------------------------------------Merchant_Onboarding_Start----------------------------------//
        public async Task<object> GetM_PersonalDetailsAsync(int merchantId)
        {
            var merchantPersonalDetail = await _context.MerchantPersonalDetail
                .Where(m => m.MechantId == merchantId)
                .FirstOrDefaultAsync();
            if (merchantPersonalDetail == null)
            {
                throw new NotfoundException($"Merchant presonal deatils with ID {merchantId} not found.");
            }
            return merchantPersonalDetail;
        }

        public async Task<object> PostM_PersonalDetailsAsync(MerchantPersonalDetail merchantPersonalDetail)
        {
            await _context.MerchantPersonalDetail.AddAsync(merchantPersonalDetail);
            await _context.SaveChangesAsync();
            return merchantPersonalDetail;
        }

        public async Task<object> GetM_BusinessDetailsAsync(int merchantId)
        {
            var merchantBusinessDetail = await _context.MerchantBusinessDetail
                .Where(m => m.FK_MechantId == merchantId)
                .FirstOrDefaultAsync();

            if (merchantBusinessDetail == null)
            {
                throw new NotfoundException($"Merchant business deatils with ID {merchantId} not found.");
            }
            
            var merchantShareHolders = await _context.MerchantShareHolders
                .Where(m => m.FK_MBusinessId == merchantBusinessDetail.Id)
                .ToListAsync();
            var merchantDirectors = await _context.MerchantDirectors
                .Where(m => m.FK_MBusinessId == merchantBusinessDetail.Id)
                .ToListAsync();

            var details = new
            {
                BusinessDetails = merchantBusinessDetail,
                ShareHolders = merchantShareHolders,
                Directors = merchantDirectors
            };
            return details;
        }

        public async Task<object> PostM_BusinessDetailsAsync(MerchantBusinessDetail merchantBusinessDetail)
        {
            await _context.MerchantBusinessDetail.AddAsync(merchantBusinessDetail);
            await _context.SaveChangesAsync();
            return merchantBusinessDetail;
        }

        public async Task<object> PostM_ShareHolderDetailsAsync(MerchantShareHolders merchantShareHolders)
        {
            await _context.MerchantShareHolders.AddAsync(merchantShareHolders);
            await _context.SaveChangesAsync();
            return merchantShareHolders;
        }

        public async Task<object> PostM_DiretorDetailsAsync(MerchantDirectors merchantDirectors)
        {
            await _context.MerchantDirectors.AddAsync(merchantDirectors);
            await _context.SaveChangesAsync();
            return merchantDirectors;
        }

        public async Task<object> GetM_BankDetailsAsync(int merchantId)
        {
            var merchantBankDetail = await _context.MerchantBankDetails
                .Where(m => m.FK_MId == merchantId)
                .FirstOrDefaultAsync();
            if (merchantBankDetail == null)
            {
                throw new NotfoundException($"Merchant Bank deatils with ID {merchantId} not found.");
            }
            return merchantBankDetail;
        }

        public async Task<object> PostM_BankDetailsAsync(MerchantBankDetails merchantBankDetails)
        {
            await _context.MerchantBankDetails.AddAsync(merchantBankDetails);
            await _context.SaveChangesAsync();
            return merchantBankDetails;
        }

        //-------------------------------------------Merchant_Onboarding_End------------------------------------//



        //-------------------------------------------Merchant_Management_Start----------------------------------//
        //-------------------------------------------Merchant_Management_End------------------------------------//



        //-------------------------------------------Merchant_SupportFunctions_Start----------------------------//
        public async Task<int> CheckApprovedStatus(int merchantId, string tableName)
        {
            object? approveSatatus = null;

            switch (tableName)
            {
                case "MerchantPersonalDetail":
                    approveSatatus = await _context.MerchantPersonalDetail
                        .Where(m => m.MechantId == merchantId)
                        .Select(m => new { m.ApprovedStatus })
                        .FirstOrDefaultAsync();
                    break;
                case "MerchantBusinessDetail":
                    approveSatatus = await _context.MerchantBusinessDetail
                        .Where(m => m.FK_MechantId == merchantId)
                        .Select(m => new { m.ApprovedStatus })
                        .FirstOrDefaultAsync();
                    break;
                case "MerchantBankDetail":
                    approveSatatus = await _context.MerchantBankDetails
                        .Where(m => m.FK_MId == merchantId)
                        .Select(m => new { m.ApprovedStatus })
                        .FirstOrDefaultAsync();
                    break;
                default:
                    throw new ArgumentException("Invalid table name provided.");
            }

            return (int)approveSatatus;
        }
        //-------------------------------------------Merchant_SupportFunctions_End------------------------------//
    }
}