CreateCollection.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 CREATECOLLECTION_H
#define CREATECOLLECTION_H
 
#include <ArchiveParser.h>
#include <BaseID.h>
#include <MLBookProc.h>
#include <UDBase.h>
#include <atomic>
#include <condition_variable>
#include <filesystem>
#include <functional>
#include <mutex>
#include <tuple>
#include <vector>

class CreateCollection
{
public:
  CreateCollection(const std::shared_ptr<MLBookProc> &mlbp,
                   const int &threads_num = int(1));
 
  virtual ~CreateCollection();

  void
  createCollection(const std::vector<std::filesystem::path> &files_and_dirs,
                   const std::filesystem::path &base_path);

  void
  createInpxCollection(const std::filesystem::path &path_to_inpx,
                       const std::filesystem::path &base_path);

  virtual void
  stopAll();

  static void
  saveBase(const std::filesystem::path &base_path, UDBase &col_base);

  std::function<void(const size_t &files_found)> signal_files_collecting;

  std::function<void(double processed, double total)> signal_parsing_progress;
 
protected:
  void
  filesCollecting(const std::vector<std::filesystem::path> &files_and_dirs,
                  UDBase &col_base);

  size_t
  countFiles(const std::vector<UDBElement> &el_v);

  std::vector<std::tuple<const std::vector<UDBElement> *,
                         std::vector<UDBElement>::const_iterator>>
  getAllFiles(const std::vector<UDBElement> &el_v);

  void
  removeDublicates(
      std::vector<std::tuple<const std::vector<UDBElement> *,
                             std::vector<UDBElement>::const_iterator>> &files);

  void
  processFiles(const std::vector<UDBElement> &items);

  void
  fileParsing(UDBElement *file);

  void
  cleanBase(std::vector<UDBElement> &items);  

  void
  fb2Parsing(UDBElement *file, const std::filesystem::path &file_path);

  void
  epubParsing(UDBElement *file, const std::filesystem::path &file_path);

  void
  pdfParsing(UDBElement *file, const std::filesystem::path &file_path);

  void
  djvuParsing(UDBElement *file, const std::filesystem::path &file_path);

  void
  odtParsing(UDBElement *file, const std::filesystem::path &file_path);

  void
  txtParsing(UDBElement *file, const std::filesystem::path &file_path);

  void
  docParsing(UDBElement *file, const std::filesystem::path &file_path);

  void
  rtfParsing(UDBElement *file, const std::filesystem::path &file_path);

  void
  docxParsing(UDBElement *file, const std::filesystem::path &file_path);

  void
  mobiParsing(UDBElement *file, const std::filesystem::path &file_path);

  void
  archiveParsing(UDBElement *file, const std::filesystem::path &file_path);

  std::string
  bufferHash(const std::string &buf);

  std::string
  fileHash(const std::filesystem::path &file_path);

  void
  bufHash(UDBElement *file, const std::filesystem::path &file_path,
          const std::string &buf);

  std::shared_ptr<MLBookProc> mlbp;

  std::shared_ptr<std::vector<std::tuple<unsigned, bool>>> threads_v;

  std::shared_ptr<std::mutex> threads_v_mtx;

  std::shared_ptr<std::condition_variable> threads_v_var;

  std::atomic<bool> cancel;

  std::vector<std::shared_ptr<ArchiveParser>> arch_proc;

  std::mutex arch_proc_mtx;

  std::vector<std::tuple<std::filesystem::path, std::string>> already_hashed;

  BaseID bid;

  std::atomic<double> processed;

  double total;
};
 
#endif // CREATECOLLECTION_H