package jetbrains.buildServer.buildTriggers.vcs.mercurial;

import com.intellij.openapi.diagnostic.Logger;
import jetbrains.buildServer.TempFiles;
import jetbrains.buildServer.agent.*;
import jetbrains.buildServer.log.Log4jFactory;
import jetbrains.buildServer.vcs.*;
import org.jetbrains.annotations.NotNull;
import org.jmock.Expectations;
import org.jmock.Mockery;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;

import java.io.File;
import java.util.Date;
import java.util.HashMap;

import static java.util.Arrays.asList;
import static jetbrains.buildServer.buildTriggers.vcs.mercurial.LocalRepositoryUtil.copyRepository;
import static jetbrains.buildServer.buildTriggers.vcs.mercurial.VcsRootBuilder.vcsRoot;

/**
 * @author dmitry.neverov
 */
@Test
public class AgentMirrorCleanerTest {

  static {
    Logger.setFactory(new Log4jFactory());
  }

  private TempFiles myTempFiles = new TempFiles();
  private Mockery myContext;
  private MercurialAgentSideVcsSupport myVcsSupport;
  private AgentMirrorCleaner myCleaner;
  private BuildProgressLogger myLogger;
  private File myWorkDir;
  private int myBuildCounter;
  private MirrorManager myMirrorManager;

  @BeforeMethod
  public void setUp() throws Exception {
    myContext = new Mockery();
    myWorkDir = myTempFiles.createTempDir();

    final BuildAgentConfiguration agentConfig = myContext.mock(BuildAgentConfiguration.class);
    myContext.checking(new Expectations() {{
      allowing(agentConfig).getCacheDirectory("mercurial"); will(returnValue(myTempFiles.createTempDir()));
      allowing(agentConfig).getParametersResolver(); will(returnValue(new HgPathResolver()));
    }});

    AgentPluginConfigImpl pluginConfig = new AgentPluginConfigImpl(agentConfig);
    AgentHgPathProvider hgPathProvider = new AgentHgPathProvider(agentConfig);
    myMirrorManager = new MirrorManagerImpl(pluginConfig);
    myVcsSupport = new MercurialAgentSideVcsSupport(pluginConfig, hgPathProvider, myMirrorManager);
    myCleaner = new AgentMirrorCleaner(myMirrorManager, hgPathProvider);
    myLogger = myContext.mock(BuildProgressLogger.class);
    myContext.checking(new Expectations() {{
      allowing(myLogger).message(with(any(String.class)));
      allowing(myLogger).warning(with(any(String.class)));
    }});
  }

  @AfterMethod
  public void tearDown() {
    myTempFiles.cleanup();
  }


  public void should_add_cleaners_only_for_roots_not_used_in_build() throws Exception {
    //setup mirrors for 2 roots on an agent:
    final File repo1 = myTempFiles.createTempDir();
    final File repo2 = myTempFiles.createTempDir();
    copyRepository(new File("mercurial-tests/testData/rep1"), repo1);
    copyRepository(new File("mercurial-tests/testData/rep2"), repo2);

    final VcsRoot root1 = vcsRoot().withUrl(repo1.getAbsolutePath()).build();
    final VcsRoot root2 = vcsRoot().withUrl(repo2.getAbsolutePath()).build();
    //update will initialize mirrors
    doUpdate(root1, "4:b06a290a363b", myWorkDir);
    doUpdate(root2, "8:b6e2d176fe8e", new File(myWorkDir, "subdir"));

    final File mirrorDir1 = myMirrorManager.getMirrorDir(repo1.getAbsolutePath());
    final File mirrorDir2 = myMirrorManager.getMirrorDir(repo2.getAbsolutePath());
    final Date mirrorDir1LastUsedTime = new Date(myMirrorManager.getLastUsedTime(mirrorDir1));
    final Date mirrorDir2LastUsedTime = new Date(myMirrorManager.getLastUsedTime(mirrorDir2));

    //run build which uses root1:
    final DirectoryCleanersProviderContext ctx = myContext.mock(DirectoryCleanersProviderContext.class);
    myContext.checking(new Expectations(){{
      AgentRunningBuild build = myContext.mock(AgentRunningBuild.class, "build" + myBuildCounter++);
      allowing(build).getVcsRootEntries(); will(returnValue(asList(new VcsRootEntry(root1, CheckoutRules.DEFAULT))));
      allowing(ctx).getRunningBuild(); will(returnValue(build));
    }});

    //cleaner should add cleaners only for roots which are not used in the running build
    final DirectoryCleanersRegistry registry = myContext.mock(DirectoryCleanersRegistry.class);
    myContext.checking(new Expectations() {{
      never(registry).addCleaner(with(mirrorDir1), with(mirrorDir1LastUsedTime));
      one(registry).addCleaner(with(mirrorDir2), with(mirrorDir2LastUsedTime));
    }});

    myCleaner.registerDirectoryCleaners(ctx, registry);
    myContext.assertIsSatisfied();
  }


  private void doUpdate(@NotNull VcsRoot vcsRoot, @NotNull String toVersion, @NotNull File workDir) throws VcsException {
    final AgentRunningBuild build = myContext.mock(AgentRunningBuild.class, "build" + myBuildCounter++);
    myContext.checking(new Expectations() {{
      allowing(build).getBuildLogger(); will(returnValue(myLogger));
      allowing(build).getSharedConfigParameters(); will(returnValue(new HashMap<String, String>() {{
        put("teamcity.hg.use.local.mirrors", "true");
      }}));
    }});
    myVcsSupport.getUpdater(vcsRoot, CheckoutRules.DEFAULT, toVersion, workDir, build, false).process(IncludeRule.createDefaultInstance(), workDir);
  }

}