#ifndef MEGA_SYNC_H

#define MEGA_SYNC_H 1

#ifdef ENABLE_SYNC

#include "megaclient.h"

namespace mega {

int computeReversePathMatchScore(string& accumulated, const LocalPath& path1, const LocalPath& path2, const FileSystemAccess&);

bool assignFilesystemIds(Sync& sync, MegaApp& app, FileSystemAccess& fsaccess, handlelocalnode_map& fsidnodes,

LocalPath& localdebris);

class MEGA_API SyncConfigBag

{

SyncConfigBag(DbAccess& dbaccess, FileSystemAccess& fsaccess, PrnGen& rng, const std::string& id);

MEGA_DISABLE_COPY_MOVE(SyncConfigBag)

// Adds a new sync config or updates if exists already

void insert(const SyncConfig& syncConfig);

// Removes a sync config at the given local path

void remove(const std::string& localPath);

// Returns the sync config at the given local path

const SyncConfig* get(const std::string& localPath) const;

// Removes all sync configs

void clear();

// Returns all current sync configs

std::vector<SyncConfig> all() const;

std::unique_ptr<DbTable> mTable; // table for caching the sync configs

std::map<std::string, SyncConfig> mSyncConfigs; // map of local paths to sync configs

};

class MEGA_API Sync

{

// returns the sync config

const SyncConfig& getConfig() const;

// sets whether this sync is resumable (default is true)

void setResumable(bool isResumable);

void* appData = nullptr;

MegaClient* client = nullptr;

// sync-wide directory notification provider

std::unique_ptr<DirNotify> dirnotify;

// root of local filesystem tree, holding the sync's root folder. Never null except briefly in the destructor (to ensure efficient db usage)

unique_ptr<LocalNode> localroot;

FileSystemType mFilesystemType = FS_UNKNOWN;

// Path used to normalize sync locaroot name when using prefix /System/Volumes/Data needed by fsevents, due to notification paths

// are served with such prefix from macOS catalina +

#ifdef __APPLE__

string mFsEventsPath;

#endif

// current state

syncstate_t state = SYNC_INITIALSCAN;

// are we conducting a full tree scan? (during initialization and if event notification failed)

bool fullscan = true;

// syncing to an inbound share?

bool inshare = false;

// deletion queue

set<uint32_t> deleteq;

// insertion/update queue

localnode_set insertq;

// adds an entry to the delete queue - removes it from insertq

void statecachedel(LocalNode*);

// adds an entry to the insert queue - removes it from deleteq

void statecacheadd(LocalNode*);

// recursively add children

void addstatecachechildren(uint32_t, idlocalnode_map*, LocalPath&, LocalNode*, int);

// Caches all synchronized LocalNode

void cachenodes();

// change state, signal to application

void changestate(syncstate_t);

// skip duplicates and self-caused

bool checkValidNotification(int q, Notification& notification);

// process and remove one directory notification queue item from *notify

dstime procscanq(int);

// recursively look for vanished child nodes and delete them

void deletemissing(LocalNode*);

// scan specific path

LocalNode* checkpath(LocalNode*, LocalPath*, string* const, dstime*, bool wejustcreatedthisfolder, DirAccess* iteratingDir);

m_off_t localbytes = 0;

unsigned localnodes[2]{};

// look up LocalNode relative to localroot

LocalNode* localnodebypath(LocalNode*, const LocalPath&, LocalNode** = NULL, string* = NULL);

// Assigns fs IDs to those local nodes that match the fingerprint retrieved from disk.

// The fs IDs of unmatched nodes are invalidated.

bool assignfsids();

// scan items in specified path and add as children of the specified

// LocalNode

bool scan(LocalPath*, FileAccess*);

// own position in session sync list

sync_list::iterator sync_it{};

// rescan sequence number (incremented when a full rescan or a new

// notification batch starts)

int scanseqno = 0;

// notified nodes originating from this sync bear this tag

int tag = 0;

// debris path component relative to the base path

string debris;

LocalPath localdebris;

// permanent lock on the debris/tmp folder

std::unique_ptr<FileAccess> tmpfa;

// state cache table

DbTable* statecachetable = nullptr;

// move file or folder to localdebris

bool movetolocaldebris(LocalPath& localpath);

// original filesystem fingerprint

fsfp_t fsfp = 0;

// does the filesystem have stable IDs? (FAT does not)

bool fsstableids = false;

// Error that causes a cancellation

error errorcode = API_OK;

// true if the sync hasn't loaded cached LocalNodes yet

bool initializing = true;

// true if the local synced folder is a network folder

bool isnetwork = false;

// values related to possible files being updated

m_off_t updatedfilesize = ~0;

m_time_t updatedfilets = 0;

m_time_t updatedfileinitialts = 0;

// flag to optimize destruction by skipping calls to treestate()

bool mDestructorRunning = false;

Sync(MegaClient*, SyncConfig, const char*, string*, Node*, bool, int, void*);

~Sync();

static const int SCANNING_DELAY_DS;

static const int EXTRA_SCANNING_DELAY_DS;

static const int FILE_UPDATE_DELAY_DS;

static const int FILE_UPDATE_MAX_DELAY_SECS;

static const dstime RECENT_VERSION_INTERVAL_SECS;

protected :

bool readstatecache();

std::string mLocalPath;

};

} // namespace

#endif

#endif