public class SweetStudentRecord
{
    public string FullName { get; set; }  // Full name of our sweetie pie
    public string Course { get; set; }  // The course they are taking, like "Mathematics" or "Science" 💡
    public int FinalExamScore { get; set; }  // The score they got on the final exam 🎓
    public int MidtermScore { get; set; }  // Their midterm score 📚
    public int QuizScore { get; set; }  // How they did on quizzes! 💫
}

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text.Json;
using System.Threading.Tasks;

public class SweetStorageHandler<T>
{
    private const string jsonFilePath = "SweetStudentData.json";  // Oh so sweet file path! 💖

    public async Task<List<T>> RetrieveSweetDataAsync(Func<T, bool> filter)
    {
        if (!File.Exists(jsonFilePath))
            return new List<T>();  // No worries, just an empty list of sweeties 🍬

        string json = await File.ReadAllTextAsync(jsonFilePath);  // Reading the sweet file 💖
        var data = JsonSerializer.Deserialize<List<T>>(json) ?? new List<T>();  // Deserializing all our cute data!

        return data.Where(filter).ToList();  // Filtering based on our cutie-pie condition 🍒
    }

    public async Task SaveSweetUpdatedDataAsync(IEnumerable<T> newData, Func<T, bool> matchCondition)
    {
        try
        {
            List<T> existingSweeties = new List<T>();

            if (File.Exists(jsonFilePath))
            {
                string existingJson = await File.ReadAllTextAsync(jsonFilePath);  // Oh look, an old JSON file to update! 🌸
                existingSweeties = JsonSerializer.Deserialize<List<T>>(existingJson) ?? new List<T>();
            }

            // Add or update data based on sweet condition 🧸
            foreach (var newEntry in newData)
            {
                var oldEntry = existingSweeties.FirstOrDefault(matchCondition);
                if (oldEntry != null)
                {
                    int index = existingSweeties.IndexOf(oldEntry);
                    if (index >= 0)
                    {
                        existingSweeties[index] = newEntry;  // Update the record!
                    }
                }
                else
                {
                    existingSweeties.Add(newEntry);  // Adding a new sweetie 💖
                }
            }

            string updatedJson = JsonSerializer.Serialize(existingSweeties, new JsonSerializerOptions { WriteIndented = true });
            await File.WriteAllTextAsync(jsonFilePath, updatedJson);  // Saving the updated data 💕
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Oops, something went wrong while saving the sweet file: {ex.Message}");
        }
    }
}

public class SweetStudentManager
{
    private readonly SweetStorageHandler<SweetStudentRecord> sweetStorageHandler = new SweetStorageHandler<SweetStudentRecord>();

    public async Task<IEnumerable<SweetStudentRecord>> LoadSweetStudentRecordsAsync(Func<SweetStudentRecord, bool> filter)
    {
        try
        {
            var sweetStudents = await sweetStorageHandler.RetrieveSweetDataAsync(filter);
            return sweetStudents;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Oops, couldn’t find your sweet students: {ex.Message}");
            return Enumerable.Empty<SweetStudentRecord>();  // Just in case we don’t find anyone 💔
        }
    }
}

public class SweetScoreUpdater
{
    private readonly SweetStorageHandler<SweetStudentRecord> sweetStorageHandler = new SweetStorageHandler<SweetStudentRecord>();

    public async Task UpdateSweetStudentScoreAsync(object selectedRow)
    {
        if (selectedRow is SweetStudentRecord sweetStudent)  // Check if we have a sweet student selected
        {
            var matchingSweetRecords = await sweetStorageHandler.RetrieveSweetDataAsync(record => record.FullName == sweetStudent.FullName && record.Course == sweetStudent.Course);

            var foundRecord = matchingSweetRecords.FirstOrDefault();  // Find our cherry-berry sweetie!

            if (foundRecord is SweetStudentRecord sweetData)
            {
                sweetData.FinalExamScore = sweetStudent.FinalExamScore;  // Update those scores! 🎓
                sweetData.MidtermScore = sweetStudent.MidtermScore;  // Midterm update 🍒
                sweetData.QuizScore = sweetStudent.QuizScore;  // Quiz score update 💖

                // Save the updated sweet data! 🍒
                await sweetStorageHandler.SaveSweetUpdatedDataAsync(matchingSweetRecords, record => record.FullName == sweetStudent.FullName && record.Course == sweetStudent.Course);
            }
        }
    }
}

public async Task<List<LucyModel>> LoadTableDataAsync()
{
    // 🛑 If the file doesn't exist, return an empty list
    if (!File.Exists(tempJsonFile)) return new List<LucyModel>();

    using (var reader = new StreamReader(tempJsonFile))
    {
        // 📝 Read the entire JSON file
        string jsonData = await reader.ReadToEndAsync();
        
        // 🔄 Convert JSON text into a List of objects
        return JsonConvert.DeserializeObject<List<LucyModel>>(jsonData) ?? new List<LucyModel>();
    }
}

public async Task UpdateSelectedPropertiesAsync(string itemId, decimal newPrice, int newDiscount)
{
    // 🔄 Step 1: Load existing data from JSON
    var items = await LoadTableDataAsync();

    // 🔍 Step 2: Find the item that needs to be updated
    var itemToUpdate = items.FirstOrDefault(item => item.Id == itemId);

    if (itemToUpdate != null)
    {
        // ✨ Step 3: Update ONLY the required properties
        itemToUpdate.Price = newPrice;
        itemToUpdate.Discount = newDiscount;
        itemToUpdate.IsUpdated = true; // ✅ Mark as updated

        // 💾 Step 4: Save changes back to JSON
        await SaveTableDataAsync(items);
    }
}

public async Task SaveTableDataAsync(List<LucyModel> updatedData)
{
    // 🔄 Convert the updated list back to JSON format
    string updatedJson = JsonConvert.SerializeObject(updatedData, Formatting.Indented);

    // 💾 Save the JSON to file
    await File.WriteAllTextAsync(tempJsonFile, updatedJson);
}

public async Task<List<LucyModel>> LoadTableDataAsync()
{
    if (!File.Exists(tempJsonFile)) return new List<LucyModel>();

    using (var reader = new StreamReader(tempJsonFile))
    {
        string jsonData = await reader.ReadToEndAsync();
        return JsonConvert.DeserializeObject<List<LucyModel>>(jsonData) ?? new List<LucyModel>();
    }
}

public async Task UpdateSelectedPropertiesAsync(string itemId, decimal newPrice, int newDiscount)
{
    var items = await LoadTableDataAsync();
    var itemToUpdate = items.FirstOrDefault(item => item.Id == itemId);

    if (itemToUpdate != null)
    {
        itemToUpdate.Price = newPrice;
        itemToUpdate.Discount = newDiscount;
        itemToUpdate.IsUpdated = true;

        await SaveTableDataAsync(items);
    }
}

public async Task SaveTableDataAsync(List<LucyModel> updatedData)
{
    string updatedJson = JsonConvert.SerializeObject(updatedData, Formatting.Indented);
    await File.WriteAllTextAsync(tempJsonFile, updatedJson);
}