MoneyMap/MoneyMap/Pages/Recategorize.cshtml.cs

using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.RazorPages;
using Microsoft.EntityFrameworkCore;
using MoneyMap.Data;
using MoneyMap.Services;

namespace MoneyMap.Pages
{
    public class RecategorizeModel : PageModel
    {
        private readonly MoneyMapContext _db;
        private readonly ITransactionCategorizer _categorizer;

        public RecategorizeModel(MoneyMapContext db, ITransactionCategorizer categorizer)
        {
            _db = db;
            _categorizer = categorizer;
        }

        public RecategorizeStats Stats { get; set; } = new();

        [TempData]
        public string? SuccessMessage { get; set; }

        public async Task OnGetAsync()
        {
            await LoadStatsAsync();
        }

        public async Task<IActionResult> OnPostRecategorizeAllAsync()
        {
            var result = await RecategorizeTransactionsAsync(includeAlreadyCategorized: true);

            SuccessMessage = $"Processed {result.Total} transactions: {result.Updated} updated, {result.AlreadyCorrect} already correct, {result.NoMatch} no match found.";

            return RedirectToPage();
        }

        public async Task<IActionResult> OnPostRecategorizeUncategorizedAsync()
        {
            var result = await RecategorizeTransactionsAsync(includeAlreadyCategorized: false);

            SuccessMessage = $"Processed {result.Total} uncategorized transactions: {result.Updated} categorized, {result.NoMatch} still need manual categorization.";

            return RedirectToPage();
        }

        private async Task LoadStatsAsync()
        {
            var totalTransactions = await _db.Transactions.CountAsync();
            var uncategorized = await _db.Transactions
                .CountAsync(t => string.IsNullOrWhiteSpace(t.Category));
            var categorized = totalTransactions - uncategorized;

            Stats = new RecategorizeStats
            {
                TotalTransactions = totalTransactions,
                Categorized = categorized,
                Uncategorized = uncategorized
            };
        }

        private async Task<RecategorizeResult> RecategorizeTransactionsAsync(bool includeAlreadyCategorized)
        {
            var query = _db.Transactions.AsQueryable();

            if (!includeAlreadyCategorized)
            {
                query = query.Where(t => string.IsNullOrWhiteSpace(t.Category));
            }

            var transactions = await query.ToListAsync();

            int total = transactions.Count;
            int updated = 0;
            int alreadyCorrect = 0;
            int noMatch = 0;

            foreach (var txn in transactions)
            {
                var newCategory = await _categorizer.CategorizeAsync(txn.Name, txn.Amount);

                if (string.IsNullOrWhiteSpace(newCategory))
                {
                    noMatch++;
                    continue;
                }

                if (txn.Category == newCategory)
                {
                    alreadyCorrect++;
                    continue;
                }

                txn.Category = newCategory;
                updated++;
            }

            if (updated > 0)
            {
                await _db.SaveChangesAsync();
            }

            return new RecategorizeResult
            {
                Total = total,
                Updated = updated,
                AlreadyCorrect = alreadyCorrect,
                NoMatch = noMatch
            };
        }

        public class RecategorizeStats
        {
            public int TotalTransactions { get; set; }
            public int Categorized { get; set; }
            public int Uncategorized { get; set; }
        }

        private class RecategorizeResult
        {
            public int Total { get; set; }
            public int Updated { get; set; }
            public int AlreadyCorrect { get; set; }
            public int NoMatch { get; set; }
        }
    }
}