* ====================================================================

* Copyright (c) 2004-2009 TMate Software Ltd.  All rights reserved.

*

* This software is licensed as described in the file COPYING, which

* you should have received as part of this distribution.  The terms

* are also available at http://svnkit.com/license.html

* If newer versions of this license are posted there, you may use a

* newer version instead, at your option.

* ====================================================================

*/

* @author TMate Software Ltd.

* @version 1.3

*/

    private static int ourInstanceCount;

    private String myConfigDir;

    private PromptUserPassword myPrompt;

    private String myUserName;

    private String myPassword;

    private ISVNEventHandler mySVNEventListener;

    private ISVNConflictHandler mySVNConflictHandler;

    /**

     * @deprecated

     */

    private Notify myNotify;

    private Notify2 myNotify2;

    private ConflictResolverCallback myConflictResolverCallback;

    private CommitMessage myMessageHandler;

    private DefaultSVNOptions myOptions;

    private boolean myCancelOperation = false;

    private SVNClientManager myClientManager;

    private SVNClientInterface myOwner;

    private JavaHLCompositeLog myDebugLog;

    private JavaHLProgressLog myProgressListener;

    private ISVNAuthenticationManager myAuthenticationManager;

    private ISVNAuthenticationStorage myAuthStorage;

    private static ISVNAuthenticationStorage ourAuthStorage;

    /**

     * @author TMate Software Ltd.

     * @version 1.3

     */

    public static final class LogLevel implements SVNClientLogLevel {

    }

    public static SVNClientImpl newInstance() {

        return newInstance(null);

    }

    public static SVNClientImpl newInstance(SVNClient owner) {

        return newInstance(owner, null, null);

    }

    public static SVNClientImpl newInstance(SVNClient owner,

                                            IHTTPConnectionFactory httpConnectionFactory, ISVNConnectorFactory svnConnectorFactory) {

        return newInstance(owner, httpConnectionFactory, svnConnectorFactory, true);

    }

    public static SVNClientImpl newInstance(SVNClient owner,

                                            IHTTPConnectionFactory httpConnectionFactory, ISVNConnectorFactory svnConnectorFactory, boolean trackClient) {

        SVNClientImpl client = new SVNClientImpl(owner, httpConnectionFactory, svnConnectorFactory);

        if (trackClient) {

            SVNClientImplTracker.registerClient(client);

        }

        return client;

    }

    protected SVNClientImpl(SVNClient owner) {

        this(owner, null, null);

    }

    protected SVNClientImpl(SVNClient owner, IHTTPConnectionFactory httpConnectionFactory, ISVNConnectorFactory svnConnectorFactory) {

        DAVRepositoryFactory.setup(httpConnectionFactory);

        SVNRepositoryFactoryImpl.setup(svnConnectorFactory);

        FSRepositoryFactory.setup();

        myConfigDir = SVNWCUtil.getDefaultConfigurationDirectory().getAbsolutePath();

        myOwner = owner == null ? (SVNClientInterface) this : (SVNClientInterface) owner;

        synchronized (SVNClientImpl.class) {

            ourInstanceCount++;

        }

    }

    public static ISVNAuthenticationStorage getRuntimeCredentialsStorage() {

        synchronized (SVNClientImpl.class) {

            if (ourAuthStorage == null) {

                ourAuthStorage = new JavaHLAuthenticationStorage();

            }

            return ourAuthStorage;

        }

    }

    public static void setRuntimeCredentialsStorage(ISVNAuthenticationStorage storage) {

        synchronized (SVNClientImpl.class) {

            ourAuthStorage = storage == null ? new JavaHLAuthenticationStorage() : storage;

        }

    }

    public ISVNAuthenticationStorage getClientCredentialsStorage() {

        if (myAuthStorage != null) {

            return myAuthStorage;

        }

        return getRuntimeCredentialsStorage();

    }

    public void setClientCredentialsStorage(ISVNAuthenticationStorage storage) {

        myAuthStorage = storage;

        updateClientManager();

    }

    public ISVNDebugLog getDebugLog() {

        if (myDebugLog == null) {

            myDebugLog = new JavaHLCompositeLog();

            myDebugLog.addLogger(SVNDebugLog.getDefaultLog());

            myDebugLog.addLogger(JavaHLDebugLog.getInstance());

        }

        return myDebugLog;

    }

    public String getLastPath() {

        return null;

    }

    public Status[] status(String path, boolean descend, boolean onServer, boolean getAll) throws ClientException {

        return status(path, descend, onServer, getAll, false);

    }

    public Status[] status(String path, boolean descend, boolean onServer, boolean getAll, boolean noIgnore) throws ClientException {

        return status(path, descend, onServer, getAll, noIgnore, false);

    }

    public Status[] status(final String path, boolean descend, boolean onServer, boolean getAll,

            boolean noIgnore, boolean ignoreExternals) throws ClientException {

        if (path == null) {

            return null;

        }

        final Collection statuses = new ArrayList();

        status(path, JavaHLObjectFactory.unknownOrImmediates(descend), onServer, getAll, noIgnore,

                ignoreExternals, null, new ISVNStatusHandler() {

            public void handleStatus(SVNStatus status) {

                statuses.add(JavaHLObjectFactory.createStatus(status.getFile().getPath(), status));

            }

        });

        return (Status[]) statuses.toArray(new Status[statuses.size()]);

    }

    public void status(String path, int depth, boolean onServer, boolean getAll, boolean noIgnore,

            boolean ignoreExternals, String[] changelists, StatusCallback callback) throws ClientException {

        final StatusCallback statusCallback = callback;

        status(path, depth, onServer, getAll, noIgnore, ignoreExternals, changelists, new ISVNStatusHandler() {

            public void handleStatus(SVNStatus status) {

                if (statusCallback != null) {

                    statusCallback.doStatus(JavaHLObjectFactory.createStatus(status.getFile().getPath(), status));

                }

            }

        });

    }

    private void status(String path, int depth, boolean onServer, boolean getAll, boolean noIgnore,

            boolean ignoreExternals, String[] changelists, ISVNStatusHandler handler) throws ClientException {

        if (path == null) {

            return;

        }

        SVNStatusClient stClient = getSVNStatusClient();

        boolean oldIgnoreExternals = stClient.isIgnoreExternals();

        stClient.setIgnoreExternals(ignoreExternals);

        try {

            stClient.doStatus(new File(path).getAbsoluteFile(), SVNRevision.HEAD,

                    JavaHLObjectFactory.getSVNDepth(depth), onServer, getAll, noIgnore,

                    !ignoreExternals, handler, JavaHLObjectFactory.getChangeListsCollection(changelists));

        } catch (SVNException e) {

            throwException(e);

        } finally {

            stClient.setIgnoreExternals(oldIgnoreExternals);

            resetLog();

        }

    }

    public Status singleStatus(final String path, boolean onServer) throws ClientException {

        Status[] result = status(path, false, onServer, true, false, false);

        if (result != null && result.length > 0){

            return result[0];

        }

        return null;       

    }

    public DirEntry[] list(String url, Revision revision, boolean recurse) throws ClientException {

        return list(url, revision, revision, recurse);

    }

    public DirEntry[] list(String url, Revision revision, Revision pegRevision, boolean recurse) throws ClientException {

        final Collection allEntries = new ArrayList();

        list(url, revision, pegRevision, JavaHLObjectFactory.infinityOrImmediates(recurse), SVNDirEntry.DIRENT_ALL, false, new ISVNDirEntryHandler() {

            public void handleDirEntry(SVNDirEntry dirEntry) {

                if (dirEntry.getRelativePath().length() != 0) {

                    allEntries.add(JavaHLObjectFactory.createDirEntry(dirEntry));

                }

            }

        });

        return (DirEntry[]) allEntries.toArray(new DirEntry[allEntries.size()]);

    }

    public void list(String url, Revision revision, Revision pegRevision, int depth, int direntFields, boolean fetchLocks, ListCallback callback) throws ClientException {

        final ListCallback listCallback = callback;

        list(url, revision, pegRevision, depth, direntFields, fetchLocks, new ISVNDirEntryHandler() {

            public void handleDirEntry(SVNDirEntry dirEntry) {

                if (listCallback != null) {

                    listCallback.doEntry(JavaHLObjectFactory.createDirEntry(dirEntry), JavaHLObjectFactory.createLock(dirEntry.getLock()));

                }

            }

        });

    }

    private void list(String url, Revision revision, Revision pegRevision, int depth, int direntFields, boolean fetchLocks, ISVNDirEntryHandler handler) throws ClientException {

        SVNLogClient client = getSVNLogClient();

        try {

            if (isURL(url)) {

                client.doList(SVNURL.parseURIEncoded(url),

                        JavaHLObjectFactory.getSVNRevision(pegRevision),

                        JavaHLObjectFactory.getSVNRevision(revision),

                        fetchLocks,

                        JavaHLObjectFactory.getSVNDepth(depth),

                        direntFields, handler);

            } else {

                client.doList(new File(url).getAbsoluteFile(),

                        JavaHLObjectFactory.getSVNRevision(pegRevision),

                        JavaHLObjectFactory.getSVNRevision(revision),

                        fetchLocks,

                        JavaHLObjectFactory.getSVNDepth(depth),

                        direntFields, handler);

            }

        } catch (SVNException e) {

            throwException(e);

        } finally {

            resetLog();

        }

    }

    public void username(String username) {

        myUserName = username;

        updateClientManager();

    }

    public void password(String password) {

        myPassword = password;

        updateClientManager();

    }

    public void setPrompt(PromptUserPassword prompt) {

        myPrompt = prompt;

        updateClientManager();

    }

    private void updateClientManager() {

        File configDir = myConfigDir == null ? null : new File(myConfigDir);

        myOptions = SVNWCUtil.createDefaultOptions(configDir, true);

        myOptions.setConflictHandler(getConflictHandler());

        myAuthenticationManager = SVNWCUtil.createDefaultAuthenticationManager(configDir, myUserName, myPassword, myOptions.isAuthStorageEnabled());

        if (myPrompt != null) {

            myAuthenticationManager.setAuthenticationProvider(new JavaHLAuthenticationProvider(myPrompt));

        } else {

            myAuthenticationManager.setAuthenticationProvider(null);

        }

        if (myAuthenticationManager instanceof DefaultSVNAuthenticationManager) {

            ((DefaultSVNAuthenticationManager)myAuthenticationManager).setRuntimeStorage(getClientCredentialsStorage());

        }

        if (myClientManager != null) {

            myClientManager.dispose();

            myClientManager.setAuthenticationManager(myAuthenticationManager);

            myClientManager.setOptions(myOptions);

        }

    }

    public LogMessage[] logMessages(String path, Revision revisionStart, Revision revisionEnd) throws ClientException {

        return logMessages(path, revisionStart, revisionEnd, true, false);

    }

    public LogMessage[] logMessages(String path, Revision revisionStart, Revision revisionEnd, boolean stopOnCopy) throws ClientException {

        return logMessages(path, revisionStart, revisionEnd, stopOnCopy, false);

    }

    public LogMessage[] logMessages(String path, Revision revisionStart, Revision revisionEnd, boolean stopOnCopy, boolean discoverPath) throws ClientException {

        return logMessages(path, revisionStart, revisionEnd, stopOnCopy, discoverPath, 0);

    }

    public LogMessage[] logMessages(String path, Revision revisionStart, Revision revisionEnd, boolean stopOnCopy, boolean discoverPath, long limit) throws ClientException {

        final Collection entries = new ArrayList();

        String[] revisionProperties = new String[]{SVNRevisionProperty.LOG, SVNRevisionProperty.DATE, SVNRevisionProperty.AUTHOR};

        logMessages(path, revisionEnd, revisionStart, revisionEnd, stopOnCopy, discoverPath, false, revisionProperties, limit,

                new ISVNLogEntryHandler() {

                    public void handleLogEntry(SVNLogEntry logEntry) {

                        entries.add(JavaHLObjectFactory.createLogMessage(logEntry));

                    }

                }

        );

        return (LogMessage[]) entries.toArray(new LogMessage[entries.size()]);

    }

    public void logMessages(String path, Revision pegRevision, Revision revisionStart, Revision revisionEnd, boolean stopOnCopy, boolean discoverPath, boolean includeMergedRevisions,

                            String[] revProps, long limit, LogMessageCallback callback) throws ClientException {

        final LogMessageCallback logMessageCallback = callback;

        logMessages(path, pegRevision, revisionStart, revisionEnd, stopOnCopy, discoverPath, includeMergedRevisions, revProps, limit,

                new ISVNLogEntryHandler() {

                    public void handleLogEntry(SVNLogEntry logEntry) {

                        JavaHLObjectFactory.handleLogMessage(logEntry, logMessageCallback);

                    }

                }

        );

    }

    private void logMessages(String path, Revision pegRevision, Revision revisionStart, Revision revisionEnd, boolean stopOnCopy, boolean discoverPath, boolean includeMergeInfo, String[] revisionProperties, long limit, ISVNLogEntryHandler logEntryHandler) throws ClientException {

        SVNLogClient client = getSVNLogClient();

        try {

            if (revisionEnd == null || revisionEnd.getKind() == RevisionKind.unspecified) {

                revisionEnd = Revision.HEAD;

            }

            if (revisionStart != null && revisionStart.getKind() == RevisionKind.unspecified) {

                revisionStart = Revision.getInstance(1);

            }

            if (isURL(path)) {

                if (revisionStart == null) {

                    revisionStart = Revision.HEAD;

                }

                client.doLog(

                        SVNURL.parseURIEncoded(path), new String[]{""},

                        JavaHLObjectFactory.getSVNRevision(pegRevision),

                        JavaHLObjectFactory.getSVNRevision(revisionStart),

                        JavaHLObjectFactory.getSVNRevision(revisionEnd),

                        stopOnCopy, discoverPath, includeMergeInfo, limit, revisionProperties, logEntryHandler);

            } else {

                if (revisionStart == null) {

                    revisionStart = Revision.BASE;

                }

                client.doLog(

                        new File[]{new File(path).getAbsoluteFile()},

                        JavaHLObjectFactory.getSVNRevision(revisionStart),

                        JavaHLObjectFactory.getSVNRevision(revisionEnd),

                        JavaHLObjectFactory.getSVNRevision(pegRevision),

                        stopOnCopy, discoverPath, includeMergeInfo, limit, revisionProperties, logEntryHandler);

            }

        } catch (SVNException e) {

            throwException(e);

        } finally {

            resetLog();

        }

    }

    /**

     * @deprecated

     */

    public void notification(Notify notify) {

        myNotify = notify;

    }

    public void notification2(Notify2 notify) {

        myNotify2 = notify;

    }

    public void setProgressListener(ProgressListener listener) {

        getDebugLog();

        if (listener != null) {

            myProgressListener = new JavaHLProgressLog(listener);

            myDebugLog.addLogger(myProgressListener);

        } else if (myProgressListener != null) {

            myDebugLog.removeLogger(myProgressListener);

            myProgressListener = null;

        }

    }

    private void resetLog(){

        if (myProgressListener != null) {

            myProgressListener.reset();           

        }

    }

    public void commitMessageHandler(CommitMessage messageHandler) {

        myMessageHandler = messageHandler;

    }

    public void setConflictResolver(ConflictResolverCallback listener) {

        myConflictResolverCallback = listener;

        mySVNConflictHandler = null;

        updateClientManager();

    }

    public void remove(String[] path, String message, boolean force) throws ClientException {

        remove(path, message, force, false, null);

    }

    public void remove(String[] path, String message, boolean force, boolean keepLocal, Map revprops) throws ClientException {

        boolean areURLs = false;

        for (int i = 0; i < path.length; i++) {

            areURLs = areURLs || isURL(path[i]);

        }

        if (areURLs) {

            SVNCommitClient client = getSVNCommitClient();

            SVNURL[] urls = new SVNURL[path.length];

            for (int i = 0; i < urls.length; i++) {

                try {

                    urls[i] = SVNURL.parseURIEncoded(path[i]);

                } catch (SVNException e) {

                    throwException(e);

                }

            }

            try {

                SVNProperties revisionProperties = revprops == null ? null : SVNProperties.wrap(revprops);

                client.setCommitHandler(createCommitMessageHandler(true));

                client.doDelete(urls, message, revisionProperties);

            } catch (SVNException e) {

                throwException(e);

            } finally {

                if (client != null) {

                    client.setCommitHandler(null);

                }

                resetLog();

            }

        } else {

            SVNWCClient client = getSVNWCClient();

            for (int i = 0; i < path.length; i++) {

                try {

                    client.doDelete(new File(path[i]).getAbsoluteFile(), force, !keepLocal, false);

                } catch (SVNException e) {

                    throwException(e);

                } finally {

                    resetLog();

                }

            }

        }

    }

    public void revert(String path, boolean recurse) throws ClientException {

        revert(path, JavaHLObjectFactory.infinityOrEmpty(recurse), null);

    }

  public void revert(String path, int depth, String[] changelists)

      throws ClientException {

        SVNWCClient client = getSVNWCClient();

        try {

            client.doRevert(new File[] { new File(path).getAbsoluteFile() },

                    JavaHLObjectFactory.getSVNDepth(depth),

                    JavaHLObjectFactory.getChangeListsCollection(changelists));

        } catch (SVNException e) {

            throwException(e);

        } finally {

            resetLog();

        }

  }

    public void add(String path, boolean recurse) throws ClientException {

        add(path, recurse, false);

    }

    public void add(String path, boolean recurse, boolean force) throws ClientException {

        add(path, JavaHLObjectFactory.infinityOrEmpty(recurse), force, false, false);

    }

    public void add(String path, int depth, boolean force, boolean noIgnores, boolean addParents) throws ClientException {       

        SVNWCClient wcClient = getSVNWCClient();

        try {

            wcClient.doAdd(new File(path).getAbsoluteFile(), force, false, false, JavaHLObjectFactory.getSVNDepth(depth), noIgnores, addParents);

        } catch (SVNException e) {

            throwException(e);

        } finally {

            resetLog();

        }

    }

    public long update(String path, Revision revision, boolean recurse) throws ClientException {

        long[] updated =  update(new String[]{path}, revision, recurse, false);

        if (updated != null && updated.length > 0) {

            return updated[0];

        }

        return -1;

    }

    public long[] update(String[] path, Revision revision, boolean recurse, boolean ignoreExternals) throws ClientException {

        return update(path, revision, JavaHLObjectFactory.unknownOrFiles(recurse), false, ignoreExternals, false);

    }

    public long update(String path, Revision revision, int depth, boolean depthIsSticky, boolean ignoreExternals, boolean allowUnverObstructions) throws ClientException {

        long[] updated = update(new String[]{path}, revision, depth, depthIsSticky, ignoreExternals, allowUnverObstructions);

        if (updated != null && updated.length > 0) {

            return updated[0];

        }

        return -1;

    }

    public long[] update(String[] path, Revision revision, int depth, boolean depthIsSticky, boolean ignoreExternals, boolean allowUnverObstructions) throws ClientException {

        if (path == null || path.length == 0) {

            return new long[]{};

        }

        long[] updated = new long[path.length];

        SVNUpdateClient updater = getSVNUpdateClient();

        boolean oldIgnore = updater.isIgnoreExternals();

        updater.setIgnoreExternals(ignoreExternals);

        updater.setEventPathPrefix("");

        SVNDepth svnDepth = JavaHLObjectFactory.getSVNDepth(depth);

        SVNRevision rev = JavaHLObjectFactory.getSVNRevision(revision);

        try {

            for (int i = 0; i < updated.length; i++) {

                updated[i] = updater.doUpdate(new File(path[i]).getAbsoluteFile(), rev, svnDepth,

                        allowUnverObstructions, depthIsSticky);

            }

        } catch (SVNException e) {

            throwException(e);

        } finally {

            updater.setIgnoreExternals(oldIgnore);

            updater.setEventPathPrefix(null);

            resetLog();

            SVNFileUtil.sleepForTimestamp();

        }

        return updated;

    }

    public long commit(String[] path, String message, boolean recurse) throws ClientException {

        return commit(path, message, recurse, false);

    }

    public long commit(String[] path, String message, boolean recurse, boolean noUnlock) throws ClientException {

        return commit(path, message, JavaHLObjectFactory.infinityOrEmpty(recurse), noUnlock, false, null, null);

    }

    public long commit(String[] path, String message, int depth, boolean noUnlock, boolean keepChangelist, String[] changelists, Map revprops) throws ClientException {

        if (path == null || path.length == 0) {

            return 0;

        }

        SVNCommitClient client = getSVNCommitClient();

        File[] files = new File[path.length];

        for (int i = 0; i < path.length; i++) {

            files[i] = new File(path[i]).getAbsoluteFile();

        }

        try {

            client.setCommitHandler(createCommitMessageHandler(false, false));

            SVNDepth svnDepth = SVNDepth.fromID(depth);

            boolean recurse = SVNDepth.recurseFromDepth(svnDepth);

            SVNProperties revisionProperties = revprops == null ? null : SVNProperties.wrap(revprops);

            return client.doCommit(files, noUnlock, message, revisionProperties, changelists, keepChangelist, !recurse, svnDepth).getNewRevision();

        } catch (SVNException e) {

            throwException(e);

        } finally {

            if (client != null) {

                client.setCommitHandler(null);

            }

            resetLog();

        }

        return -1;

    }

    public long[] commit(String[] path, String message, boolean recurse, boolean noUnlock, boolean atomicCommit) throws ClientException {

        return commit(path, message, JavaHLObjectFactory.infinityOrEmpty(recurse), noUnlock, false, null, null, atomicCommit);

    }

    public long[] commit(String[] path, String message, int depth, boolean noUnlock, boolean keepChangelist, String[] changlelists, Map revprops, boolean atomicCommit) throws ClientException {

        if (path == null || path.length == 0) {

            return new long[0];

        }

        SVNCommitClient client = getSVNCommitClient();

        File[] files = new File[path.length];

        for (int i = 0; i < path.length; i++) {

            files[i] = new File(path[i]).getAbsoluteFile();

        }

        SVNCommitPacket[] packets = null;

        SVNCommitInfo[] commitResults = null;

        try {

            client.setCommitHandler(createCommitMessageHandler(false));

            SVNDepth svnDepth = SVNDepth.fromID(depth);   

            boolean recurse = SVNDepth.recurseFromDepth(svnDepth);

            packets = client.doCollectCommitItems(files, noUnlock, !recurse, svnDepth, atomicCommit, changlelists);

            commitResults = client.doCommit(packets, noUnlock, keepChangelist, message, revprops != null ? SVNProperties.wrap(revprops) : null);

        } catch (SVNException e) {

            throwException(e);

        } finally {

            if (client != null) {

                client.setCommitHandler(null);

            }

            resetLog();

        }

        if (commitResults != null && commitResults.length > 0) {

            long[] revisions = new long[commitResults.length];

            for (int i = 0; i < commitResults.length; i++) {

                SVNCommitInfo result = commitResults[i];

                revisions[i] = result.getNewRevision();

            }

            return revisions;

        }

        return new long[0];

    }

    public void copy(String srcPath, String destPath, String message, Revision revision) throws ClientException {

        copy(new CopySource[]{new CopySource(srcPath, revision, null)}, destPath, message, true, false, null);

    }

    public void copy(CopySource[] sources, String destPath, String message, boolean copyAsChild, boolean makeParents, Map revprops) throws ClientException {

        SVNCopySource[] copySources = getCopySources(sources, copyAsChild);

        copyOrMove(copySources, destPath, false, message, copyAsChild, makeParents, revprops);

    }

    public void move(String srcPath, String destPath, String message, boolean force) throws ClientException {

        move(new String[]{srcPath}, destPath, message, force, true, false, null);

    }

    public void move(String srcPath, String destPath, String message, Revision revision, boolean force) throws ClientException {

        move(new String[]{srcPath}, destPath, message, force, true, false, null);

    }

    public void move(String[] srcPaths, String destPath, String message, boolean force, boolean moveAsChild, boolean makeParents, Map revprops) throws ClientException {

        SVNCopySource[] copySources = getCopySources(srcPaths, moveAsChild);

        copyOrMove(copySources, destPath, true, message, moveAsChild, makeParents, revprops);

    }

    private SVNCopySource[] getCopySources(CopySource[] srcs, boolean copyAsChild) throws ClientException {

        if (srcs.length > 1 && !copyAsChild) {

            SVNErrorMessage err = SVNErrorMessage.create(SVNErrorCode.CLIENT_MULTIPLE_SOURCES_DISALLOWED);

            SVNException ex = new SVNException(err);