BookmarkDataProvider.cs

using System.Globalization;

using LogExpert.Core.Entities;
using LogExpert.Core.Interfaces;

using NLog;

namespace LogExpert.Core.Classes.Bookmark;

public class BookmarkDataProvider : IBookmarkData
{
    #region Fields

    private static readonly Logger _logger = LogManager.GetCurrentClassLogger();

    private readonly Lock _bookmarkListLock = new();

    #endregion

    #region cTor

    public BookmarkDataProvider ()
    {
        BookmarkList = [];
    }

    public BookmarkDataProvider (SortedList<int, Entities.Bookmark> bookmarkList)
    {
        BookmarkList = bookmarkList;
    }

    #endregion

    #region Events

    public event EventHandler<EventArgs> BookmarkAdded;
    public event EventHandler<EventArgs> BookmarkRemoved;
    public event EventHandler<EventArgs> AllBookmarksRemoved;

    #endregion

    #region Properties

    public BookmarkCollection Bookmarks => new(BookmarkList);

    public SortedList<int, Entities.Bookmark> BookmarkList { get; private set; }

    #endregion

    #region Public methods

    public void SetBookmarks (SortedList<int, Entities.Bookmark> bookmarkList)
    {
        lock (_bookmarkListLock)
        {
            BookmarkList = bookmarkList;
        }
    }

    public void ToggleBookmark (int lineNum)
    {
        if (IsBookmarkAtLine(lineNum))
        {
            RemoveBookmarkForLine(lineNum);
        }
        else
        {
            AddBookmark(new Entities.Bookmark(lineNum));
        }
    }

    public bool IsBookmarkAtLine (int lineNum)
    {
        lock (_bookmarkListLock)
        {
            return BookmarkList.ContainsKey(lineNum);
        }
    }

    public int GetBookmarkIndexForLine (int lineNum)
    {
        lock (_bookmarkListLock)
        {
            return BookmarkList.IndexOfKey(lineNum);
        }
    }

    public Entities.Bookmark GetBookmarkForLine (int lineNum)
    {
        lock (_bookmarkListLock)
        {
            return BookmarkList[lineNum];
        }
    }

    #endregion

    #region Internals

    /// <summary>
    /// Removes all bookmarks where <see cref="Entities.Bookmark.IsAutoGenerated"/> is <c>true</c>.
    /// Manual bookmarks are not affected. Fires <see cref="BookmarkRemoved"/> if any were removed.
    /// </summary>
    public void RemoveAutoGeneratedBookmarks ()
    {
        var removed = false;

        lock (_bookmarkListLock)
        {
            List<int> keysToRemove = [.. BookmarkList
                 .Where(kvp => kvp.Value.IsAutoGenerated)
                 .Select(kvp => kvp.Key)];

            foreach (var key in keysToRemove)
            {
                _ = BookmarkList.Remove(key);
                removed = true;
            }
        }

        if (removed)
        {
            OnBookmarkRemoved();
        }
    }

    /// <summary>
    /// Converts an auto-generated bookmark at the given line to a manual bookmark.
    /// Sets <see cref="Entities.Bookmark.IsAutoGenerated"/> to <c>false</c> and clears
    /// <see cref="Entities.Bookmark.SourceHighlightText"/>.
    /// The bookmark will then survive re-scans.
    /// </summary>
    /// <returns><c>true</c> if a bookmark was found and converted; <c>false</c> otherwise.</returns>
    public bool ConvertToManualBookmark (int lineNum)
    {
        lock (_bookmarkListLock)
        {
            if (BookmarkList.TryGetValue(lineNum, out var bookmark) && bookmark.IsAutoGenerated)
            {
                bookmark.IsAutoGenerated = false;
                bookmark.SourceHighlightText = null;
                return true;
            }
        }

        return false;
    }

    public void ShiftBookmarks (int offset)
    {
        SortedList<int, Entities.Bookmark> newBookmarkList = [];

        foreach (var bookmark in BookmarkList.Values)
        {
            var line = bookmark.LineNum - offset;
            if (line >= 0)
            {
                bookmark.LineNum = line;
                newBookmarkList.Add(line, bookmark);
            }
        }

        BookmarkList = newBookmarkList;
    }

    public int FindPrevBookmarkIndex (int lineNum)
    {
        var values = BookmarkList.Values;
        for (var i = BookmarkList.Count - 1; i >= 0; --i)
        {
            if (values[i].LineNum <= lineNum)
            {
                return i;
            }
        }

        return BookmarkList.Count - 1;
    }

    public int FindNextBookmarkIndex (int lineNum)
    {

        var values = BookmarkList.Values;
        for (var i = 0; i < BookmarkList.Count; ++i)
        {
            if (values[i].LineNum >= lineNum)
            {
                return i;
            }
        }

        return 0;
    }

    public void RemoveBookmarkForLine (int lineNum)
    {
        lock (_bookmarkListLock)
        {
            _ = BookmarkList.Remove(lineNum);
        }

        OnBookmarkRemoved();
    }

    //TOOD: check if the callers are checking for null before calling
    public void RemoveBookmarksForLines (IEnumerable<int> lineNumList)
    {
        ArgumentNullException.ThrowIfNull(lineNumList, nameof(lineNumList));
        lock (_bookmarkListLock)
        {
            foreach (var lineNum in lineNumList)
            {
                _ = BookmarkList.Remove(lineNum);

            }
        }

        OnBookmarkRemoved();
    }

    public void AddBookmark (Entities.Bookmark bookmark)
    {
        ArgumentNullException.ThrowIfNull(bookmark, nameof(bookmark));
        lock (_bookmarkListLock)
        {
            BookmarkList.Add(bookmark.LineNum, bookmark);
        }

        OnBookmarkAdded();
    }

    /// <summary>
    /// Adds multiple bookmarks in a single batch operation. Fires <see cref="BookmarkAdded"/>
    /// only once at the end, avoiding per-item event overhead.
    /// Bookmarks whose <see cref="Entities.Bookmark.LineNum"/> already exists in the list are skipped.
    /// </summary>
    public int AddBookmarks (IEnumerable<Entities.Bookmark> bookmarks)
    {
        ArgumentNullException.ThrowIfNull(bookmarks, nameof(bookmarks));

        var added = 0;

        lock (_bookmarkListLock)
        {
            foreach (var bookmark in bookmarks)
            {
                if (!BookmarkList.ContainsKey(bookmark.LineNum))
                {
                    BookmarkList.Add(bookmark.LineNum, bookmark);
                    added++;
                }
            }
        }

        if (added > 0)
        {
            OnBookmarkAdded();
        }

        return added;
    }

    public void ClearAllBookmarks ()
    {
#if DEBUG
        _logger.Debug(CultureInfo.InvariantCulture, "Removing all bookmarks");
#endif
        lock (_bookmarkListLock)
        {
            BookmarkList.Clear();
        }

        OnAllBookmarksRemoved();
    }

    #endregion

    #region Event invokers

    protected void OnBookmarkAdded ()
    {
        BookmarkAdded?.Invoke(this, EventArgs.Empty);
    }

    protected void OnBookmarkRemoved ()
    {
        BookmarkRemoved?.Invoke(this, EventArgs.Empty);
    }

    protected void OnAllBookmarksRemoved ()
    {
        AllBookmarksRemoved?.Invoke(this, EventArgs.Empty);
    }

    #endregion

}