using AutoMapper;
using PowderCoating.Shared.Constants;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
using PowderCoating.Application.DTOs.Common;
using PowderCoating.Application.DTOs.Customer;
using PowderCoating.Application.Interfaces;
using PowderCoating.Core.Entities;
using PowderCoating.Core.Enums;
using PowderCoating.Core.Interfaces;
using PowderCoating.Infrastructure.Data;
using PowderCoating.Web.Helpers;
using Microsoft.AspNetCore.Mvc.Rendering;
using Microsoft.EntityFrameworkCore;

namespace PowderCoating.Web.Controllers;

[Authorize(Policy = AppConstants.Policies.CanManageCustomers)]
public class CustomersController : Controller
{
    private readonly IUnitOfWork _unitOfWork;
    private readonly IMapper _mapper;
    private readonly ILogger<CustomersController> _logger;
    private readonly INotificationService _notificationService;
    private readonly ISubscriptionService _subscriptionService;
    private readonly ITenantContext _tenantContext;
    private readonly UserManager<ApplicationUser> _userManager;
    private readonly IFinancialReportService _financialReports;

    public CustomersController(
        IUnitOfWork unitOfWork,
        IMapper mapper,
        ILogger<CustomersController> logger,
        INotificationService notificationService,
        ISubscriptionService subscriptionService,
        ITenantContext tenantContext,
        UserManager<ApplicationUser> userManager,
        IFinancialReportService financialReports)
    {
        _unitOfWork = unitOfWork;
        _mapper = mapper;
        _logger = logger;
        _notificationService = notificationService;
        _subscriptionService = subscriptionService;
        _tenantContext = tenantContext;
        _userManager = userManager;
        _financialReports = financialReports;
    }

    /// <summary>
    /// Displays the paginated, searchable customer list. Sanitizes the search term before
    /// building the EF filter expression to guard against injection; sorting is resolved
    /// server-side via a switch so the column name never reaches raw SQL.
    /// </summary>
    public async Task<IActionResult> Index(
        string? searchTerm,
        string? sortColumn,
        string sortDirection = "asc",
        int pageNumber = 1,
        int pageSize = 25)
    {
        try
        {
            // SECURITY: Sanitize search input to prevent injection attacks
            searchTerm = SecurityHelper.SanitizeSearchTerm(searchTerm);

            // Create and validate grid request
            var gridRequest = new GridRequest
            {
                PageNumber = pageNumber,
                PageSize = pageSize,
                SortColumn = sortColumn ?? "CompanyName",
                SortDirection = sortDirection,
                SearchTerm = searchTerm
            };
            gridRequest.Validate();

            // Build search filter
            System.Linq.Expressions.Expression<Func<Customer, bool>>? filter = null;
            if (!string.IsNullOrWhiteSpace(searchTerm))
            {
                var search = searchTerm.ToLower();
                filter = c => c.CompanyName.ToLower().Contains(search)
                    || (c.ContactFirstName != null && c.ContactFirstName.ToLower().Contains(search))
                    || (c.ContactLastName != null && c.ContactLastName.ToLower().Contains(search))
                    || (c.Email != null && c.Email.ToLower().Contains(search))
                    || (c.Phone != null && c.Phone.ToLower().Contains(search));
            }

            // Build orderBy function
            Func<IQueryable<Customer>, IOrderedQueryable<Customer>> orderBy = gridRequest.SortColumn switch
            {
                "CompanyName" => q => gridRequest.SortDirection == "asc" ? q.OrderBy(c => c.CompanyName) : q.OrderByDescending(c => c.CompanyName),
                "ContactName" => q => gridRequest.SortDirection == "asc"
                    ? q.OrderBy(c => c.ContactFirstName).ThenBy(c => c.ContactLastName)
                    : q.OrderByDescending(c => c.ContactFirstName).ThenByDescending(c => c.ContactLastName),
                "Email" => q => gridRequest.SortDirection == "asc" ? q.OrderBy(c => c.Email) : q.OrderByDescending(c => c.Email),
                "Phone" => q => gridRequest.SortDirection == "asc" ? q.OrderBy(c => c.Phone) : q.OrderByDescending(c => c.Phone),
                "CurrentBalance" => q => gridRequest.SortDirection == "asc" ? q.OrderBy(c => c.CurrentBalance) : q.OrderByDescending(c => c.CurrentBalance),
                "IsActive" => q => gridRequest.SortDirection == "asc" ? q.OrderBy(c => c.IsActive) : q.OrderByDescending(c => c.IsActive),
                "LastContactDate" => q => gridRequest.SortDirection == "asc" ? q.OrderBy(c => c.LastContactDate) : q.OrderByDescending(c => c.LastContactDate),
                _ => q => q.OrderBy(c => c.CompanyName)
            };

            // Get paged data
            var (items, totalCount) = await _unitOfWork.Customers.GetPagedAsync(
                gridRequest.PageNumber,
                gridRequest.PageSize,
                filter,
                orderBy);

            // Map to DTOs
            var customerDtos = items.Select(c => new CustomerListDto
            {
                Id = c.Id,
                CompanyName = c.CompanyName,
                ContactName = !string.IsNullOrEmpty(c.ContactFirstName) || !string.IsNullOrEmpty(c.ContactLastName)
                    ? $"{c.ContactFirstName} {c.ContactLastName}".Trim()
                    : string.Empty,
                Phone = c.Phone,
                Email = c.Email,
                IsCommercial = c.IsCommercial,
                CurrentBalance = c.CurrentBalance,
                IsActive = c.IsActive,
                LastContactDate = c.LastContactDate
            }).ToList();

            var pagedResult = PagedResult<CustomerListDto>.From(gridRequest, customerDtos, totalCount);

            // Set ViewBag for sorting
            ViewBag.SearchTerm = searchTerm;
            ViewBag.SortColumn = gridRequest.SortColumn;
            ViewBag.SortDirection = gridRequest.SortDirection;

            return View(pagedResult);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error retrieving customers");
            this.ToastError("An error occurred while loading customers.");
            return View(new PagedResult<CustomerListDto>());
        }
    }

    /// <summary>
    /// Renders the customer detail page, including the 10 most-recent non-voided credit memos.
    /// Credit memos are loaded separately (not via eager loading) because the customer entity
    /// does not navigate to CreditMemo; this keeps the Customer aggregate lean.
    /// </summary>
    public async Task<IActionResult> Details(int? id)
    {
        if (id == null)
        {
            return NotFound();
        }

        try
        {
            var customer = await _unitOfWork.Customers.GetByIdAsync(id.Value);
            if (customer == null)
            {
                return NotFound();
            }

            var creditMemos = await _unitOfWork.CreditMemos.FindAsync(
                cm => cm.CustomerId == id.Value && cm.Status != CreditMemoStatus.Voided);
            ViewBag.CreditMemos = creditMemos
                .OrderByDescending(cm => cm.IssueDate)
                .Take(10)
                .ToList();

            var customerDto = _mapper.Map<CustomerDto>(customer);
            return View(customerDto);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error retrieving customer {CustomerId}", id);
            this.ToastError("An error occurred while loading the customer.");
            return RedirectToAction(nameof(Index));
        }
    }

    /// <summary>
    /// Shows the full paginated job history for a single customer. Defaults to descending
    /// by creation date so the newest jobs appear first. JobStatus and JobPriority are
    /// eagerly loaded so their display names and sort orders are available without N+1 queries.
    /// </summary>
    public async Task<IActionResult> JobHistory(
        int? id,
        string? searchTerm,
        string? sortColumn,
        string sortDirection = "desc",
        int pageNumber = 1,
        int pageSize = 25)
    {
        if (id == null)
        {
            return NotFound();
        }

        try
        {
            var customer = await _unitOfWork.Customers.GetByIdAsync(id.Value);
            if (customer == null)
            {
                return NotFound();
            }

            var gridRequest = new GridRequest
            {
                PageNumber = pageNumber,
                PageSize = pageSize,
                SortColumn = sortColumn ?? "CreatedAt",
                SortDirection = sortDirection,
                SearchTerm = searchTerm
            };
            gridRequest.Validate();

            System.Linq.Expressions.Expression<Func<Core.Entities.Job, bool>> filter;
            if (!string.IsNullOrWhiteSpace(searchTerm))
            {
                var search = searchTerm.ToLower();
                filter = j => j.CustomerId == id.Value
                    && (j.JobNumber.ToLower().Contains(search)
                        || j.Description.ToLower().Contains(search)
                        || (j.CustomerPO != null && j.CustomerPO.ToLower().Contains(search))
                        || j.JobStatus.DisplayName.ToLower().Contains(search)
                        || j.JobPriority.DisplayName.ToLower().Contains(search));
            }
            else
            {
                filter = j => j.CustomerId == id.Value;
            }

            Func<IQueryable<Core.Entities.Job>, IOrderedQueryable<Core.Entities.Job>> orderBy = gridRequest.SortColumn switch
            {
                "JobNumber" => q => gridRequest.SortDirection == "asc" ? q.OrderBy(j => j.JobNumber) : q.OrderByDescending(j => j.JobNumber),
                "Status" => q => gridRequest.SortDirection == "asc" ? q.OrderBy(j => j.JobStatus.DisplayOrder) : q.OrderByDescending(j => j.JobStatus.DisplayOrder),
                "Priority" => q => gridRequest.SortDirection == "asc" ? q.OrderBy(j => j.JobPriority.DisplayOrder) : q.OrderByDescending(j => j.JobPriority.DisplayOrder),
                "ScheduledDate" => q => gridRequest.SortDirection == "asc" ? q.OrderBy(j => j.ScheduledDate) : q.OrderByDescending(j => j.ScheduledDate),
                "DueDate" => q => gridRequest.SortDirection == "asc" ? q.OrderBy(j => j.DueDate) : q.OrderByDescending(j => j.DueDate),
                "FinalPrice" => q => gridRequest.SortDirection == "asc" ? q.OrderBy(j => j.FinalPrice) : q.OrderByDescending(j => j.FinalPrice),
                _ => q => q.OrderByDescending(j => j.CreatedAt)
            };

            var (items, totalCount) = await _unitOfWork.Jobs.GetPagedAsync(
                gridRequest.PageNumber,
                gridRequest.PageSize,
                filter,
                orderBy,
                j => j.JobStatus,
                j => j.JobPriority);

            // Use AutoMapper to map jobs to DTOs
            var jobDtos = _mapper.Map<List<Application.DTOs.Job.JobListDto>>(items);

            var pagedResult = new Application.DTOs.Common.PagedResult<Application.DTOs.Job.JobListDto>
            {
                Items = jobDtos,
                PageNumber = gridRequest.PageNumber,
                PageSize = gridRequest.PageSize,
                TotalCount = totalCount
            };

            ViewBag.CustomerId = id.Value;
            ViewBag.CustomerName = !string.IsNullOrWhiteSpace(customer.CompanyName)
                ? customer.CompanyName
                : $"{customer.ContactFirstName} {customer.ContactLastName}".Trim();
            ViewBag.SearchTerm = searchTerm;
            ViewBag.SortColumn = gridRequest.SortColumn;
            ViewBag.SortDirection = gridRequest.SortDirection;

            return View(pagedResult);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error retrieving job history for customer {CustomerId}", id);
            this.ToastError("An error occurred while loading the job history.");
            return RedirectToAction(nameof(Details), new { id });
        }
    }

    /// <summary>
    /// Renders the customer activity tab-panel, showing jobs and quotes in independent
    /// paginated grids. Each grid carries its own sort/page state in the query string so
    /// both can be navigated without resetting the other. Page sizes are clamped to
    /// [10, 100] server-side to prevent accidental full-table loads.
    /// </summary>
    public async Task<IActionResult> Activity(
        int? id,
        string activeTab = "jobs",
        string jobSort = "CreatedAt",
        string jobDir = "desc",
        int jobPage = 1,
        int jobSize = 25,
        string quoteSort = "QuoteDate",
        string quoteDir = "desc",
        int quotePage = 1,
        int quoteSize = 25)
    {
        if (id == null)
        {
            return NotFound();
        }

        try
        {
            var customer = await _unitOfWork.Customers.GetByIdAsync(id.Value);
            if (customer == null)
            {
                return NotFound();
            }

            var customerName = !string.IsNullOrWhiteSpace(customer.CompanyName)
                ? customer.CompanyName
                : $"{customer.ContactFirstName} {customer.ContactLastName}".Trim();

            // Clamp page sizes
            jobSize = Math.Clamp(jobSize, 10, 100);
            quoteSize = Math.Clamp(quoteSize, 10, 100);
            if (jobPage < 1) jobPage = 1;
            if (quotePage < 1) quotePage = 1;

            // --- Jobs ---
            Func<IQueryable<Core.Entities.Job>, IOrderedQueryable<Core.Entities.Job>> jobOrderBy = jobSort switch
            {
                "JobNumber" => q => jobDir == "asc" ? q.OrderBy(j => j.JobNumber) : q.OrderByDescending(j => j.JobNumber),
                "Status"    => q => jobDir == "asc" ? q.OrderBy(j => j.JobStatus.DisplayOrder) : q.OrderByDescending(j => j.JobStatus.DisplayOrder),
                "Priority"  => q => jobDir == "asc" ? q.OrderBy(j => j.JobPriority.DisplayOrder) : q.OrderByDescending(j => j.JobPriority.DisplayOrder),
                "DueDate"   => q => jobDir == "asc" ? q.OrderBy(j => j.DueDate) : q.OrderByDescending(j => j.DueDate),
                "FinalPrice"=> q => jobDir == "asc" ? q.OrderBy(j => j.FinalPrice) : q.OrderByDescending(j => j.FinalPrice),
                _           => q => jobDir == "asc" ? q.OrderBy(j => j.CreatedAt) : q.OrderByDescending(j => j.CreatedAt)
            };

            var (jobItems, jobTotal) = await _unitOfWork.Jobs.GetPagedAsync(
                jobPage, jobSize,
                j => j.CustomerId == id.Value,
                jobOrderBy,
                j => j.JobStatus,
                j => j.JobPriority);

            var jobDtos = _mapper.Map<List<Application.DTOs.Job.JobListDto>>(jobItems);
            var pagedJobs = new Application.DTOs.Common.PagedResult<Application.DTOs.Job.JobListDto>
            {
                Items = jobDtos,
                PageNumber = jobPage,
                PageSize = jobSize,
                TotalCount = jobTotal
            };

            // --- Quotes ---
            Func<IQueryable<Core.Entities.Quote>, IOrderedQueryable<Core.Entities.Quote>> quoteOrderBy = quoteSort switch
            {
                "QuoteNumber" => q => quoteDir == "asc" ? q.OrderBy(x => x.QuoteNumber) : q.OrderByDescending(x => x.QuoteNumber),
                "Status"      => q => quoteDir == "asc" ? q.OrderBy(x => x.QuoteStatus.DisplayOrder) : q.OrderByDescending(x => x.QuoteStatus.DisplayOrder),
                "Total"       => q => quoteDir == "asc" ? q.OrderBy(x => x.Total) : q.OrderByDescending(x => x.Total),
                "Expiration"  => q => quoteDir == "asc" ? q.OrderBy(x => x.ExpirationDate) : q.OrderByDescending(x => x.ExpirationDate),
                _             => q => quoteDir == "asc" ? q.OrderBy(x => x.QuoteDate) : q.OrderByDescending(x => x.QuoteDate)
            };

            var (quoteItems, quoteTotal) = await _unitOfWork.Quotes.GetPagedAsync(
                quotePage, quoteSize,
                q => q.CustomerId == id.Value,
                quoteOrderBy,
                q => q.QuoteStatus);

            var quoteDtos = _mapper.Map<List<Application.DTOs.Quote.QuoteListDto>>(quoteItems);
            var pagedQuotes = new Application.DTOs.Common.PagedResult<Application.DTOs.Quote.QuoteListDto>
            {
                Items = quoteDtos,
                PageNumber = quotePage,
                PageSize = quoteSize,
                TotalCount = quoteTotal
            };

            ViewBag.CustomerId = id.Value;
            ViewBag.CustomerName = customerName;
            ViewBag.ActiveTab = activeTab;
            ViewBag.Jobs = pagedJobs;
            ViewBag.JobSort = jobSort;
            ViewBag.JobDir = jobDir;
            ViewBag.Quotes = pagedQuotes;
            ViewBag.QuoteSort = quoteSort;
            ViewBag.QuoteDir = quoteDir;

            return View();
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error retrieving activity for customer {CustomerId}", id);
            this.ToastError("An error occurred while loading customer activity.");
            return RedirectToAction(nameof(Details), new { id });
        }
    }

    /// <summary>
    /// Displays the paginated invoice list scoped to a single customer. Defaults to
    /// descending invoice date so the most recent invoice is shown first, matching the
    /// typical accounts-receivable workflow of reviewing the latest outstanding balance.
    /// </summary>
    public async Task<IActionResult> Invoices(
        int? id,
        string? sortColumn,
        string sortDirection = "desc",
        int pageNumber = 1,
        int pageSize = 25)
    {
        if (id == null)
        {
            return NotFound();
        }

        try
        {
            var customer = await _unitOfWork.Customers.GetByIdAsync(id.Value);
            if (customer == null)
            {
                return NotFound();
            }

            var gridRequest = new GridRequest
            {
                PageNumber = pageNumber,
                PageSize = pageSize,
                SortColumn = sortColumn ?? "InvoiceDate",
                SortDirection = sortDirection
            };
            gridRequest.Validate();

            Func<IQueryable<Core.Entities.Invoice>, IOrderedQueryable<Core.Entities.Invoice>> orderBy = gridRequest.SortColumn switch
            {
                "InvoiceNumber" => q => gridRequest.SortDirection == "asc" ? q.OrderBy(i => i.InvoiceNumber) : q.OrderByDescending(i => i.InvoiceNumber),
                "Status"        => q => gridRequest.SortDirection == "asc" ? q.OrderBy(i => i.Status) : q.OrderByDescending(i => i.Status),
                "DueDate"       => q => gridRequest.SortDirection == "asc" ? q.OrderBy(i => i.DueDate) : q.OrderByDescending(i => i.DueDate),
                "Total"         => q => gridRequest.SortDirection == "asc" ? q.OrderBy(i => i.Total) : q.OrderByDescending(i => i.Total),
                "BalanceDue"    => q => gridRequest.SortDirection == "asc" ? q.OrderBy(i => i.BalanceDue) : q.OrderByDescending(i => i.BalanceDue),
                _               => q => gridRequest.SortDirection == "asc" ? q.OrderBy(i => i.InvoiceDate) : q.OrderByDescending(i => i.InvoiceDate)
            };

            var (items, totalCount) = await _unitOfWork.Invoices.GetPagedAsync(
                gridRequest.PageNumber,
                gridRequest.PageSize,
                i => i.CustomerId == id.Value,
                orderBy);

            var invoiceDtos = _mapper.Map<List<Application.DTOs.Invoice.InvoiceListDto>>(items);

            var pagedResult = new Application.DTOs.Common.PagedResult<Application.DTOs.Invoice.InvoiceListDto>
            {
                Items = invoiceDtos,
                PageNumber = gridRequest.PageNumber,
                PageSize = gridRequest.PageSize,
                TotalCount = totalCount
            };

            ViewBag.CustomerId = id.Value;
            ViewBag.CustomerName = !string.IsNullOrWhiteSpace(customer.CompanyName)
                ? customer.CompanyName
                : $"{customer.ContactFirstName} {customer.ContactLastName}".Trim();
            ViewBag.SortColumn = gridRequest.SortColumn;
            ViewBag.SortDirection = gridRequest.SortDirection;

            return View(pagedResult);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error retrieving invoices for customer {CustomerId}", id);
            this.ToastError("An error occurred while loading the invoices.");
            return RedirectToAction(nameof(Details), new { id });
        }
    }

    /// <summary>
    /// Renders the customer creation form. Checks the subscription plan limit before
    /// allowing access; redirects with an error if the company has reached its customer cap.
    /// Pricing tiers are pre-loaded via <see cref="PopulatePricingTiersAsync"/> so the
    /// dropdown is available immediately without a round-trip.
    /// </summary>
    public async Task<IActionResult> Create()
    {
        var companyId = _tenantContext.GetCurrentCompanyId() ?? 0;
        if (!await _subscriptionService.CanAddCustomerAsync(companyId))
        {
            var (used, max) = await _subscriptionService.GetCustomerCountAsync(companyId);
            TempData["Error"] = $"You have reached your plan limit of {max} customers. " +
                "Please upgrade your plan to add more customers.";
            return RedirectToAction(nameof(Index));
        }

        await PopulatePricingTiersAsync();
        return View();
    }

    /// <summary>
    /// Persists a new customer record. Re-validates the subscription plan limit on POST
    /// to guard against concurrent session exploitation. If the staff member records
    /// verbal SMS consent, sets NotifyBySms, stamps SmsConsentedAt, and immediately
    /// sends a confirmation SMS via <see cref="INotificationService"/>; the resulting
    /// notification log entry is then surfaced as a toast so staff can confirm delivery.
    /// </summary>
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task<IActionResult> Create(CreateCustomerDto dto)
    {
        if (!ModelState.IsValid)
        {
            await PopulatePricingTiersAsync();
            return View(dto);
        }

        // Subscription limit check
        var companyId = _tenantContext.GetCurrentCompanyId() ?? 0;
        if (!await _subscriptionService.CanAddCustomerAsync(companyId))
        {
            var (used, max) = await _subscriptionService.GetCustomerCountAsync(companyId);
            ModelState.AddModelError(string.Empty,
                $"You have reached your plan limit of {max} customers. " +
                "Please upgrade your plan to add more customers.");
            await PopulatePricingTiersAsync();
            return View(dto);
        }

        try
        {
            var customer = _mapper.Map<Customer>(dto);
            customer.CreatedAt = DateTime.UtcNow;
            customer.IsActive = true;

            // SMS consent: only enable if staff has checked the consent box
            if (dto.SmsConsentGranted && !string.IsNullOrWhiteSpace(dto.MobilePhone ?? dto.Phone))
            {
                customer.NotifyBySms = true;
                customer.SmsConsentedAt = DateTime.UtcNow;
                customer.SmsConsentMethod = "Staff-recorded verbal consent";
            }
            else
            {
                customer.NotifyBySms = false;
            }

            await _unitOfWork.Customers.AddAsync(customer);
            await _unitOfWork.SaveChangesAsync();

            // Send welcome/confirmation SMS after the customer record is saved
            if (customer.NotifyBySms)
            {
                try { await _notificationService.NotifySmsConsentGrantedAsync(customer); }
                catch (Exception ex) { _logger.LogWarning(ex, "SMS consent confirmation failed for customer {Id}", customer.Id); }

                var logs = await _unitOfWork.NotificationLogs.FindAsync(
                    n => n.CustomerId == customer.Id, ignoreQueryFilters: true);
                var smsLog = logs.OrderByDescending(n => n.SentAt).FirstOrDefault();
                this.SetNotificationResultToast(smsLog);
            }

            this.ToastSuccess("Customer created successfully.");
            return RedirectToAction(nameof(Index));
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error creating customer");
            this.ToastError("An error occurred while creating the customer.");
            return View(dto);
        }
    }

    /// <summary>
    /// Renders the customer edit form, pre-populated via AutoMapper from the stored entity.
    /// Pricing tiers are loaded so the dropdown reflects current active tiers even if
    /// the tier list has changed since the customer was created.
    /// </summary>
    public async Task<IActionResult> Edit(int? id)
    {
        if (id == null)
        {
            return NotFound();
        }

        try
        {
            var customer = await _unitOfWork.Customers.GetByIdAsync(id.Value);
            if (customer == null)
            {
                return NotFound();
            }

            var dto = _mapper.Map<UpdateCustomerDto>(customer);
            await PopulatePricingTiersAsync();
            return View(dto);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error retrieving customer {CustomerId} for edit", id);
            this.ToastError("An error occurred while loading the customer.");
            return RedirectToAction(nameof(Index));
        }
    }

    /// <summary>
    /// Persists edits to an existing customer. Special handling covers two sensitive fields:
    /// (1) Tax-exempt certificate bytes are captured before AutoMapper runs and restored after,
    ///     preventing the Edit form from inadvertently clearing an already-uploaded file.
    /// (2) SMS consent is append-only: newly granted consent stamps SmsConsentedAt and sends
    ///     a confirmation SMS; existing consent is not re-granted, but NotifyBySms can be
    ///     toggled on/off after the first grant to pause or resume messages.
    /// </summary>
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task<IActionResult> Edit(int id, UpdateCustomerDto dto)
    {
        if (id != dto.Id)
        {
            return NotFound();
        }

        if (!ModelState.IsValid)
        {
            await PopulatePricingTiersAsync();
            return View(dto);
        }

        try
        {
            var customer = await _unitOfWork.Customers.GetByIdAsync(id);
            if (customer == null)
            {
                return NotFound();
            }

            // Capture consent state before mapping (mapping ignores SmsConsentedAt/Method)
            var hadConsentBefore = customer.SmsConsentedAt.HasValue;

            // Preserve cert data before mapping (mapper ignores these, but save explicitly for safety)
            var certData = customer.TaxExemptCertificateData;
            var certContentType = customer.TaxExemptCertificateContentType;
            var certFileName = customer.TaxExemptCertificateFileName;

            _mapper.Map(dto, customer);
            customer.UpdatedAt = DateTime.UtcNow;

            // Restore cert data (defensive: ensure Edit form never clears uploaded certificates)
            customer.TaxExemptCertificateData = certData;
            customer.TaxExemptCertificateContentType = certContentType;
            customer.TaxExemptCertificateFileName = certFileName;

            // If consent was not previously granted and staff has now checked the consent box
            var newlyGranted = !hadConsentBefore && dto.SmsConsentGranted
                && !string.IsNullOrWhiteSpace(customer.MobilePhone ?? customer.Phone);

            if (newlyGranted)
            {
                customer.NotifyBySms = true;
                customer.SmsConsentedAt = DateTime.UtcNow;
                customer.SmsConsentMethod = "Staff-recorded verbal consent";
            }
            else if (!hadConsentBefore)
            {
                // No consent exists and none newly granted — keep SMS off
                customer.NotifyBySms = false;
            }
            // If hadConsentBefore: NotifyBySms is mapped from the toggle as-is (allow pause/resume)

            await _unitOfWork.Customers.UpdateAsync(customer);
            await _unitOfWork.SaveChangesAsync();

            // Send welcome SMS if consent was just granted
            if (newlyGranted)
            {
                try { await _notificationService.NotifySmsConsentGrantedAsync(customer); }
                catch (Exception ex) { _logger.LogWarning(ex, "SMS consent confirmation failed for customer {Id}", customer.Id); }

                var logs = await _unitOfWork.NotificationLogs.FindAsync(
                    n => n.CustomerId == customer.Id, ignoreQueryFilters: true);
                var smsLog = logs.OrderByDescending(n => n.SentAt).FirstOrDefault();
                this.SetNotificationResultToast(smsLog);
            }

            this.ToastSuccess("Customer updated successfully.");
            return RedirectToAction(nameof(Index));
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error updating customer {CustomerId}", id);
            this.ToastError("An error occurred while updating the customer.");
            return View(dto);
        }
    }

    /// <summary>
    /// Renders the delete confirmation page for a customer. The view shows a full
    /// summary so the user can verify they are about to remove the correct record
    /// before submitting the confirmation POST.
    /// </summary>
    public async Task<IActionResult> Delete(int? id)
    {
        if (id == null)
        {
            return NotFound();
        }

        try
        {
            var customer = await _unitOfWork.Customers.GetByIdAsync(id.Value);
            if (customer == null)
            {
                return NotFound();
            }

            var customerDto = _mapper.Map<CustomerDto>(customer);
            return View(customerDto);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error retrieving customer {CustomerId} for delete", id);
            this.ToastError("An error occurred while loading the customer.");
            return RedirectToAction(nameof(Index));
        }
    }

    /// <summary>
    /// Performs a soft delete on the customer record. A soft delete sets IsDeleted = true
    /// rather than removing the row, preserving referential integrity with historical jobs,
    /// quotes, and invoices. The record is filtered from all normal queries by the global
    /// EF query filter, and can only be seen by SuperAdmins with ignoreQueryFilters.
    /// </summary>
    [HttpPost, ActionName("Delete")]
    [ValidateAntiForgeryToken]
    public async Task<IActionResult> DeleteConfirmed(int id)
    {
        try
        {
            var customer = await _unitOfWork.Customers.GetByIdAsync(id);
            if (customer == null)
            {
                return NotFound();
            }

            await _unitOfWork.Customers.SoftDeleteAsync(customer);
            await _unitOfWork.SaveChangesAsync();

            this.ToastSuccess("Customer deleted successfully.");
            return RedirectToAction(nameof(Index));
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error deleting customer {CustomerId}", id);
            this.ToastError("An error occurred while deleting the customer.");
            return RedirectToAction(nameof(Index));
        }
    }

    /// <summary>
    /// Streams the tax-exempt certificate file stored as binary in the Customer entity back
    /// to the browser using the original content-type and filename. Certificates are stored
    /// in-database (not on disk) to keep them tenant-isolated without requiring blob storage
    /// configuration in every deployment environment.
    /// </summary>
    [HttpGet]
    public async Task<IActionResult> TaxExemptCertificate(int id)
    {
        try
        {
            var customer = await _unitOfWork.Customers.GetByIdAsync(id);
            if (customer == null || customer.TaxExemptCertificateData == null || customer.TaxExemptCertificateData.Length == 0)
            {
                return NotFound();
            }

            var contentType = customer.TaxExemptCertificateContentType ?? "application/pdf";
            var fileName = customer.TaxExemptCertificateFileName ?? "tax-exempt-certificate.pdf";

            return File(customer.TaxExemptCertificateData, contentType, fileName);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error retrieving tax exempt certificate for customer {CustomerId}", id);
            return NotFound();
        }
    }

    /// <summary>
    /// Accepts a tax-exempt certificate upload (PDF, JPG, or PNG, max 10 MB) and stores the
    /// raw bytes directly on the Customer entity. Storing in-database avoids the need for a
    /// shared file system or Azure Blob container in single-tenant or on-premise deployments.
    /// Content-type and original filename are stored alongside the bytes so
    /// <see cref="TaxExemptCertificate"/> can return them faithfully.
    /// </summary>
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task<IActionResult> UploadTaxExemptCertificate(int id, IFormFile certificateFile)
    {
        try
        {
            if (certificateFile == null || certificateFile.Length == 0)
            {
                this.ToastError("Please select a file to upload.");
                return RedirectToAction(nameof(Edit), new { id });
            }

            // Validate file type
            var allowedContentTypes = new[] { "application/pdf", "image/jpeg", "image/jpg", "image/png" };
            if (!allowedContentTypes.Contains(certificateFile.ContentType, StringComparer.OrdinalIgnoreCase))
            {
                this.ToastError("Invalid file type. Only PDF and image files (JPG, PNG) are allowed.");
                return RedirectToAction(nameof(Edit), new { id });
            }

            // Validate file size (10 MB max)
            const long maxSize = 10 * 1024 * 1024;
            if (certificateFile.Length > maxSize)
            {
                this.ToastError("File size exceeds the 10 MB limit.");
                return RedirectToAction(nameof(Edit), new { id });
            }

            var customer = await _unitOfWork.Customers.GetByIdAsync(id);
            if (customer == null)
            {
                return NotFound();
            }

            // Read file data
            using var ms = new MemoryStream();
            await certificateFile.CopyToAsync(ms);
            customer.TaxExemptCertificateData = ms.ToArray();
            customer.TaxExemptCertificateContentType = certificateFile.ContentType;
            customer.TaxExemptCertificateFileName = certificateFile.FileName;

            await _unitOfWork.Customers.UpdateAsync(customer);
            await _unitOfWork.SaveChangesAsync();

            this.ToastSuccess("Tax exempt certificate uploaded successfully.");
            return RedirectToAction(nameof(Edit), new { id });
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error uploading tax exempt certificate for customer {CustomerId}", id);
            this.ToastError("An error occurred while uploading the certificate.");
            return RedirectToAction(nameof(Edit), new { id });
        }
    }

    /// <summary>
    /// Clears the tax-exempt certificate from the customer record by nulling all three
    /// certificate fields (Data, ContentType, FileName). A separate action (rather than
    /// embedding the delete in Edit) avoids race conditions where the Edit form could
    /// clear the certificate bytes if the user saves without re-uploading.
    /// </summary>
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task<IActionResult> DeleteTaxExemptCertificate(int id)
    {
        try
        {
            var customer = await _unitOfWork.Customers.GetByIdAsync(id);
            if (customer == null)
            {
                return NotFound();
            }

            customer.TaxExemptCertificateData = null;
            customer.TaxExemptCertificateContentType = null;
            customer.TaxExemptCertificateFileName = null;

            await _unitOfWork.Customers.UpdateAsync(customer);
            await _unitOfWork.SaveChangesAsync();

            this.ToastSuccess("Tax exempt certificate deleted successfully.");
            return RedirectToAction(nameof(Edit), new { id });
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error deleting tax exempt certificate for customer {CustomerId}", id);
            this.ToastError("An error occurred while deleting the certificate.");
            return RedirectToAction(nameof(Edit), new { id });
        }
    }

    /// <summary>
    /// Issues a standalone credit memo and increments the customer's CreditBalance.
    /// Restricted to CompanyAdmin because credits affect the financial ledger. The memo
    /// number follows the CM-YYMM-#### format generated by <see cref="GenerateCreditMemoNumberAsync"/>.
    /// The memo is not tied to any invoice at creation; it will be applied automatically
    /// when the next invoice is created for this customer.
    /// </summary>
    [HttpPost, ValidateAntiForgeryToken]
    [Authorize(Policy = AppConstants.Policies.CompanyAdminOnly)]
    public async Task<IActionResult> AddCredit(int id, AddCreditDto dto)
    {
        if (!ModelState.IsValid)
        {
            TempData["Error"] = "Invalid credit amount or missing reason.";
            return RedirectToAction(nameof(Details), new { id });
        }

        try
        {
            var customer = await _unitOfWork.Customers.GetByIdAsync(id);
            if (customer == null) return NotFound();

            var currentUser = await _userManager.GetUserAsync(User);
            var memoNumber = await GenerateCreditMemoNumberAsync();

            var memo = new CreditMemo
            {
                MemoNumber = memoNumber,
                CustomerId = id,
                OriginalInvoiceId = null,   // not tied to an invoice
                Amount = dto.Amount,
                AmountApplied = 0,
                IssueDate = DateTime.UtcNow,
                ExpiryDate = dto.ExpiryDate,
                Reason = dto.Reason,
                Notes = dto.Notes,
                Status = CreditMemoStatus.Active,
                IssuedById = currentUser?.Id,
                CompanyId = customer.CompanyId,
                CreatedAt = DateTime.UtcNow,
                CreatedBy = currentUser?.Email
            };

            await _unitOfWork.CreditMemos.AddAsync(memo);

            customer.CreditBalance += dto.Amount;
            await _unitOfWork.Customers.UpdateAsync(customer);

            await _unitOfWork.CompleteAsync();

            TempData["Success"] = $"Credit of {dto.Amount:C} added to {customer.CompanyName ?? customer.ContactFirstName}'s account (Memo {memoNumber}).";
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error adding credit to customer {CustomerId}", id);
            TempData["Error"] = "An error occurred while adding the credit.";
        }

        return RedirectToAction(nameof(Details), new { id });
    }

    /// <summary>
    /// Displays or downloads a dated activity statement for a customer.
    /// Pass <c>pdf=true</c> to download the QuestPDF version; otherwise renders the HTML view.
    /// </summary>
    [HttpGet]
    public async Task<IActionResult> Statement(int id, DateTime? from, DateTime? to, bool pdf = false)
    {
        var companyId = _tenantContext.GetCurrentCompanyId() ?? 0;
        var fromDate  = from ?? new DateTime(DateTime.Today.Year, DateTime.Today.Month, 1);
        var toDate    = to   ?? DateTime.Today;

        var dto = await _financialReports.GetCustomerStatementAsync(companyId, id, fromDate, toDate);

        if (pdf)
        {
            var bytes = StatementPdfHelper.Generate(
                dto.CustomerName, dto.CompanyName, dto.CustomerAddress,
                dto.From, dto.To, dto.OpeningBalance, dto.Lines, dto.ClosingBalance, isVendor: false);
            return File(bytes, "application/pdf", $"Statement-{dto.CustomerName}-{toDate:yyyyMMdd}.pdf");
        }

        return View(dto);
    }

    /// <summary>
    /// Generates the next sequential credit memo number in CM-YYMM-#### format.
    /// Uses <c>ignoreQueryFilters: true</c> when scanning all existing memos so that
    /// soft-deleted records are included in the sequence check and their numbers are
    /// never reused, maintaining an audit-friendly gap-free numbering history.
    /// </summary>
    private async Task<string> GenerateCreditMemoNumberAsync()
    {
        var prefix = $"CM-{DateTime.Now:yyMM}-";
        var last = (await _unitOfWork.CreditMemos.FindAsync(
                m => m.MemoNumber.StartsWith(prefix), ignoreQueryFilters: true))
            .OrderByDescending(m => m.MemoNumber)
            .Select(m => m.MemoNumber)
            .FirstOrDefault();

        int next = 1;
        if (last != null && int.TryParse(last[prefix.Length..], out int num))
            next = num + 1;

        return $"{prefix}{next:D4}";
    }

    /// <summary>
    /// Loads all active pricing tiers into ViewBag.PricingTiers for the Create and Edit
    /// dropdowns. Tiers are sorted alphabetically and include the discount percentage in
    /// the label text so staff can see the benefit without opening the tier detail page.
    /// </summary>
    private async Task PopulatePricingTiersAsync()
    {
        var tiers = await _unitOfWork.PricingTiers.FindAsync(t => t.IsActive);
        ViewBag.PricingTiers = tiers
            .OrderBy(t => t.TierName)
            .Select(t => new SelectListItem
            {
                Value = t.Id.ToString(),
                Text = t.DiscountPercent > 0
                    ? $"{t.TierName} ({t.DiscountPercent:0.##}% discount)"
                    : t.TierName
            })
            .ToList();
    }
}