#ifndef SYNCJOURNALDB_H

#define SYNCJOURNALDB_H

#include <QObject>

#include <qmutex.h>

#include <QDateTime>

#include <QHash>

#include <functional>

#include "common/utility.h"

#include "common/ownsql.h"

#include "common/preparedsqlquerymanager.h"

#include "common/syncjournalfilerecord.h"

#include "common/result.h"

#include "common/pinstate.h"

namespace OCC {

class SyncJournalFileRecord;

class OCSYNC_EXPORT SyncJournalDb : public QObject

{

Q_OBJECT

explicit SyncJournalDb(const QString &dbFilePath, QObject *parent = nullptr);

~SyncJournalDb() override;

/// Create a journal path for a specific configuration

static QString makeDbName(const QString &localPath,

const QString &infix = QStringLiteral("journal"));

/// Migrate a csync_journal to the new path, if necessary. Returns false on error

static bool maybeMigrateDb(const QString &localPath, const QString &absoluteJournalPath);

// To verify that the record could be found check with SyncJournalFileRecord::isValid()

bool getFileRecord(const QString &filename, SyncJournalFileRecord *rec) { return getFileRecord(filename.toUtf8(), rec); }

bool getFileRecord(const QByteArray &filename, SyncJournalFileRecord *rec);

bool getFileRecordByInode(quint64 inode, SyncJournalFileRecord *rec);

bool getFileRecordsByFileId(const QByteArray &fileId, const std::function<void(const SyncJournalFileRecord &)> &rowCallback);

bool getFilesBelowPath(const QByteArray &path, const std::function<void(const SyncJournalFileRecord&)> &rowCallback);

bool listFilesInPath(const QByteArray &path, const std::function<void(const SyncJournalFileRecord&)> &rowCallback);

Result<void, QString> setFileRecord(const SyncJournalFileRecord &record);

bool deleteFileRecord(const QString &filename, bool recursively = false);

bool updateFileRecordChecksum(const QString &filename,

const QByteArray &contentChecksum,

const QByteArray &contentChecksumType);

/// Return value for hasHydratedOrDehydratedFiles()

struct HasHydratedDehydrated

};

/** Returns whether the item or any subitems are dehydrated */

Optional<HasHydratedDehydrated> hasHydratedOrDehydratedFiles(const QByteArray &filename);

bool exists();

void walCheckpoint();

QString databaseFilePath() const;

static qint64 getPHash(const QByteArray &);

void setErrorBlacklistEntry(const SyncJournalErrorBlacklistRecord &item);

void wipeErrorBlacklistEntry(const QString &file);

void wipeErrorBlacklistCategory(SyncJournalErrorBlacklistRecord::Category category);

int wipeErrorBlacklist();

int errorBlackListEntryCount();

struct DownloadInfo

};

struct UploadInfo

};

DownloadInfo getDownloadInfo(const QString &file);

void setDownloadInfo(const QString &file, const DownloadInfo &i);

QVector<DownloadInfo> getAndDeleteStaleDownloadInfos(const QSet<QString> &keep);

int downloadInfoCount();

UploadInfo getUploadInfo(const QString &file);

void setUploadInfo(const QString &file, const UploadInfo &i);

// Return the list of transfer ids that were removed.

QVector<uint> deleteStaleUploadInfos(const QSet<QString> &keep);

SyncJournalErrorBlacklistRecord errorBlacklistEntry(const QString &);

bool deleteStaleErrorBlacklistEntries(const QSet<QString> &keep);

/// Delete flags table entries that have no metadata correspondent

void deleteStaleFlagsEntries();

void avoidRenamesOnNextSync(const QString &path) { avoidRenamesOnNextSync(path.toUtf8()); }

void avoidRenamesOnNextSync(const QByteArray &path);

enum SelectiveSyncListType {

};

/* return the specified list from the database */

QStringList getSelectiveSyncList(SelectiveSyncListType type, bool *ok);

/* Write the selective sync list (remove all other entries of that list */

void setSelectiveSyncList(SelectiveSyncListType type, const QStringList &list);

/**

void schedulePathForRemoteDiscovery(const QString &fileName) { schedulePathForRemoteDiscovery(fileName.toUtf8()); }

void schedulePathForRemoteDiscovery(const QByteArray &fileName);

/**

void clearEtagStorageFilter();

/**

void forceRemoteDiscoveryNextSync();

/* Because sqlite transactions are really slow, we encapsulate everything in big transactions

void commit(const QString &context, bool startTrans = true);

void commitIfNeededAndStartNewTransaction(const QString &context);

/** Open the db if it isn't already.

bool open();

/** Returns whether the db is currently openend. */

bool isOpen();

/** Close the database */

void close();

/**

QByteArray getChecksumType(int checksumTypeId);

/**

void setDataFingerprint(const QByteArray &dataFingerprint);

QByteArray dataFingerprint();

// Conflict record functions

/// Store a new or updated record in the database

void setConflictRecord(const ConflictRecord &record);

/// Retrieve a conflict record by path of the file with the conflict tag

ConflictRecord conflictRecord(const QByteArray &path);

/// Delete a conflict record by path of the file with the conflict tag

void deleteConflictRecord(const QByteArray &path);

/// Return all paths of files with a conflict tag in the name and records in the db

QByteArrayList conflictRecordPaths();

/** Find the base name for a conflict file name, using journal or name pattern

QByteArray conflictFileBaseName(const QByteArray &conflictName);

/**

void clearFileTable();

/**

void markVirtualFileForDownloadRecursively(const QByteArray &path);

/** Grouping for all functions relating to pin states,

struct OCSYNC_EXPORT PinStateInterface

{

PinStateInterface(const PinStateInterface &) = delete;

PinStateInterface(PinStateInterface &&) = delete;

/**

Optional<PinState> rawForPath(const QByteArray &path);

/**

Optional<PinState> effectiveForPath(const QByteArray &path);

/**

Optional<PinState> effectiveForPathRecursive(const QByteArray &path);

/**

void setForPath(const QByteArray &path, PinState state);

/**

void wipeForPathAndBelow(const QByteArray &path);

/**

Optional<QVector<QPair<QByteArray, PinState>>> rawList();

SyncJournalDb *_db;

};

friend struct PinStateInterface;

/** Access to PinStates stored in the database.

PinStateInterface internalPinStates();

/**

int autotestFailCounter = -1;

int getFileRecordCount();

bool updateDatabaseStructure();

bool updateMetadataTableStructure();

bool updateErrorBlacklistTableStructure();

bool sqlFail(const QString &log, const SqlQuery &query);

void commitInternal(const QString &context, bool startTrans = true);

void startTransaction();

void commitTransaction();

QVector<QByteArray> tableColumns(const QByteArray &table);

bool checkConnect();

// Same as forceRemoteDiscoveryNextSync but without acquiring the lock

void forceRemoteDiscoveryNextSyncLocked();

// Returns the integer id of the checksum type

//

// Returns 0 on failure and for empty checksum types.

int mapChecksumType(const QByteArray &checksumType);

SqlDatabase _db;

QString _dbFile;

QMutex _mutex; // Public functions are protected with the mutex.

QMap<QByteArray, int> _checksymTypeCache;

int _transaction;

bool _metadataTableIsEmpty;

/* Storing etags to these folders, or their parent folders, is filtered out.

QList<QByteArray> _etagStorageFilter;

/** The journal mode to use for the db.

QByteArray _journalMode;

PreparedSqlQueryManager _queryManager;

};

bool OCSYNC_EXPORT

operator==(const SyncJournalDb::DownloadInfo &lhs,

const SyncJournalDb::DownloadInfo &rhs);

bool OCSYNC_EXPORT

operator==(const SyncJournalDb::UploadInfo &lhs,

const SyncJournalDb::UploadInfo &rhs);

} // namespace OCC

#endif // SYNCJOURNALDB_H