/*
 * Copyright (C) 2005-2008 Patrick Ohly
 */

#include "EvolutionSyncClient.h"
#include "EvolutionSyncSource.h"
#include "SyncEvolutionUtil.h"

#include <posix/base/posixlog.h>

#include <list>
#include <memory>
#include <vector>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <stdexcept>
using namespace std;

#include <boost/algorithm/string/predicate.hpp>
#include <boost/algorithm/string/replace.hpp>
#include <boost/foreach.hpp>

#include <sys/stat.h>
#include <pwd.h>
#include <unistd.h>
#include <dirent.h>
#include <errno.h>

SourceList *EvolutionSyncClient::m_sourceListPtr;

EvolutionSyncClient::EvolutionSyncClient(const string &server,
                                         bool doLogging,
                                         const set<string> &sources) :
    EvolutionSyncConfig(server),
    m_server(server),
    m_sources(sources),
    m_doLogging(doLogging),
    m_syncMode(SYNC_NONE),
    m_quiet(false)
{
}

EvolutionSyncClient::~EvolutionSyncClient()
{
}


// this class owns the logging directory and is responsible
// for redirecting output at the start and end of sync (even
// in case of exceptions thrown!)
class LogDir {
    string m_logdir;         /**< configured backup root dir, empty if none */
    int m_maxlogdirs;        /**< number of backup dirs to preserve, 0 if unlimited */
    string m_prefix;         /**< common prefix of backup dirs */
    string m_path;           /**< path to current logging and backup dir */
    string m_logfile;        /**< path to log file there, empty if not writing one */
    const string &m_server;  /**< name of the server for this synchronization */
    LogLevel m_oldLogLevel;  /**< logging level to restore */
    bool m_restoreLog;       /**< false if nothing needs to be restored because setLogdir() was never called */

public:
    LogDir(const string &server) : m_server(server),
                                   m_restoreLog(false)
    {
        // SyncEvolution-<server>-<yyyy>-<mm>-<dd>-<hh>-<mm>
        m_prefix = "SyncEvolution-";
        m_prefix += m_server;

        // default: $TMPDIR/SyncEvolution-<username>-<server>
        stringstream path;
        char *tmp = getenv("TMPDIR");
        if (tmp) {
            path << tmp;
        } else {
            path << "/tmp";
        }
        path << "/SyncEvolution-";
        struct passwd *user = getpwuid(getuid());
        if (user && user->pw_name) {
            path << user->pw_name;
        } else {
            path << getuid();
        }
        path << "-" << m_server;

        m_path = path.str();
    }

    /**
     * Finds previous log directory. Must be called before setLogdir().
     *
     * @param path        path to configured backup directy, NULL if defaulting to /tmp, "none" if not creating log file
     * @return full path of previous log directory, empty string if not found
     */
    string previousLogdir(const char *path) {
        string logdir;

        if (path && !strcasecmp(path, "none")) {
            return "";
        } else if (path && path[0]) {
            vector<string> entries;
            try {
                getLogdirs(path, entries);
            } catch(const std::exception &ex) {
                LOG.error("%s", ex.what());
                return "";
            }

            logdir = entries.size() ? string(path) + "/" + entries[entries.size()-1] : "";
        } else {
            logdir = m_path;
        }

        if (access(logdir.c_str(), R_OK|X_OK) == 0) {
            return logdir;
        } else {
            return "";
        }
    }

    // setup log directory and redirect logging into it
    // @param path        path to configured backup directy, NULL if defaulting to /tmp, "none" if not creating log file
    // @param maxlogdirs  number of backup dirs to preserve in path, 0 if unlimited
    // @param logLevel    0 = default, 1 = ERROR, 2 = INFO, 3 = DEBUG
    void setLogdir(const char *path, int maxlogdirs, int logLevel = 0) {
        m_maxlogdirs = maxlogdirs;
        if (path && !strcasecmp(path, "none")) {
            m_logfile = "";
        } else if (path && path[0]) {
            m_logdir = path;

            // create unique directory name in the given directory
            time_t ts = time(NULL);
            struct tm *tm = localtime(&ts);
            stringstream base;
            base << path << "/"
                 << m_prefix
                 << "-"
                 << setfill('0')
                 << setw(4) << tm->tm_year + 1900 << "-"
                 << setw(2) << tm->tm_mon + 1 << "-"
                 << setw(2) << tm->tm_mday << "-"
                 << setw(2) << tm->tm_hour << "-"
                 << setw(2) << tm->tm_min;
            int seq = 0;
            while (true) {
                stringstream path;
                path << base.str();
                if (seq) {
                    path << "-" << seq;
                }
                m_path = path.str();
                if (!mkdir(m_path.c_str(), S_IRWXU)) {
                    break;
                }
                if (errno != EEXIST) {
                    LOG.debug("%s: %s", m_path.c_str(), strerror(errno));
                    EvolutionSyncClient::throwError(m_path, errno);
                }
                seq++;
            }
            m_logfile = m_path + "/client.log";
        } else {
            // use the default temp directory
            if (mkdir(m_path.c_str(), S_IRWXU)) {
                if (errno != EEXIST) {
                    EvolutionSyncClient::throwError(m_path, errno);
                }
            }
            m_logfile = m_path + "/client.log";
        }

        if (m_logfile.size()) {
            // redirect logging into that directory, including stderr,
            // after truncating it
            FILE *file = fopen(m_logfile.c_str(), "w");
            if (file) {
                fclose(file);
#ifdef POSIX_LOG
                POSIX_LOG.
#endif
                    setLogFile(NULL, m_logfile.c_str(), true);
            } else {
                LOG.error("creating log file %s failed", m_logfile.c_str());
            }
        }
        m_oldLogLevel = LOG.getLevel();
        LOG.setLevel(logLevel > 0 ? (LogLevel)(logLevel - 1) /* fixed level */ :
                     m_logfile.size() ? LOG_LEVEL_DEBUG /* default for log file */ :
                     LOG_LEVEL_INFO /* default for console output */ );
        m_restoreLog = true;
    }

    /** sets a fixed directory for database files without redirecting logging */
    void setPath(const string &path) { m_path = path; }

    // return log directory, empty if not enabled
    const string &getLogdir() {
        return m_path;
    }

    // return log file, empty if not enabled
    const string &getLogfile() {
        return m_logfile;
    }

    /** find all entries in a given directory, return as sorted array */
    void getLogdirs(const string &logdir, vector<string> &entries) {
        ReadDir dir(logdir);
        BOOST_FOREACH(const string &entry, dir) {
            if (boost::starts_with(entry, m_prefix)) {
                entries.push_back(entry);
            }
        }
        sort(entries.begin(), entries.end());
    }


    // remove oldest backup dirs if exceeding limit
    void expire() {
        if (m_logdir.size() && m_maxlogdirs > 0 ) {
            vector<string> entries;
            getLogdirs(m_logdir, entries);

            int deleted = 0;
            for (vector<string>::iterator it = entries.begin();
                 it != entries.end() && (int)entries.size() - deleted > m_maxlogdirs;
                 ++it, ++deleted) {
                string path = m_logdir + "/" + *it;
                string msg = "removing " + path;
                LOG.info(msg.c_str());
                rm_r(path);
            }
        }
    }

    // remove redirection of stderr and (optionally) also of logging
    void restore(bool all) {
        if (!m_restoreLog) {
            return;
        }
          
        if (all) {
            if (m_logfile.size()) {
#ifdef POSIX_LOG
                POSIX_LOG.
#endif
                    setLogFile(NULL, "-", false);
            }
            LOG.setLevel(m_oldLogLevel);
        } else {
            if (m_logfile.size()) {
#ifdef POSIX_LOG
                POSIX_LOG.
#endif
                    setLogFile(NULL, m_logfile.c_str(), false);
            }
        }
    }

    ~LogDir() {
        restore(true);
    }
};

// this class owns the sync sources and (together with
// a logdir) handles writing of per-sync files as well
// as the final report (
class SourceList : public vector<EvolutionSyncSource *> {
    LogDir m_logdir;     /**< our logging directory */
    bool m_prepared;     /**< remember whether syncPrepare() dumped databases successfully */
    bool m_doLogging;    /**< true iff additional files are to be written during sync */
    SyncClient &m_client; /**< client which holds the sync report after a sync */
    bool m_reportTodo;   /**< true if syncDone() shall print a final report */
    boost::scoped_array<SyncSource *> m_sourceArray;  /** owns the array that is expected by SyncClient::sync() */
    const bool m_quiet;  /**< avoid redundant printing to screen */
    string m_previousLogdir; /**< remember previous log dir before creating the new one */

    /** create name in current (if set) or previous logdir */
    string databaseName(EvolutionSyncSource &source, const string suffix, string logdir = "") {
        if (!logdir.size()) {
            logdir = m_logdir.getLogdir();
        }
        return logdir + "/" +
            source.getName() + "." + suffix + "." +
            source.fileSuffix();
    }

public:
    /**
     * dump into files with a certain suffix
     */
    void dumpDatabases(const string &suffix) {
        ofstream out;
#ifndef IPHONE
        // output stream on iPhone raises exception even though it is in a good state;
        // perhaps the missing C++ exception support is the reason:
        // http://code.google.com/p/iphone-dev/issues/detail?id=48
        out.exceptions(ios_base::badbit|ios_base::failbit|ios_base::eofbit);
#endif

        BOOST_FOREACH(EvolutionSyncSource *source, *this) {
            string file = databaseName(*source, suffix);
            LOG.debug("creating %s", file.c_str());
            out.open(file.c_str());
            source->exportData(out);
            out.close();
            LOG.debug("%s created", file.c_str());
        }
    }

    /** remove database dumps with a specific suffix */
    void removeDatabases(const string &removeSuffix) {
        BOOST_FOREACH(EvolutionSyncSource *source, *this) {
            string file;

            file = databaseName(*source, removeSuffix);
            unlink(file.c_str());
        }
    }
        
    SourceList(const string &server, bool doLogging, SyncClient &client, bool quiet) :
        m_logdir(server),
        m_prepared(false),
        m_doLogging(doLogging),
        m_client(client),
        m_reportTodo(true),
        m_quiet(quiet)
    {
    }
    
    // call as soon as logdir settings are known
    void setLogdir(const char *logDirPath, int maxlogdirs, int logLevel) {
        m_previousLogdir = m_logdir.previousLogdir(logDirPath);
        if (m_doLogging) {
            m_logdir.setLogdir(logDirPath, maxlogdirs, logLevel);
        } else {
            // at least increase log level
            LOG.setLevel(LOG_LEVEL_DEBUG);
        }
    }

    /** return previous log dir found in setLogdir() */
    const string &getPrevLogdir() const { return m_previousLogdir; }

    /** set directory for database files without actually redirecting the logging */
    void setPath(const string &path) { m_logdir.setPath(path); }

    /**
     * If possible (m_previousLogdir found) and enabled (!m_quiet),
     * then dump changes applied locally.
     *
     * @param oldSuffix      suffix of old database dump: usually "after"
     * @param currentSuffix  the current database dump suffix: "current"
     *                       when not doing a sync, otherwise "before"
     */
    bool dumpLocalChanges(const string &oldSuffix, const string &newSuffix) {
        if (m_quiet || !m_previousLogdir.size()) {
            return false;
        }

        cout << "Local changes to be applied to server during synchronization:\n";
        BOOST_FOREACH(EvolutionSyncSource *source, *this) {
            string oldFile = databaseName(*source, oldSuffix, m_previousLogdir);
            string newFile = databaseName(*source, newSuffix);
            cout << "*** " << source->getName() << " ***\n" << flush;
            string cmd = string("env CLIENT_TEST_COMPARISON_FAILED=10 CLIENT_TEST_LEFT_NAME='after last sync' CLIENT_TEST_RIGHT_NAME='current data' CLIENT_TEST_REMOVED='removed since last sync' CLIENT_TEST_ADDED='added since last sync' synccompare 2>/dev/null '" ) +
                oldFile + "' '" + newFile + "'";
            int ret = system(cmd.c_str());
            switch (ret == -1 ? ret : WEXITSTATUS(ret)) {
            case 0:
                cout << "no changes\n";
                break;
            case 10:
                break;
            default:
                cout << "Comparison was impossible.\n";
                break;
            }
        }
        cout << "\n";
        return true;
    }

    // call when all sync sources are ready to dump
    // pre-sync databases
    void syncPrepare() {
        if (m_logdir.getLogfile().size() &&
            m_doLogging) {
            // dump initial databases
            dumpDatabases("before");
            // compare against the old "after" database dump
            dumpLocalChanges("after", "before");
            // now remove the old database dump
            removeDatabases("after");
            m_prepared = true;
        }
    }

    // call at the end of a sync with success == true
    // if all went well to print report
    void syncDone(bool success) {
        if (m_doLogging) {
            // ensure that stderr is seen again
            m_logdir.restore(false);

            if (m_reportTodo) {
                // haven't looked at result of sync yet;
                // don't do it again
                m_reportTodo = false;

                // dump datatbase after sync, but not if already dumping it at the beginning didn't complete
                if (m_prepared) {
                    try {
                        dumpDatabases("after");
                    } catch (const std::exception &ex) {
                        LOG.error( "%s", ex.what() );
                        m_prepared = false;
                    }
                }

                string logfile = m_logdir.getLogfile();
#ifndef LOG_HAVE_SET_LOGGER
                // scan for error messages
                if (!m_quiet && logfile.size()) {
                    ifstream in;
                    in.open(m_logdir.getLogfile().c_str());
                    while (in.good()) {
                        string line;
                        getline(in, line);
                        if (line.find("[ERROR]") != line.npos) {
                            success = false;
                           cout << line << "\n";
                        } else if (line.find("[INFO]") != line.npos) {
                            cout << line << "\n";
                        }
                    }
                    in.close();
                }
#endif

                cout << flush;
                cerr << flush;
                cout << "\n";
                if (success) {
                    cout << "Synchronization successful.\n";
                } else if (logfile.size()) {
                    cout << "Synchronization failed, see "
                         << logfile
                         << " for details.\n";
                } else {
                    cout << "Synchronization failed.\n";
                }

                // pretty-print report
                if (!m_quiet) {
                    cout << "\nChanges applied during synchronization:\n";
                }
                SyncReport *report = m_client.getSyncReport();
                if (!m_quiet && report) {

                    cout << "+-------------------|-------ON CLIENT-------|-------ON SERVER-------|\n";
                    cout << "|                   |   successful / total  |   successful / total  |\n";
                    cout << "|            Source |  NEW  |  MOD  |  DEL  |  NEW  |  MOD  |  DEL  |\n";
                    const char *sep = 
                        "+-------------------+-------+-------+-------+-------+-------+-------+\n";
                    cout << sep;

                    for (unsigned int i = 0; report->getSyncSourceReport(i); i++) {
                        SyncSourceReport* ssr = report->getSyncSourceReport(i);

                        if (ssr->getState() == SOURCE_INACTIVE) {
                            continue;
                        }
                        
                        cout << "|" << right << setw(18) << ssr->getSourceName() << " |";
                        static const char * const targets[] =
                            { CLIENT, SERVER, NULL };
                        for (int target = 0;
                             targets[target];
                             target++) {
                            static const char * const commands[] =
                                { COMMAND_ADD, COMMAND_REPLACE, COMMAND_DELETE, NULL };
                            for (int command = 0;
                                 commands[command];
                                 command++) {
                                cout << right << setw(3) <<
                                    ssr->getItemReportSuccessfulCount(targets[target], commands[command]);
                                cout << "/";
                                cout << left << setw(3) <<
                                    ssr->getItemReportCount(targets[target], commands[command]);
                                cout << "|";
                            }
                        }
                        cout << "\n";
                    }
                    cout << sep;
                }

                // compare databases?
                if (!m_quiet && m_prepared) {
                    cout << "\nChanges applied to client during synchronization:\n";
                    BOOST_FOREACH(EvolutionSyncSource *source, *this) {
                        cout << "*** " << source->getName() << " ***\n" << flush;

                        string before = databaseName(*source, "before");
                        string after = databaseName(*source, "after");
                        string cmd = string("synccompare '" ) +
                            before + "' '" + after +
                            "' && echo 'no changes'";
                        system(cmd.c_str());
                    }
                    cout << "\n";
                }

                if (success) {
                    m_logdir.expire();
                }
            }
        }
    }

    /** returns current sources as array as expected by SyncClient::sync(), memory owned by this class */
    SyncSource **getSourceArray() {
        m_sourceArray.reset(new SyncSource *[size() + 1]);

        int index = 0;
        BOOST_FOREACH(EvolutionSyncSource *source, *this) {
            m_sourceArray[index] = source;
            index++;
        }
        m_sourceArray[index] = 0;
        return &m_sourceArray[0];
    }

    /** returns names of active sources */
    set<string> getSources() {
        set<string> res;

        BOOST_FOREACH(EvolutionSyncSource *source, *this) {
            res.insert(source->getName());
        }
        return res;
    }
   
    ~SourceList() {
        // free sync sources
        BOOST_FOREACH(EvolutionSyncSource *source, *this) {
            delete source;
        }
    }

    /** find sync source by name */
    EvolutionSyncSource *operator [] (const string &name) {
        BOOST_FOREACH(EvolutionSyncSource *source, *this) {
            if (name == source->getName()) {
                return source;
            }
        }
        return NULL;
    }

    /** find by index */
    EvolutionSyncSource *operator [] (int index) { return vector<EvolutionSyncSource *>::operator [] (index); }
};

void unref(SourceList *sourceList)
{
    delete sourceList;
}

string EvolutionSyncClient::askPassword(const string &descr)
{
    char buffer[256];

    printf("Enter password for %s: ",
           descr.c_str());
    fflush(stdout);
    if (fgets(buffer, sizeof(buffer), stdin) &&
        strcmp(buffer, "\n")) {
        size_t len = strlen(buffer);
        if (len && buffer[len - 1] == '\n') {
            buffer[len - 1] = 0;
        }
        return buffer;
    } else {
        throwError(string("could not read password for ") + descr);
        return "";
    }
}

void EvolutionSyncClient::throwError(const string &error)
{
#ifdef IPHONE
    /*
     * Catching the runtime_exception fails due to a toolchain problem,
     * so do the error handling now and abort: because there is just
     * one sync source this is probably the only thing that can be done.
     * Still, it's not nice on the server...
     */
    fatalError(NULL, error.c_str());
#else
    throw runtime_error(error);
#endif
}

void EvolutionSyncClient::throwError(const string &action, int error)
{
    throwError(action + ": " + strerror(error));
}

void EvolutionSyncClient::fatalError(void *object, const char *error)
{
    LOG.error("%s", error);
    if (m_sourceListPtr) {
        m_sourceListPtr->syncDone(false);
    }
    exit(1);
}

/*
 * There have been segfaults inside glib in the background
 * thread which ran the second event loop. Disabled it again,
 * even though the synchronous EDS API calls will block then
 * when EDS dies.
 */
#if 0 && defined(HAVE_GLIB) && defined(HAVE_EDS)
# define RUN_GLIB_LOOP
#endif

#ifdef RUN_GLIB_LOOP
#include <pthread.h>
#include <signal.h>
static void *mainLoopThread(void *)
{
    // The test framework uses SIGALRM for timeouts.
    // Block the signal here because a) the signal handler
    // prints a stack back trace when called and we are not
    // interessted in the background thread's stack and b)
    // it seems to have confused glib/libebook enough to
    // access invalid memory and segfault when it gets the SIGALRM.
    sigset_t blocked;
    sigemptyset(&blocked);
    sigaddset(&blocked, SIGALRM);
    pthread_sigmask(SIG_BLOCK, &blocked, NULL);

    GMainLoop *mainloop = g_main_loop_new(NULL, TRUE);
    if (mainloop) {
        g_main_loop_run(mainloop);
        g_main_loop_unref(mainloop);
    }
    return NULL;
}
#endif

void EvolutionSyncClient::startLoopThread()
{
#ifdef RUN_GLIB_LOOP
    // when using Evolution we must have a running main loop,
    // otherwise loss of connection won't be reported to us
    static pthread_t loopthread;
    static bool loopthreadrunning;
    if (!loopthreadrunning) {
        loopthreadrunning = !pthread_create(&loopthread, NULL, mainLoopThread, NULL);
    }
#endif
}

AbstractSyncSourceConfig* EvolutionSyncClient::getAbstractSyncSourceConfig(const char* name) const
{
    return m_sourceListPtr ? (*m_sourceListPtr)[name] : NULL;
}

AbstractSyncSourceConfig* EvolutionSyncClient::getAbstractSyncSourceConfig(unsigned int i) const
{
    return m_sourceListPtr ? (*m_sourceListPtr)[i] : NULL;
}

unsigned int EvolutionSyncClient::getAbstractSyncSourceConfigsCount() const
{
    return m_sourceListPtr ? m_sourceListPtr->size() : 0;
}

void EvolutionSyncClient::setConfigFilter(bool sync, const FilterConfigNode::ConfigFilter &filter)
{
    map<string, string>::const_iterator hasSync = filter.find(EvolutionSyncSourceConfig::m_sourcePropSync.getName());

    if (!sync && hasSync != filter.end()) {
        m_overrideMode = hasSync->second;
        FilterConfigNode::ConfigFilter strippedFilter = filter;
        strippedFilter.erase(EvolutionSyncSourceConfig::m_sourcePropSync.getName());
        EvolutionSyncConfig::setConfigFilter(sync, strippedFilter);
    } else {
        EvolutionSyncConfig::setConfigFilter(sync, filter);
    }
}

void EvolutionSyncClient::initSources(SourceList &sourceList)
{
    set<string> unmatchedSources = m_sources;
    list<string> configuredSources = getSyncSources();
    BOOST_FOREACH(const string &name, configuredSources) {
        boost::shared_ptr<PersistentEvolutionSyncSourceConfig> sc(getSyncSourceConfig(name));
        
        // is the source enabled?
        string sync = sc->getSync();
        bool enabled = sync != "disabled";
        string overrideMode = m_overrideMode;

        // override state?
        if (m_sources.size()) {
            if (m_sources.find(sc->getName()) != m_sources.end()) {
                if (!enabled) {
                    if (overrideMode.empty()) {
                        overrideMode = "two-way";
                    }
                    enabled = true;
                }
                unmatchedSources.erase(sc->getName());
            } else {
                enabled = false;
            }
        }
        
        if (enabled) {
            string url = getSyncURL();
            boost::replace_first(url, "https://", "http://"); // do not distinguish between protocol in change tracking
            string changeId = string("sync4jevolution:") + url + "/" + name;
            EvolutionSyncSourceParams params(name,
                                             getSyncSourceNodes(name),
                                             changeId);
            // the sync mode has to be set before instantiating the source
            // because the client library reads the preferredSyncMode at that time
            if (!overrideMode.empty()) {
                params.m_nodes.m_configNode->addFilter(EvolutionSyncSourceConfig::m_sourcePropSync.getName(),
                                                       overrideMode);
            }
            EvolutionSyncSource *syncSource =
                EvolutionSyncSource::createSource(params);
            if (!syncSource) {
                throwError(name + ": type unknown" );
            }
            sourceList.push_back(syncSource);
        }
    }

    // check whether there were any sources specified which do not exist
    if (unmatchedSources.size()) {
        throwError(string("no such source(s): ") + boost::join(unmatchedSources, " "));
    }
}

int EvolutionSyncClient::sync()
{
    int res = 1;
    
    if (!exists()) {
        LOG.error("No configuration for server \"%s\" found.", m_server.c_str());
        throwError("cannot proceed without configuration");
    }

    // redirect logging as soon as possible
    SourceList sourceList(m_server, m_doLogging, *this, m_quiet);
    m_sourceListPtr = &sourceList;

    try {
        sourceList.setLogdir(getLogDir(),
                             getMaxLogDirs(),
                             getLogLevel());

        // dump some summary information at the beginning of the log
#ifdef LOG_HAVE_DEVELOPER
# define LOG_DEVELOPER developer
#else
# define LOG_DEVELOPER debug
#endif
        LOG.LOG_DEVELOPER("SyncML server account: %s", getUsername());
        LOG.LOG_DEVELOPER("client: SyncEvolution %s for %s",
                          getSwv(), getDevType());
        LOG.LOG_DEVELOPER("device ID: %s", getDevID());
        LOG.LOG_DEVELOPER("%s", EDSAbiWrapperDebug());

        // instantiate backends, but do not open them yet
        initSources(sourceList);

        // request all config properties once: throwing exceptions
        // now is okay, whereas later it would lead to leaks in the
        // not exception safe client library
        EvolutionSyncConfig dummy;
        set<string> activeSources = sourceList.getSources();
        dummy.copy(*this, &activeSources);

        // start background thread if not running yet:
        // necessary to catch problems with Evolution backend
        startLoopThread();

        // ask for passwords now
        checkPassword(*this);
        if (getUseProxy()) {
            checkProxyPassword(*this);
        }
        BOOST_FOREACH(EvolutionSyncSource *source, sourceList) {
            source->checkPassword(*this);
        }

        // open each source - failing now is still safe
        BOOST_FOREACH(EvolutionSyncSource *source, sourceList) {
            source->open();
        }

        // give derived class also a chance to update the configs
        prepare(sourceList.getSourceArray());

        // ready to go: dump initial databases and prepare for final report
        sourceList.syncPrepare();

        // do it
        res = SyncClient::sync(*this, sourceList.getSourceArray());

        // store modified properties: must be done even after failed
        // sync because the source's anchor might have been reset
        flush();

        if (res) {
            if (getLastErrorCode() && getLastErrorMsg() && getLastErrorMsg()[0]) {
                throwError(getLastErrorMsg());
            }
            // no error code/description?!
            throwError("sync failed without an error description, check log");
        }

        // all went well: print final report before cleaning up
        sourceList.syncDone(true);

        res = 0;
    } catch (const std::exception &ex) {
        LOG.error( "%s", ex.what() );

        // something went wrong, but try to write .after state anyway
        m_sourceListPtr = NULL;
        sourceList.syncDone(false);
    } catch (...) {
        LOG.error( "unknown error" );
        m_sourceListPtr = NULL;
        sourceList.syncDone(false);
    }

    m_sourceListPtr = NULL;
    return res;
}

void EvolutionSyncClient::prepare(SyncSource **sources) {
    if (m_syncMode != SYNC_NONE) {
        for (SyncSource **source = sources;
             *source;
             source++) {
            (*source)->setPreferredSyncMode(m_syncMode);
        }
    }
}

void EvolutionSyncClient::status()
{
    EvolutionSyncConfig config(m_server);
    if (!exists()) {
        LOG.error("No configuration for server \"%s\" found.", m_server.c_str());
        throwError("cannot proceed without configuration");
    }

    SourceList sourceList(m_server, false, *this, false);
    initSources(sourceList);
    BOOST_FOREACH(EvolutionSyncSource *source, sourceList) {
        source->checkPassword(*this);
    }
    BOOST_FOREACH(EvolutionSyncSource *source, sourceList) {
        source->open();
    }

    sourceList.setLogdir(getLogDir(), 0, LOG_LEVEL_NONE);
    LOG.setLevel(LOG_LEVEL_INFO);
    string prevLogdir = sourceList.getPrevLogdir();
    bool found = access(prevLogdir.c_str(), R_OK|X_OK) == 0;

    if (found) {
        try {
            sourceList.setPath(prevLogdir);
            sourceList.dumpDatabases("current");
            sourceList.dumpLocalChanges("after", "current");
        } catch(const std::exception &ex) {
            LOG.error("%s", ex.what());
        }
    } else {
        cerr << "Previous log directory not found.\n";
        if (!getLogDir() || !getLogDir()[0]) {
            cerr << "Enable the 'logdir' option and synchronize to use this feature.\n";
        }
    }
}