using Domain.Entities;
using Domain.Generics;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Storage;
using Models.Helpers;
using Models.Interfaces;
using Models.Models;

namespace PhronCare.Core.Data.Repositories.Sales
{
    public class PhSQuoteHeaderRepository(PhronCareOperationsHubContext context, IPhSFormSeriesRepository formSeriesRepository) : IPhSQuoteHeaderRepository
    {
        private readonly PhronCareOperationsHubContext _context = context;
        private readonly IPhSFormSeriesRepository _formSeriesRepository = formSeriesRepository;
        public async Task<PagedResult<EQuoteHeader>> GetAllAsync(int page = 1, int pageSize = 50)
        {
            var query = _context.PhSQuoteHeaders
                .Include(q => q.PhSQuoteDetails)
                .Include(q => q.PhSQuoteRoles)
                .Include(q => q.PhSQuoteAdjustments)
                .Include(q => q.PhSQuoteTaxes)
                .AsNoTracking();

            var pagedEntities = await query.ToPagedResultAsync(page, pageSize);

            return new PagedResult<EQuoteHeader>
            {
                Items = pagedEntities.Items.Select(EntityMapper.MapEntity<PhSQuoteHeader, EQuoteHeader>),
                TotalItems = pagedEntities.TotalItems,
                Page = pagedEntities.Page,
                PageSize = pagedEntities.PageSize
            };
        }
        public async Task<EQuoteHeader?> GetByIdAsync(int id)
        {
            var entity = await _context.PhSQuoteHeaders
                .Include(q => q.PhSQuoteDetails)
                .Include(q => q.PhSQuoteRoles)
                .Include(q => q.PhSQuoteAdjustments)
                .Include(q => q.PhSQuoteTaxes)
                .FirstOrDefaultAsync(q => q.Id == id);

            return entity != null ? EntityMapper.MapEntity<PhSQuoteHeader, EQuoteHeader>(entity) : null;
        }
        public async Task<IEnumerable<EQuoteHeader>> GetByCustomerIdAsync(int customerId)
        {
            var entities = await _context.PhSQuoteHeaders
                .Where(q => q.CustomerId == customerId)
                .Include(q => q.PhSQuoteDetails)
                .Include(q => q.PhSQuoteRoles)
                .Include(q => q.PhSQuoteAdjustments)
                .Include(q => q.PhSQuoteTaxes)
                .ToListAsync();

            return entities.Select(EntityMapper.MapEntity<PhSQuoteHeader, EQuoteHeader>);
        }
        public async Task<PagedResult<EQuoteHeader>> SearchAsync(int? customerId,
            string? quoteNumber, int? professionalId, int? institutionId, int? patientId,
            DateTime? issueDateFrom, DateTime? issueDateTo, string? status,
            int page = 1, int pageSize = 50)
        {
            var query = _context.PhSQuoteHeaders
                .Include(q => q.PhSQuoteDetails)
                .Include(q => q.PhSQuoteRoles)
                .Include(q => q.PhSQuoteAdjustments)
                .Include(q => q.PhSQuoteTaxes)
                .AsQueryable();

            if (customerId.HasValue)
                query = query.Where(q => q.CustomerId == customerId);

            if (!string.IsNullOrEmpty(quoteNumber))
                query = query.Where(q => q.Quotenumber.Contains(quoteNumber));

            if (professionalId.HasValue)
                query = query.Where(q => q.PhSQuoteRoles.Any(r => r.Entitytype == PhSEntityTypes.Professional && r.EntityId == professionalId));

            if (institutionId.HasValue)
                query = query.Where(q => q.PhSQuoteRoles.Any(r => r.Entitytype == PhSEntityTypes.Institution && r.EntityId == institutionId));

            if (patientId.HasValue)
                query = query.Where(q => q.PhSQuoteRoles.Any(r => r.Entitytype == PhSEntityTypes.Patient && r.EntityId == patientId));

            if (issueDateFrom.HasValue)
                query = query.Where(q => q.Issuedate >= issueDateFrom.Value);

            if (issueDateTo.HasValue)
                query = query.Where(q => q.Issuedate <= issueDateTo.Value);

            if (!string.IsNullOrEmpty(status))
                query = query.Where(q => q.Status == status);

            var pagedEntities = await query.ToPagedResultAsync(page, pageSize);

            return new PagedResult<EQuoteHeader>
            {
                Items = pagedEntities.Items.Select(EntityMapper.MapEntity<PhSQuoteHeader, EQuoteHeader>),
                TotalItems = pagedEntities.TotalItems,
                Page = pagedEntities.Page,
                PageSize = pagedEntities.PageSize
            };
        }
        public async Task<EQuoteHeader> AddAsync(EQuoteHeader quoteHeader)
        {
            var dbEntity = EntityMapper.MapEntity<EQuoteHeader, PhSQuoteHeader>(quoteHeader);
            _context.PhSQuoteHeaders.Add(dbEntity);
            await _context.SaveChangesAsync();
            return EntityMapper.MapEntity<PhSQuoteHeader, EQuoteHeader>(dbEntity);
        }
        public async Task UpdateAsync(EQuoteHeader quoteHeader)
        {
            var dbEntity = EntityMapper.MapEntity<EQuoteHeader, PhSQuoteHeader>(quoteHeader);
            _context.PhSQuoteHeaders.Update(dbEntity);
            await _context.SaveChangesAsync();
        }
        public async Task DeleteAsync(int id)
        {
            var entity = await _context.PhSQuoteHeaders.FindAsync(id);
            if (entity != null)
            {
                _context.PhSQuoteHeaders.Remove(entity);
                await _context.SaveChangesAsync();
            }
        }

        // ----------------------------
        // Métodos para Ajustes
        // ----------------------------
        public async Task<IEnumerable<EQuoteAdjustment>> GetAdjustmentsByQuoteIdAsync(int quoteId)
        {
            var adjustments = await _context.PhSQuoteAdjustments
                .Where(a => a.QuoteheaderId == quoteId)
                .ToListAsync();

            return adjustments.Select(EntityMapper.MapEntity<PhSQuoteAdjustment, EQuoteAdjustment>);
        }
        public async Task<EQuoteAdjustment> AddAdjustmentAsync(EQuoteAdjustment adjustment)
        {
            var dbEntity = EntityMapper.MapEntity<EQuoteAdjustment, PhSQuoteAdjustment>(adjustment);
            _context.PhSQuoteAdjustments.Add(dbEntity);
            await _context.SaveChangesAsync();
            return EntityMapper.MapEntity<PhSQuoteAdjustment, EQuoteAdjustment>(dbEntity);
        }
        public async Task UpdateAdjustmentAsync(EQuoteAdjustment adjustment)
        {
            var dbEntity = EntityMapper.MapEntity<EQuoteAdjustment, PhSQuoteAdjustment>(adjustment);
            _context.PhSQuoteAdjustments.Update(dbEntity);
            await _context.SaveChangesAsync();
        }
        public async Task DeleteAdjustmentAsync(int adjustmentId)
        {
            var entity = await _context.PhSQuoteAdjustments.FindAsync(adjustmentId);
            if (entity != null)
            {
                _context.PhSQuoteAdjustments.Remove(entity);
                await _context.SaveChangesAsync();
            }
        }

        // ----------------------------
        // Métodos para Impuestos
        // ----------------------------

        /// <summary>
        /// Obtiene todos los impuestos asociados a un presupuesto dado por su ID.
        /// </summary>
        public async Task<IEnumerable<EQuoteTax>> GetTaxesByQuoteIdAsync(int quoteId)
        {
            var taxes = await _context.PhSQuoteTaxes
                .Where(t => t.QuoteheaderId == quoteId)
                .ToListAsync();

            return taxes.Select(EntityMapper.MapEntity<PhSQuoteTaxis, EQuoteTax>);
        }

        /// <summary>
        /// Agrega un nuevo impuesto al presupuesto correspondiente.
        /// </summary>
        public async Task<EQuoteTax> AddTaxAsync(EQuoteTax tax)
        {
            var dbEntity = EntityMapper.MapEntity<EQuoteTax, PhSQuoteTaxis>(tax);
            _context.PhSQuoteTaxes.Add(dbEntity);
            await _context.SaveChangesAsync();
            return EntityMapper.MapEntity<PhSQuoteTaxis, EQuoteTax>(dbEntity);
        }

        /// <summary>
        /// Actualiza los datos de un impuesto existente en un presupuesto.
        /// </summary>
        public async Task UpdateTaxAsync(EQuoteTax tax)
        {
            var dbEntity = EntityMapper.MapEntity<EQuoteTax, PhSQuoteTaxis>(tax);
            _context.PhSQuoteTaxes.Update(dbEntity);
            await _context.SaveChangesAsync();
        }

        /// <summary>
        /// Elimina un impuesto asociado a un presupuesto a partir de su ID.
        /// </summary>
        public async Task DeleteTaxAsync(int taxId)
        {
            var entity = await _context.PhSQuoteTaxes.FindAsync(taxId);
            if (entity != null)
            {
                _context.PhSQuoteTaxes.Remove(entity);
                await _context.SaveChangesAsync();
            }
        }

        #region Guardado completo de presupuesto (encabezado + detalles + roles + ajustes + impuestos)
        /// <summary>
        /// Crea un nuevo presupuesto, incluyendo encabezado, detalles, roles, ajustes e impuestos asociados.
        /// Genera automáticamente el número de presupuesto en base a la serie indicada.
        /// </summary>
        /// <param name="quote">Presupuesto a registrar, incluyendo entidades relacionadas.</param>
        /// <param name="formSeriesId">Identificador de la serie de numeración a utilizar.</param>
        /// <returns>Cadena con el número generado del presupuesto.</returns>
        public async Task<string> CreateFullQuoteAsync(EQuoteHeader quote, int formSeriesId)
        {
            using var transaction = await _context.Database.BeginTransactionAsync();
            try
            {
                // Obtener el próximo número de presupuesto desde SP
                var nextNumber = await _formSeriesRepository.GetNextInternalNumberAsync(formSeriesId);
                quote.Quotenumber = nextNumber.ToString();

                // Map y guardado de Header
                var headerEntity = EntityMapper.MapEntity<EQuoteHeader, PhSQuoteHeader>(quote);
                _context.PhSQuoteHeaders.Add(headerEntity);
                await _context.SaveChangesAsync();

                // Guardado de Detalles
                if (quote.PhSQuoteDetails?.Any() == true)
                {
                    foreach (var detail in quote.PhSQuoteDetails)
                    {
                        detail.QuoteheaderId = headerEntity.Id;
                        var dbDetail = EntityMapper.MapEntity<EQuoteDetail, PhSQuoteDetail>(detail);
                        _context.PhSQuoteDetails.Add(dbDetail);
                    }
                }

                // Guardado de Roles
                if (quote.PhSQuoteRoles?.Any() == true)
                {
                    foreach (var role in quote.PhSQuoteRoles)
                    {
                        role.QuoteheaderId = headerEntity.Id;
                        var dbRole = EntityMapper.MapEntity<EQuoteRole, PhSQuoteRole>(role);
                        _context.PhSQuoteRoles.Add(dbRole);
                    }
                }

                // Guardado de Ajustes
                if (quote.PhSQuoteAdjustments?.Any() == true)
                {
                    foreach (var adj in quote.PhSQuoteAdjustments)
                    {
                        adj.QuoteheaderId = headerEntity.Id;
                        var dbAdj = EntityMapper.MapEntity<EQuoteAdjustment, PhSQuoteAdjustment>(adj);
                        _context.PhSQuoteAdjustments.Add(dbAdj);
                    }
                }

                // Guardado de Impuestos
                if (quote.PhSQuoteTaxes?.Any() == true)
                {
                    foreach (var tax in quote.PhSQuoteTaxes)
                    {
                        tax.QuoteheaderId = headerEntity.Id;
                        var dbTax = EntityMapper.MapEntity<EQuoteTax, PhSQuoteTaxis>(tax);
                        _context.PhSQuoteTaxes.Add(dbTax);
                    }
                }

                await _context.SaveChangesAsync();
                await transaction.CommitAsync();

                return headerEntity.Quotenumber;
            }
            catch
            {
                await transaction.RollbackAsync();
                throw;
            }
        }
        public async Task<IDbContextTransaction> BeginTransactionAsync()
        {
            return await _context.Database.BeginTransactionAsync();
        }
        #endregion
    }
}