BaseKeeper.h

/*
 * Copyright (C) 2026 Yury Bobylev <bobilev_yury@mail.ru>
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation, version 3.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program. If not, see <https://www.gnu.org/licenses/>.
 */
#ifndef BASEKEEPER_H
#define BASEKEEPER_H
 
#include <BaseID.h>
#include <MLBookProc.h>
#include <NotesKeeper.h>
#include <UDBase.h>
#include <filesystem>
#include <functional>
#include <shared_mutex>

class BaseKeeper : public UDBase
{
public:
  BaseKeeper(const std::shared_ptr<MLBookProc> &mlbp);
 
  virtual ~BaseKeeper();

  void
  loadCollection(const std::filesystem::path &base_path);

  size_t
  getBooksQuantity();

  size_t
  getFilesQuantity();

  UDBase
  searchBook(const std::vector<UDBElement> &requests,
             const double &coef_coincedence);

  void
  cancelSearch();

  std::string
  getCollectionType();

  std::filesystem::path
  getBooksDirectory();

  void
  editBookEntry(const UDBElement &book_search_result);

  UDBase
  searchBooksWithNotes(const std::shared_ptr<NotesKeeper> &notes);

  UDBase
  getAllFiles();

  UDBase
  listAllAuthors();

  void
  exportBase(const std::filesystem::path &result_path);

  std::filesystem::path
  getCurrentCollectionBasePath();

  static UDBElement
  getBaseAnchorFileName(const std::filesystem::path &base_path);

  static void
  importCollectionBase(const std::filesystem::path &source_base_path,
                       const std::filesystem::path &coll_base_path,
                       const std::filesystem::path &anchor_file);

  void
  unloadCollection();
 
private:
  void
  loadCollectionLegacy(const std::vector<char> &buf);
 
  void
  parseFileEntryLegacy(const std::string &buf, const std::string &books_path);
 
  void
  parseBookEntryLegacy(const std::string &buf,
                       std::vector<UDBElement> &result);
 
  UDBase
  searchElement(std::function<void(const UDBElement &, UDBase &)>
                    search_function) override;
 
  void
  searchFunc(const UDBElement &el, UDBase *result,
             const std::vector<std::tuple<
                 UDBElement, std::function<bool(const UDBElement &book_el,
                                                const UDBElement &to_search)>>>
                 &l_request);
 
  bool
  authorSearch(const UDBElement &book_el, const UDBElement &to_search,
               const double &coef_coincidence);
 
  bool
  bookSearch(const UDBElement &book_el, const UDBElement &to_search,
             const double &coef_coincidence);
 
  bool
  sequenceSearch(const UDBElement &book_el, const UDBElement &to_search,
                 const std::string &name, const std::string &number,
                 const std::string &content, const double &coef_coincidence);
 
  bool
  genreSearch(const UDBElement &book_el, const UDBElement &to_search,
              const double &coef_coincidence);
 
  std::vector<UDBElement *>
  searchFile(const std::vector<UDBElement> &src, const std::string &file_path);
 
  enum Normalization
  {
    Author,
    Other
  };
 
  bool
  searchLineFunc(const std::string &to_search, const std::string &source,
                 const double &coef_coincidence,
                 const Normalization &variant = Normalization::Other);
 
  void
  normalizeString(std::string &str, const Normalization &variant);
 
  size_t
  booksQuantity(const std::vector<UDBElement> &items);
 
  size_t
  filesQuantity(const std::vector<UDBElement> &items);
 
  UDBase
  searchInNotes(const std::vector<UDBElement> &src,
                const std::shared_ptr<NotesKeeper> &notes);
 
  UDBase
  getFiles(const std::vector<UDBElement> &src);
 
  void
  listAuthors(const std::vector<UDBElement> &src,
              std::vector<UDBElement> *result);
 
  void
  setRelativePath(std::vector<UDBElement> &src,
                  const std::filesystem::path &base_path);
 
  static void
  setAbsolutePath(std::vector<UDBElement> &src,
                  const std::filesystem::path &base_path);
 
  std::shared_ptr<MLBookProc> mlbp;
 
  bool cancel_search = false;
 
  std::filesystem::path current_base_path;
 
  BaseID bid;
 
  std::shared_mutex base_mtx;
};
 
#endif // BASEKEEPER_H