Check for Duplicates In Mining Mode

JL.Core/Config/CoreConfigManager.cs

@@ -15,6 +15,7 @@ public sealed class CoreConfigManager
     public bool AnkiIntegration { get; set; } // = false;
     public bool ForceSyncAnki { get; private set; } // = false;
     public bool AllowDuplicateCards { get; private set; } // = false;
+    public bool CheckForDuplicateCards { get; private set; } // = false;
     public double LookupRate { get; private set; } // = 0;
     public bool CaptureTextFromClipboard { get; set; } = true;
     public bool CaptureTextFromWebSocket { get; set; } // = false;
@@ -95,6 +96,7 @@ public void ApplyPreferences(SqliteConnection connection)
         AnkiIntegration = ConfigDBManager.GetValueFromConfig(connection, AnkiIntegration, nameof(AnkiIntegration), bool.TryParse);
         ForceSyncAnki = ConfigDBManager.GetValueFromConfig(connection, ForceSyncAnki, nameof(ForceSyncAnki), bool.TryParse);
         AllowDuplicateCards = ConfigDBManager.GetValueFromConfig(connection, AllowDuplicateCards, nameof(AllowDuplicateCards), bool.TryParse);
+        CheckForDuplicateCards = ConfigDBManager.GetValueFromConfig(connection, CheckForDuplicateCards, nameof(CheckForDuplicateCards), bool.TryParse);
         LookupRate = ConfigDBManager.GetNumberWithDecimalPointFromConfig(connection, LookupRate, nameof(LookupRate), double.TryParse);
         TextBoxTrimWhiteSpaceCharacters = ConfigDBManager.GetValueFromConfig(connection, TextBoxTrimWhiteSpaceCharacters, nameof(TextBoxTrimWhiteSpaceCharacters), bool.TryParse);
         TextBoxRemoveNewlines = ConfigDBManager.GetValueFromConfig(connection, TextBoxRemoveNewlines, nameof(TextBoxRemoveNewlines), bool.TryParse);

JL.Core/Mining/Anki/AnkiConnect.cs

@@ -42,15 +42,12 @@ internal static class AnkiConnect
         return Send(req);
     }
 
-    public static ValueTask<Response?> GetCanAddNotesResponse(Note note)
+    public static ValueTask<Response?> GetCanAddNotesResponse(Note[] notes)
     {
         Request req = new("canAddNotes", 6, new Dictionary<string, object>(1, StringComparer.Ordinal)
         {
             {
-                "notes", new[]
-                {
-                    note
-                }
+                "notes", notes
             }
         });
 

JL.Core/Mining/Anki/AnkiUtils.cs

@@ -37,11 +37,21 @@ public static class AnkiUtils
 
     internal static async Task<bool?> CanAddNote(Note note)
     {
-        Response? response = await AnkiConnect.GetCanAddNotesResponse(note).ConfigureAwait(false);
+        Response? response = await AnkiConnect.GetCanAddNotesResponse([note]).ConfigureAwait(false);
         string? resultString = response?.Result?.ToString() ?? null;
 
         return resultString is not null
             ? JsonSerializer.Deserialize<bool[]>(resultString)![0]
             : null;
     }
+
+    internal static async Task<bool[]?> CanAddNotes(Note[] notes)
+    {
+        Response? response = await AnkiConnect.GetCanAddNotesResponse(notes).ConfigureAwait(false);
+        string? resultString = response?.Result?.ToString() ?? null;
+
+        return resultString is not null
+            ? JsonSerializer.Deserialize<bool[]>(resultString)!
+            : null;
+    }
 }

JL.Core/Mining/MiningUtils.cs

@@ -1,5 +1,6 @@
 using System.Globalization;
 using System.Text;
+using System.Text.Json;
 using JL.Core.Audio;
 using JL.Core.Config;
 using JL.Core.Dicts;
@@ -440,6 +441,75 @@ public static async Task MineToFile(LookupResult lookupResult, string currentTex
         Utils.Logger.Information("Mined {PrimarySpelling}", lookupResult.PrimarySpelling);
     }
 
+    public static async Task<List<bool>?> CheckDuplicates(List<LookupResult> lookupResults, string currentText, int currentCharPosition)
+    {
+        List<Note> notes = [];
+        List<int> positions = [];
+        List<bool> ret = [];
+        for (int i = 0; i < lookupResults.Count; i++)
+        {
+            ret.Add(false);
+            LookupResult lookupResult = lookupResults[i];
+
+            Dictionary<MineType, AnkiConfig>? ankiConfigDict = await AnkiConfig.ReadAnkiConfig().ConfigureAwait(false);
+            if (ankiConfigDict is null)
+            {
+                continue;
+            }
+
+            AnkiConfig? ankiConfig;
+            if (DictUtils.s_wordDictTypes.Contains(lookupResult.Dict.Type))
+            {
+                ankiConfig = ankiConfigDict.GetValueOrDefault(MineType.Word);
+            }
+            else if (DictUtils.s_kanjiDictTypes.Contains(lookupResult.Dict.Type))
+            {
+                ankiConfig = ankiConfigDict.GetValueOrDefault(MineType.Kanji);
+            }
+            else if (DictUtils.s_nameDictTypes.Contains(lookupResult.Dict.Type))
+            {
+                ankiConfig = ankiConfigDict.GetValueOrDefault(MineType.Name);
+            }
+            else
+            {
+                ankiConfig = ankiConfigDict.GetValueOrDefault(MineType.Other);
+            }
+
+            if (ankiConfig is null)
+            {
+                continue;
+            }
+
+            Dictionary<string, JLField> userFields = ankiConfig.Fields;
+            JLField firstValue = userFields.First().Value;
+            Dictionary<JLField, string> filteredMiningParams = new()
+            {
+                { firstValue, GetMiningParameters(lookupResult, currentText, null, null, currentCharPosition, true)[firstValue] }
+            };
+            Dictionary<string, string> fields = ConvertFields(userFields, filteredMiningParams);
+
+            Note note = new(ankiConfig.DeckName, ankiConfig.ModelName, fields, ankiConfig.Tags, null, null, null, null);
+            notes.Add(note);
+
+            positions.Add(i);
+        }
+
+        Utils.Logger.Error("Sending notes to anki {notes}", JsonSerializer.Serialize(notes));
+
+        bool[]? canAddNote = await AnkiUtils.CanAddNotes(notes.ToArray()).ConfigureAwait(false);
+        if (canAddNote == null)
+        {
+            return null;
+        }
+
+        for (int i = 0; i < canAddNote.Length; i++)
+        {
+            ret[positions[i]] = !canAddNote[i];
+        }
+
+        return ret;
+    }
+
     public static async Task Mine(LookupResult lookupResult, string currentText, string? formattedDefinitions, string? selectedDefinitions, int currentCharPosition)
     {
         CoreConfigManager coreConfigManager = CoreConfigManager.Instance;

JL.Windows/ConfigManager.cs

@@ -848,6 +848,7 @@ public void LoadPreferenceWindow(PreferencesWindow preferenceWindow)
         preferenceWindow.WebSocketUriTextBox.Text = coreConfigManager.WebSocketUri.OriginalString;
         preferenceWindow.ForceSyncAnkiCheckBox.IsChecked = coreConfigManager.ForceSyncAnki;
         preferenceWindow.AllowDuplicateCardsCheckBox.IsChecked = coreConfigManager.AllowDuplicateCards;
+        preferenceWindow.CheckForDuplicateCardsCheckBox.IsChecked = coreConfigManager.CheckForDuplicateCards;
         preferenceWindow.LookupRateNumericUpDown.Value = coreConfigManager.LookupRate;
         preferenceWindow.KanjiModeCheckBox.IsChecked = coreConfigManager.KanjiMode;
         preferenceWindow.AutoAdjustFontSizesOnResolutionChange.IsChecked = AutoAdjustFontSizesOnResolutionChange;
@@ -1213,6 +1214,9 @@ public async Task SavePreferences(PreferencesWindow preferenceWindow)
             ConfigDBManager.UpdateSetting(connection, nameof(CoreConfigManager.AllowDuplicateCards),
                 preferenceWindow.AllowDuplicateCardsCheckBox.IsChecked.ToString()!);
 
+            ConfigDBManager.UpdateSetting(connection, nameof(CoreConfigManager.CheckForDuplicateCards),
+                preferenceWindow.CheckForDuplicateCardsCheckBox.IsChecked.ToString()!);
+
             ConfigDBManager.UpdateSetting(connection, nameof(CoreConfigManager.LookupRate),
                 preferenceWindow.LookupRateNumericUpDown.Value.ToString(CultureInfo.InvariantCulture));
 

JL.Windows/GUI/PopupWindow.xaml.cs

@@ -51,6 +51,7 @@ internal sealed partial class PopupWindow
     public nint WindowHandle { get; private set; }
 
     public List<LookupResult> LastLookupResults { get; private set; } = [];
+    public List<Button> DuplicateIcons { get; private set; } = [];
 
     private List<Dict> _dictsWithResults = [];
 
@@ -251,6 +252,7 @@ public Task LookupOnCharPosition(TextBox textBox, int charPosition, bool enableM
             }
 
             LastLookupResults = lookupResults;
+            DuplicateIcons = [];
 
             if (enableMiningMode)
             {
@@ -365,6 +367,7 @@ public Task LookupOnSelect(TextBox textBox)
             _previousTextBox = textBox;
             LastSelectedText = lookupResults[0].MatchedText;
             LastLookupResults = lookupResults;
+            DuplicateIcons = [];
 
             EnableMiningMode();
             DisplayResults(true);
@@ -508,6 +511,7 @@ public void DisplayResults(bool generateAllResults)
         }
 
         PopupListView.ItemsSource = popupItemSource;
+        CheckResultForDuplicates();
         GenerateDictTypeButtons();
         UpdateLayout();
     }
@@ -695,6 +699,29 @@ private StackPanel PrepareResultStackPanel(LookupResult result, int index, int r
             audioButton.Click += AudioButton_Click;
 
             _ = top.Children.Add(audioButton);
+
+            if (!configManager.MineToFileInsteadOfAnki)
+            {
+                Button duplicate = new()
+                {
+                    Name = nameof(duplicate),
+                    Content = "⚠️",
+                    Foreground = configManager.DefinitionsColor,
+                    VerticalAlignment = VerticalAlignment.Top,
+                    Margin = new Thickness(3, 0, 0, 0),
+                    HorizontalAlignment = HorizontalAlignment.Left,
+                    Background = Brushes.Transparent,
+                    Cursor = Cursors.Arrow,
+                    BorderThickness = new Thickness(0),
+                    Padding = new Thickness(0),
+                    FontSize = 14,
+                    ToolTip = $"{result.PrimarySpelling} is already in anki deck.",
+                    Visibility = Visibility.Collapsed
+                };
+
+                _ = top.Children.Add(duplicate);
+                DuplicateIcons.Add(duplicate);
+            }
         }
 
         if (result.AlternativeSpellings is not null && configManager.AlternativeSpellingsFontSize > 0)
@@ -1067,6 +1094,30 @@ private StackPanel PrepareResultStackPanel(LookupResult result, int index, int r
         return stackPanel;
     }
 
+    private async void CheckResultForDuplicates()
+    {
+        ConfigManager configManager = ConfigManager.Instance;
+        CoreConfigManager coreConfigManager = CoreConfigManager.Instance;
+        if (MiningMode && coreConfigManager.AnkiIntegration
+            && coreConfigManager.CheckForDuplicateCards
+            && !configManager.MineToFileInsteadOfAnki)
+        {
+            List<bool>? duplicateCard = await MiningUtils.CheckDuplicates(LastLookupResults, _currentText, _currentCharPosition).ConfigureAwait(false);
+
+            if (duplicateCard != null)
+            {
+                for (int i = 0; i < duplicateCard.Count; i++)
+                {
+                    if (duplicateCard[i])
+                    {
+                        await MainWindow.Instance.Dispatcher.InvokeAsync(() => { DuplicateIcons[i].Visibility = Visibility.Visible; });
+                    }
+
+                }
+            }
+        }
+    }
+
     private int GetFirstVisibleListViewItemIndex()
     {
         StackPanel? firstVisibleStackPanel = PopupListView.Items.Cast<StackPanel>()
@@ -2068,6 +2119,7 @@ private void Window_Closed(object sender, EventArgs e)
         PopupListView.ItemsSource = null;
         _lastInteractedTextBox = null;
         LastLookupResults = null!;
+        DuplicateIcons = null!;
         _dictsWithResults = null!;
         _currentText = null!;
         _buttonAll.Click -= DictTypeButtonOnClick;

JL.Windows/GUI/PreferencesWindow.xaml

@@ -1033,6 +1033,13 @@
                                 <CheckBox x:Name="AllowDuplicateCardsCheckBox"  HorizontalAlignment="Right" />
                             </DockPanel>
 
+                            <DockPanel Margin="0,10,0,0">
+                                <TextBlock HorizontalAlignment="Left" Text="Check for duplicate cards"
+                                            Style="{StaticResource TextBlockDefault}" VerticalAlignment="Center" TextWrapping="Wrap"
+                                            ToolTip="Checks Anki for Duplicate Expressions when entering Mining Mode" Cursor="Help"/>
+                                <CheckBox x:Name="CheckForDuplicateCardsCheckBox"  HorizontalAlignment="Right" />
+                            </DockPanel>
+
                             <TabControl Margin="0,10,0,0">
                                 <TabControl.Resources>
                                     <Style TargetType="{x:Type TabPanel}">