/*
 * Copyright 2000-2009 JetBrains s.r.o.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.jetbrains.idea.svn;

import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.progress.ProcessCanceledException;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.util.Comparing;
import com.intellij.openapi.util.Computable;
import com.intellij.openapi.util.Ref;
import com.intellij.openapi.util.io.FileUtil;
import com.intellij.openapi.vcs.FilePath;
import com.intellij.openapi.vcs.FilePathImpl;
import com.intellij.openapi.vfs.LocalFileSystem;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.util.Processor;
import com.intellij.vcsUtil.VcsUtil;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.idea.svn.commandLine.SvnCommandLineStatusClient;
import org.jetbrains.idea.svn.portable.JavaHLSvnStatusClient;
import org.jetbrains.idea.svn.portable.SvnStatusClientI;
import org.jetbrains.idea.svn.portable.SvnkitSvnStatusClient;
import org.tmatesoft.svn.core.SVNDepth;
import org.tmatesoft.svn.core.SVNErrorCode;
import org.tmatesoft.svn.core.SVNException;
import org.tmatesoft.svn.core.SVNNodeKind;
import org.tmatesoft.svn.core.internal.wc.SVNFileUtil;
import org.tmatesoft.svn.core.wc.*;

import java.io.File;
import java.util.LinkedList;

public class SvnRecursiveStatusWalker {
  private static final Logger LOG = Logger.getInstance("#org.jetbrains.idea.svn.SvnRecursiveStatusWalker");
  private final StatusWalkerPartner myPartner;
  private final SvnVcs myVcs;
  private final Project myProject;
  private final StatusReceiver myReceiver;
  private final LinkedList<MyItem> myQueue;
  private final MyHandler myHandler;

  public SvnRecursiveStatusWalker(final SvnVcs vcs, final StatusReceiver receiver, final StatusWalkerPartner partner) {
    myVcs = vcs;
    myProject = vcs.getProject();
    myReceiver = receiver;
    myPartner = partner;
    myQueue = new LinkedList<MyItem>();
    myHandler = new MyHandler();
  }

  public void go(final FilePath rootPath, final SVNDepth depth) throws SVNException {
    final MyItem root = new MyItem(myVcs, rootPath, depth, myPartner.createStatusClient(), false);
    myQueue.add(root);

    while (! myQueue.isEmpty()) {
      myPartner.checkCanceled();

      final MyItem item = myQueue.removeFirst();
      final FilePath path = item.getPath();
      final File ioFile = path.getIOFile();

      if (path.isDirectory()) {
        myHandler.setCurrentItem(item);
        try {
          final SvnStatusClientI client = item.getClient(ioFile);
          client.doStatus(ioFile, SVNRevision.WORKING, item.getDepth(), false, false, true, true, myHandler, null);
          myHandler.checkIfCopyRootWasReported(null, ioFile);
        }
        catch (SVNException e) {
          handleStatusException(item, path, e);
        }
      } else {
        try {
          final SVNStatus status = item.getClient(ioFile).doStatus(ioFile, false, false);
          myReceiver.process(path, status);
        } catch (SVNException e) {
          handleStatusException(item, path, e);
        }
      }
    }
  }

  private void handleStatusException(MyItem item, FilePath path, SVNException e) throws SVNException {
    final SVNErrorCode errorCode = e.getErrorMessage().getErrorCode();
    if (SVNErrorCode.WC_NOT_DIRECTORY.equals(errorCode) || SVNErrorCode.WC_NOT_FILE.equals(errorCode)) {
      final VirtualFile virtualFile = path.getVirtualFile();
      if (virtualFile != null) {
        if (! myPartner.isExcluded(virtualFile)) {
          // self is unversioned
          myReceiver.processUnversioned(virtualFile);

          if (virtualFile.isDirectory()) {
            processRecursively(virtualFile, item.getDepth());
          }
        }
      }
    } else {
      throw e;
    }
  }

  private static class MyItem {
    private final Project myProject;
    private final FilePath myPath;
    private final SVNDepth myDepth;
    private final SvnStatusClientI mySvnClient;
    private final SvnStatusClientI myCommandLineClient;
    private final boolean myIsInnerCopyRoot;
    private final SvnConfiguration myConfiguration17;
    private final SvnVcs myVcs;

    private MyItem(SvnVcs vcs, FilePath path, SVNDepth depth, SVNStatusClient client, boolean isInnerCopyRoot) {
      myVcs = vcs;
      myProject = vcs.getProject();
      myConfiguration17 = SvnConfiguration.getInstance(myProject);
      myPath = path;
      myDepth = depth;
      mySvnClient = new SvnkitSvnStatusClient(myVcs, client);
      myCommandLineClient = new SvnCommandLineStatusClient(myVcs);
      myIsInnerCopyRoot = isInnerCopyRoot;
    }

    public FilePath getPath() {
      return myPath;
    }

    public SVNDepth getDepth() {
      return myDepth;
    }

    public SvnStatusClientI getClient(final File file) {
      // TODO: refactor to ClientFactory usage but carefully save all parameters passed in myClient - fileProvider and
      // TODO: event handler (for cancel support)
      WorkingCopyFormat format = myVcs.getWorkingCopyFormat(file);

      if (format == WorkingCopyFormat.ONE_DOT_EIGHT) {
        return myCommandLineClient;
      }

      if (format == WorkingCopyFormat.ONE_DOT_SIX) {
        return mySvnClient;
      }

      // check format
      if (CheckJavaHL.isPresent() && SvnConfiguration.UseAcceleration.javaHL.equals(myConfiguration17.myUseAcceleration) &&
          Svn17Detector.is17(myProject, file)) {
        return new JavaHLSvnStatusClient(myProject);
      } else if (myConfiguration17.isCommandLine()) {
        // apply command line disregarding working copy format
        return myCommandLineClient;
      }
      return mySvnClient;
    }

    public boolean isIsInnerCopyRoot() {
      return myIsInnerCopyRoot;
    }
  }

  private void processRecursively(final VirtualFile vFile, final SVNDepth prevDepth) {
    if (SVNDepth.EMPTY.equals(prevDepth)) return;
    if (myPartner.isIgnoredIdeaLevel(vFile)) {
      myReceiver.processIgnored(vFile);
      return;
    }
    final SVNDepth newDepth = SVNDepth.INFINITY.equals(prevDepth) ? SVNDepth.INFINITY : SVNDepth.EMPTY;

    final File ioFile = new File(vFile.getPath());
    final Processor<File> processor;
    final Processor<File> directoryFilter;
    final Ref<File> lastIgnored = new Ref<File>();
    final Processor<File> checkDirProcessor = new Processor<File>() {
      @Override
      public boolean process(File file) {
        final FilePathImpl path = new FilePathImpl(file, true);
        path.refresh();
        path.hardRefresh();
        VirtualFile vf = path.getVirtualFile();
        if (vf != null && myPartner.isIgnoredIdeaLevel(vf)) {
          lastIgnored.set(file);
          myReceiver.processIgnored(vf);
          return true;
        }
        if (file.isDirectory() && new File(file, SVNFileUtil.getAdminDirectoryName()).exists()) {
          final MyItem childItem = new MyItem(myVcs, path, newDepth, myPartner.createStatusClient(), true);
          myQueue.add(childItem);
        } else if (vf != null) {
          myReceiver.processUnversioned(vf);
        }
        return true;
      }
    };
    if (SVNDepth.EMPTY.equals(newDepth)) {
      directoryFilter = Processor.TRUE;
      processor = new Processor<File>() {
        @Override
        public boolean process(File file) {
          // here we deal only with immediate children - so ignored on IDEA level for children is not important - we nevertheless do not go into
          // other levels
          if (! FileUtil.filesEqual(ioFile, file)) return true;
          if (! FileUtil.filesEqual(ioFile, file.getParentFile())) return false;
          return checkDirProcessor.process(file);
        }
      };
    } else {
      directoryFilter = new Processor<File>() {
        @Override
        public boolean process(File file) {
          return ! Comparing.equal(lastIgnored, file) && (myQueue.isEmpty() || ! FileUtil.filesEqual(myQueue.getLast().getPath().getIOFile(), file));
        }
      };
      processor = checkDirProcessor;
    }
    FileUtil.processFilesRecursively(ioFile, processor, directoryFilter);
  }

  private class MyHandler implements ISVNStatusHandler {
    private MyItem myCurrentItem;
    private boolean myMetCurrentItem;

    public void setCurrentItem(MyItem currentItem) {
      myCurrentItem = currentItem;
      myMetCurrentItem = false;
    }

    public void checkIfCopyRootWasReported(@Nullable final SVNStatus ioFileStatus, final File ioFile) {
      File itemFile = myCurrentItem.getPath().getIOFile();
      if (! myMetCurrentItem && FileUtil.filesEqual(ioFile, itemFile)) {
        myMetCurrentItem = true;
        SVNStatus statusInner;
        try {
          statusInner = ioFileStatus != null ? ioFileStatus :
            myCurrentItem.getClient(itemFile).doStatus(itemFile, false);
        }
        catch (SVNException e) {
          LOG.info(e);
          statusInner = null;
        }
        if (statusInner == null)  return;

        final SVNStatusType status = statusInner.getNodeStatus();
        final VirtualFile vf = myCurrentItem.getPath().getVirtualFile();
        if (SVNStatusType.STATUS_IGNORED.equals(status)) {
          if (vf != null) {
            myReceiver.processIgnored(vf);
          }
          return;
        }
        if (SVNStatusType.STATUS_UNVERSIONED.equals(status) || SVNStatusType.UNKNOWN.equals(status)) {
          if (vf != null) {
            myReceiver.processUnversioned(vf);
            processRecursively(vf, myCurrentItem.getDepth());
          }
          return;
        }
        if (SVNStatusType.OBSTRUCTED.equals(status) || SVNStatusType.STATUS_NONE.equals(status)) {
          return;
        }
        if (vf != null) {
          if (myCurrentItem.isIsInnerCopyRoot()) {
            myReceiver.processCopyRoot(vf, statusInner.getURL(),
                                     WorkingCopyFormat.getInstance(statusInner.getWorkingCopyFormat()), statusInner.getRepositoryRootURL());
          } else {
            myReceiver.bewareRoot(vf, statusInner.getURL(), WorkingCopyFormat.getInstance(statusInner.getWorkingCopyFormat()));
          }
        }
      }
    }

    public void handleStatus(final SVNStatus status) throws SVNException {
      myPartner.checkCanceled();
      final File ioFile = status.getFile();
      checkIfCopyRootWasReported(status, ioFile);

      final VirtualFile vFile = getVirtualFile(ioFile);
      if (vFile != null) {
        final Boolean excluded = ApplicationManager.getApplication().runReadAction(new Computable<Boolean>() {
          @Override
          public Boolean compute() {
            if (myProject.isDisposed()) return null;
            return myPartner.isExcluded(vFile);
          }
        });
        if (Boolean.TRUE.equals(excluded)) return;
      }
      if (myProject.isDisposed()) throw new ProcessCanceledException();

      if ((vFile != null) && (SvnVcs.svnStatusIsUnversioned(status))) {
        if (vFile.isDirectory()) {
          if (FileUtil.filesEqual(myCurrentItem.getPath().getIOFile(), ioFile)) {
            //myReceiver.processUnversioned(vFile);
            //processRecursively(vFile, myCurrentItem.getDepth());
          } else {
            final MyItem childItem = new MyItem(myVcs, new FilePathImpl(vFile), SVNDepth.INFINITY,
                                                myPartner.createStatusClient(), true);
            myQueue.add(childItem);
          }
        } else {
          myReceiver.processUnversioned(vFile);
        }
      } else {
        final FilePath path = VcsUtil.getFilePath(ioFile, status.getKind().equals(SVNNodeKind.DIR));
        myReceiver.process(path, status);
      }
    }
  }

  private VirtualFile getVirtualFile(File ioFile) {
    final LocalFileSystem lfs = LocalFileSystem.getInstance();
    VirtualFile vFile = lfs.findFileByIoFile(ioFile);
    if (vFile == null) {
      vFile = lfs.refreshAndFindFileByIoFile(ioFile);
    }
    return vFile;
  }
}