/*
 * Copyright (c) 2013 TMate Software Ltd
 *  
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; version 2 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * For information on how to redistribute this software under
 * the terms of a license other than GNU General Public License
 * contact TMate Software at support@hg4j.com
 */
package org.tmatesoft.hg.test;

import static org.junit.Assert.*;
import static org.tmatesoft.hg.repo.HgRepository.TIP;

import java.io.File;
import java.util.List;

import org.junit.Rule;
import org.junit.Test;
import org.tmatesoft.hg.core.HgCheckoutCommand;
import org.tmatesoft.hg.core.HgCommitCommand;
import org.tmatesoft.hg.core.HgOutgoingCommand;
import org.tmatesoft.hg.core.HgPushCommand;
import org.tmatesoft.hg.core.Nodeid;
import org.tmatesoft.hg.internal.PhasesHelper;
import org.tmatesoft.hg.internal.RevisionSet;
import org.tmatesoft.hg.repo.HgBookmarks;
import org.tmatesoft.hg.repo.HgChangelog;
import org.tmatesoft.hg.repo.HgInternals;
import org.tmatesoft.hg.repo.HgLookup;
import org.tmatesoft.hg.repo.HgPhase;
import org.tmatesoft.hg.repo.HgRemoteRepository;
import org.tmatesoft.hg.repo.HgRepository;

/**
 * @author Artem Tikhomirov
 * @author TMate Software Ltd.
 */
public class TestPush {

	@Rule
	public ErrorCollectorExt errorCollector = new ErrorCollectorExt();

	@Test
	public void testPushToEmpty() throws Exception {
		File srcRepoLoc = RepoUtils.cloneRepoToTempLocation("test-annotate", "test-push2empty-src", false);
		File dstRepoLoc = RepoUtils.initEmptyTempRepo("test-push2empty-dst");
		HgServer server = new HgServer().start(dstRepoLoc);
		try {
			final HgLookup hgLookup = new HgLookup();
			HgRepository srcRepo = hgLookup.detect(srcRepoLoc);
			HgPushCommand cmd = new HgPushCommand(srcRepo);
			final HgRemoteRepository dstRemote = hgLookup.detect(server.getURL());
			cmd.destination(dstRemote);
			cmd.execute();
			final HgRepository dstRepo = hgLookup.detect(dstRepoLoc);
			checkRepositoriesAreSame(srcRepo, dstRepo);
			final List<Nodeid> outgoing = new HgOutgoingCommand(srcRepo).against(dstRemote).executeLite();
			errorCollector.assertTrue(outgoing.toString(), outgoing.isEmpty());
		} finally {
			server.stop();
		}
	}

	@Test
	public void testPushChanges() throws Exception {
		File srcRepoLoc = RepoUtils.cloneRepoToTempLocation("test-annotate", "test-push-src", false);
		File dstRepoLoc = RepoUtils.cloneRepoToTempLocation("test-annotate", "test-push-dst", false);
		File f1 = new File(srcRepoLoc, "file1");
		assertTrue("[sanity]", f1.canWrite());
		HgServer server = new HgServer().start(dstRepoLoc);
		try {
			final HgLookup hgLookup = new HgLookup();
			final HgRepository srcRepo = hgLookup.detect(srcRepoLoc);
			final HgRemoteRepository dstRemote = hgLookup.detect(server.getURL());
			RepoUtils.modifyFileAppend(f1, "change1");
			new HgCommitCommand(srcRepo).message("Commit 1").execute();
			new HgCheckoutCommand(srcRepo).changeset(7).clean(true).execute();
			assertEquals("[sanity]", "no-merge", srcRepo.getWorkingCopyBranchName());
			RepoUtils.modifyFileAppend(f1, "change2");
			new HgCommitCommand(srcRepo).message("Commit 2").execute();
			//
			new HgPushCommand(srcRepo).destination(dstRemote).execute();
			checkRepositoriesAreSame(srcRepo, hgLookup.detect(dstRepoLoc));
			final List<Nodeid> outgoing = new HgOutgoingCommand(srcRepo).against(dstRemote).executeLite();
			errorCollector.assertTrue(outgoing.toString(), outgoing.isEmpty());
		} finally {
			server.stop();
		}
	}
	
	@Test
	public void testPushToNonPublishingServer() throws Exception {
		// check drafts are same as on server
		// copy, not clone as latter updates phase information
		File srcRepoLoc = RepoUtils.copyRepoToTempLocation("test-phases", "test-push-nopub-src");
		File dstRepoLoc = RepoUtils.initEmptyTempRepo("test-push-nopub-dst");
		File f1 = new File(srcRepoLoc, "hello.c");
		assertTrue("[sanity]", f1.canWrite());
		HgServer server = new HgServer().publishing(false).start(dstRepoLoc);
		try {
			final HgLookup hgLookup = new HgLookup();
			final HgRepository srcRepo = hgLookup.detect(srcRepoLoc);
			final HgRemoteRepository dstRemote = hgLookup.detect(server.getURL());
			PhasesHelper phaseHelper = new PhasesHelper(HgInternals.getImplementationRepo(srcRepo));
			final RevisionSet allDraft = phaseHelper.allDraft();
			assertFalse("[sanity]", allDraft.isEmpty());
			final int publicCsetToBranchAt = 4;
			assertEquals("[sanity]", HgPhase.Public, phaseHelper.getPhase(publicCsetToBranchAt, null));
			// in addition to existing draft csets, add one more draft, branching at some other public revision
			new HgCheckoutCommand(srcRepo).changeset(publicCsetToBranchAt).clean(true).execute();
			RepoUtils.modifyFileAppend(f1, "// aaa");
			final HgCommitCommand commitCmd = new HgCommitCommand(srcRepo).message("Commit aaa");
			assertTrue(commitCmd.execute().isOk());
			Nodeid newCommit = commitCmd.getCommittedRevision();
			//
			new HgPushCommand(srcRepo).destination(dstRemote).execute();
			HgRepository dstRepo = hgLookup.detect(dstRepoLoc);
			final HgChangelog srcClog = srcRepo.getChangelog();
			final HgChangelog dstClog = dstRepo.getChangelog();
			// refresh PhasesHelper
			phaseHelper = new PhasesHelper(HgInternals.getImplementationRepo(srcRepo));
			// check if phase didn't change
			errorCollector.assertEquals(HgPhase.Draft, phaseHelper.getPhase(srcClog.getRevisionIndex(newCommit), newCommit));
			for (Nodeid n : allDraft) {
				// check drafts from src were actually pushed to dst 
				errorCollector.assertTrue(dstClog.isKnown(n));
				// check drafts didn't change their phase
				errorCollector.assertEquals(HgPhase.Draft, phaseHelper.getPhase(srcClog.getRevisionIndex(n), n));
			}
		} finally {
			server.stop();
		}
	}
	
	/**
	 * If server lists revisions we know as drafts as public, update them locally
	 */
	@Test
	public void testPushUpdatesPublishedDrafts() throws Exception {
		/* o		r9, secret
		 * |  o		r8, draft
		 * |  |
		 * |  o		r7, draft
		 * o  |		r6, secret 
		 * | /
		 * o		r5, draft
		 * |
		 * o		r4, public
		 */
		// remote: r5 -> public, r6 -> draft, r8 -> secret
		// local: new draft from r4, push
		File srcRepoLoc = RepoUtils.copyRepoToTempLocation("test-phases", "test-push-phase-update-1-src");
		File dstRepoLoc = RepoUtils.copyRepoToTempLocation("test-phases", "test-push-phase-update-1-dst");
		File f1 = new File(srcRepoLoc, "hello.c");
		assertTrue("[sanity]", f1.canWrite());
		final HgLookup hgLookup = new HgLookup();
		final HgRepository srcRepo = hgLookup.detect(srcRepoLoc);
		final ExecHelper dstRun = new ExecHelper(new OutputParser.Stub(), dstRepoLoc);
		final int publicCsetToBranchAt = 4;
		final int r5 = 5, r6 = 6, r8 = 8;
		PhasesHelper srcPhase = new PhasesHelper(HgInternals.getImplementationRepo(srcRepo));
		assertEquals("[sanity]", HgPhase.Draft, srcPhase.getPhase(r5, null));
		assertEquals("[sanity]", HgPhase.Secret, srcPhase.getPhase(r6, null));
		assertEquals("[sanity]", HgPhase.Draft, srcPhase.getPhase(r8, null));
		// change phases in repository of remote server:
		dstRun.exec("hg", "phase", "--public", String.valueOf(r5));
		assertEquals(0, dstRun.getExitValue());
		dstRun.exec("hg", "phase", "--draft", String.valueOf(r6));
		assertEquals(0, dstRun.getExitValue());
		dstRun.exec("hg", "phase", "--secret", "--force", String.valueOf(r8));
		assertEquals(0, dstRun.getExitValue());
		HgServer server = new HgServer().publishing(false).start(dstRepoLoc);
		try {
			final HgRemoteRepository dstRemote = hgLookup.detect(server.getURL());
			// commit new draft head
			new HgCheckoutCommand(srcRepo).changeset(publicCsetToBranchAt).clean(true).execute();
			RepoUtils.modifyFileAppend(f1, "// aaa");
			final HgCommitCommand commitCmd = new HgCommitCommand(srcRepo).message("Commit aaa");
			assertTrue(commitCmd.execute().isOk());
			final Nodeid newCommit = commitCmd.getCommittedRevision();
			//
			new HgPushCommand(srcRepo).destination(dstRemote).execute();
			// refresh phase information
			srcPhase = new PhasesHelper(HgInternals.getImplementationRepo(srcRepo));
			// r5 and r6 are changed to match server phases (more exposed)
			errorCollector.assertEquals(HgPhase.Public, srcPhase.getPhase(r5, null));
			errorCollector.assertEquals(HgPhase.Draft, srcPhase.getPhase(r6, null));
			// r8 is secret on server, locally can't make it less exposed though
			errorCollector.assertEquals(HgPhase.Draft, srcPhase.getPhase(r8, null));
			//
			HgRepository dstRepo = hgLookup.detect(dstRepoLoc);
			final HgChangelog dstClog = dstRepo.getChangelog();
			assertTrue(dstClog.isKnown(newCommit));
			PhasesHelper dstPhase = new PhasesHelper(HgInternals.getImplementationRepo(dstRepo));
			errorCollector.assertEquals(HgPhase.Draft, dstPhase.getPhase(dstClog.getRevisionIndex(newCommit), newCommit));
			// the one that was secret is draft now
			errorCollector.assertEquals(HgPhase.Draft, srcPhase.getPhase(r8, null));
		} finally {
			server.stop();
		}
	}
	
	/**
	 * update phases of local revisions and push changes
	 */
	@Test
	public void testPushPublishAndUpdates() throws Exception {
		File srcRepoLoc = RepoUtils.copyRepoToTempLocation("test-phases", "test-push-phase-update-2-src");
		File dstRepoLoc = RepoUtils.initEmptyTempRepo("test-push-phase-update-1-dst");
		final int r4 = 4, r5 = 5, r6 = 6, r9 = 9;
		HgServer server = new HgServer().publishing(false).start(dstRepoLoc);
		try {
			final HgLookup hgLookup = new HgLookup();
			final HgRepository srcRepo = hgLookup.detect(srcRepoLoc);
			final HgRemoteRepository dstRemote = hgLookup.detect(server.getURL());
			new HgPushCommand(srcRepo).destination(dstRemote).execute();
			//
			// make sure pushed repository got same draft root
			final Nodeid r4PublicHead = srcRepo.getChangelog().getRevision(r4);
			final Nodeid r5DraftRoot = srcRepo.getChangelog().getRevision(r5);
			HgRepository dstRepo = hgLookup.detect(dstRepoLoc);
			final HgChangelog dstClog = dstRepo.getChangelog();
			PhasesHelper dstPhase = new PhasesHelper(HgInternals.getImplementationRepo(dstRepo));
			assertEquals(HgPhase.Public, dstPhase.getPhase(dstClog.getRevisionIndex(r4PublicHead), r4PublicHead));
			assertEquals(HgPhase.Draft, dstPhase.getPhase(dstClog.getRevisionIndex(r5DraftRoot), r5DraftRoot));
			//
			// now, graduate some local revisions, r5:draft->public, r6:secret->public, r9: secret->draft
			final ExecHelper srcRun = new ExecHelper(new OutputParser.Stub(), srcRepoLoc);
			srcRun.exec("hg", "phase", "--public", String.valueOf(r5));
			srcRun.exec("hg", "phase", "--public", String.valueOf(r6));
			srcRun.exec("hg", "phase", "--draft", String.valueOf(r9));
			// PhaseHelper shall be new for the command, and would pick up these external changes 
			new HgPushCommand(srcRepo).destination(dstRemote).execute();
			final Nodeid r6Nodeid = srcRepo.getChangelog().getRevision(r6);
			final Nodeid r9Nodeid = srcRepo.getChangelog().getRevision(r9);
			// refresh 
			dstPhase = new PhasesHelper(HgInternals.getImplementationRepo(dstRepo));
			// not errorCollector as subsequent code would fail if these secret revs didn't get into dst
			assertTrue(dstClog.isKnown(r6Nodeid));
			assertTrue(dstClog.isKnown(r9Nodeid));
			errorCollector.assertEquals(HgPhase.Public, dstPhase.getPhase(dstClog.getRevisionIndex(r5DraftRoot), r5DraftRoot));
			errorCollector.assertEquals(HgPhase.Public, dstPhase.getPhase(dstClog.getRevisionIndex(r6Nodeid), r6Nodeid));
			errorCollector.assertEquals(HgPhase.Draft, dstPhase.getPhase(dstClog.getRevisionIndex(r9Nodeid), r9Nodeid));
		} finally {
			server.stop();
		}
	}

	
	/**
	 * XXX doesn't check the case when we push child of a draft revision which is
	 * known as public on server ((presentLocalDrafts \ outgoing) leaves bogus draft revision, 
	 * the parent one of the child added and pushed)
	 * For the time being, TestPull.testPullFromPublishing covers this case (as both push and
	 * pull share same phase update functionality)
	 */
	@Test
	public void testPushToPublishingServer() throws Exception {
		// copy, not clone as latter updates phase information
		File srcRepoLoc = RepoUtils.copyRepoToTempLocation("test-phases", "test-push-pub-src");
		File dstRepoLoc = RepoUtils.initEmptyTempRepo("test-push-pub-dst");
		HgServer server = new HgServer().publishing(true).start(dstRepoLoc);
		try {
			final HgLookup hgLookup = new HgLookup();
			final HgRepository srcRepo = hgLookup.detect(srcRepoLoc);
			final HgRemoteRepository dstRemote = hgLookup.detect(server.getURL());
			PhasesHelper phaseHelper = new PhasesHelper(HgInternals.getImplementationRepo(srcRepo));
			final RevisionSet allDraft = phaseHelper.allDraft();
			assertFalse("[sanity]", allDraft.isEmpty());
			// push all changes
			new HgPushCommand(srcRepo).destination(dstRemote).execute();
			HgRepository dstRepo = hgLookup.detect(dstRepoLoc);
			final HgChangelog srcClog = srcRepo.getChangelog();
			final HgChangelog dstClog = dstRepo.getChangelog();
			// refresh PhasesHelper
			phaseHelper = new PhasesHelper(HgInternals.getImplementationRepo(srcRepo));
			for (Nodeid n : allDraft) {
				// check drafts from src were actually pushed to dst 
				errorCollector.assertTrue(dstClog.isKnown(n));
				// check drafts became public
				errorCollector.assertEquals(HgPhase.Public, phaseHelper.getPhase(srcClog.getRevisionIndex(n), n));
			}
		} finally {
			server.stop();
		}
	}

	@Test
	public void testPushSecretChangesets() throws Exception {
		// copy, not clone as latter updates phase information
		File srcRepoLoc = RepoUtils.copyRepoToTempLocation("test-phases", "test-push-no-secret-src");
		File dstRepoLoc = RepoUtils.initEmptyTempRepo("test-push-no-secret-dst");
		HgServer server = new HgServer().start(dstRepoLoc);
		try {
			final HgLookup hgLookup = new HgLookup();
			final HgRepository srcRepo = hgLookup.detect(srcRepoLoc);
			final HgRemoteRepository dstRemote = hgLookup.detect(server.getURL());
			PhasesHelper phaseHelper = new PhasesHelper(HgInternals.getImplementationRepo(srcRepo));
			final RevisionSet allSecret = phaseHelper.allSecret();
			assertFalse("[sanity]", allSecret.isEmpty());
			new HgPushCommand(srcRepo).destination(dstRemote).execute();
			HgRepository dstRepo = hgLookup.detect(dstRepoLoc);
			final HgChangelog srcClog = srcRepo.getChangelog();
			final HgChangelog dstClog = dstRepo.getChangelog();
			errorCollector.assertEquals(srcClog.getRevisionCount() - allSecret.size(), dstClog.getRevisionCount());
			for (Nodeid n : allSecret) {		
				errorCollector.assertTrue(n.toString(), !dstClog.isKnown(n));
			}
		} finally {
			server.stop();
		}
	}

	@Test
	public void testUpdateBookmarkOnPush() throws Exception {
		File srcRepoLoc = RepoUtils.cloneRepoToTempLocation("test-annotate", "test-push-src", false);
		File dstRepoLoc = RepoUtils.cloneRepoToTempLocation("test-annotate", "test-push-dst", false);
		final ExecHelper srcRun = new ExecHelper(new OutputParser.Stub(), srcRepoLoc);
		final ExecHelper dstRun = new ExecHelper(new OutputParser.Stub(), dstRepoLoc);
		File f1 = new File(srcRepoLoc, "file1");
		assertTrue("[sanity]", f1.canWrite());
		//
		final String bm1 = "mark1", bm2 = "mark2", bm3 = "mark3", bm4 = "mark4", bm5 = "mark5";
		final int bm2Local = 1, bm2Remote = 6, bm3Local = 7, bm3Remote = 2, bm_4_5 = 3;
		// 1) bm1 - local active bookmark, check that push updates in remote
		srcRun.exec("hg", "bookmark", bm1);
		dstRun.exec("hg", "bookmark", "-r", "8", bm1);
		// 2) bm2 - local points to ancestor of revision remote points to
		srcRun.exec("hg", "bookmark", "-r", String.valueOf(bm2Local), bm2);
		dstRun.exec("hg", "bookmark", "-r", String.valueOf(bm2Remote), bm2);
		// 3) bm3 - remote points to ancestor of revision local one points to   
		srcRun.exec("hg", "bookmark", "-r", String.valueOf(bm3Local), bm3);
		dstRun.exec("hg", "bookmark", "-r", String.valueOf(bm3Remote), bm3);
		// 4) bm4 - remote bookmark, not known locally
		dstRun.exec("hg", "bookmark", "-r", String.valueOf(bm_4_5), bm4);
		// 5) bm5 - local bookmark, not known remotely
		srcRun.exec("hg", "bookmark", "-r", String.valueOf(bm_4_5), bm5);
		//
		HgServer server = new HgServer().start(dstRepoLoc);
		try {
			final HgLookup hgLookup = new HgLookup();
			final HgRepository srcRepo = hgLookup.detect(srcRepoLoc);
			final HgRemoteRepository dstRemote = hgLookup.detect(server.getURL());
			RepoUtils.modifyFileAppend(f1, "change1");
			final HgCommitCommand commitCmd = new HgCommitCommand(srcRepo).message("Commit 1");
			assertTrue(commitCmd.execute().isOk());
			assertEquals(bm1, srcRepo.getBookmarks().getActiveBookmarkName());
			assertEquals(commitCmd.getCommittedRevision(), srcRepo.getBookmarks().getRevision(bm1));
			//
			new HgPushCommand(srcRepo).destination(dstRemote).execute();
			Thread.sleep(300); // let the server perform the update
			//
			HgBookmarks srcBookmarks = srcRepo.getBookmarks();
			final HgChangelog srcClog = srcRepo.getChangelog();
			// first, check local bookmarks are intact
			errorCollector.assertEquals(srcClog.getRevision(bm2Local), srcBookmarks.getRevision(bm2));
			errorCollector.assertEquals(srcClog.getRevision(bm3Local), srcBookmarks.getRevision(bm3));
			errorCollector.assertEquals(null, srcBookmarks.getRevision(bm4));
			errorCollector.assertEquals(srcClog.getRevision(bm_4_5), srcBookmarks.getRevision(bm5));
			// now, check remote bookmarks were touched
			HgRepository dstRepo = hgLookup.detect(dstRepoLoc);
			HgBookmarks dstBookmarks = dstRepo.getBookmarks();
			final HgChangelog dstClog = dstRepo.getChangelog();
			// bm1 changed and points to newly pushed commit.
			// if the test fails (bm1 points to r8), chances are server didn't manage to update
			// bookmarks yet (there's Thread.sleep() above to give it a chance).
			errorCollector.assertEquals(commitCmd.getCommittedRevision(), dstBookmarks.getRevision(bm1));
			// bm2 didn't change
			errorCollector.assertEquals(dstClog.getRevision(bm2Remote), dstBookmarks.getRevision(bm2));
			// bm3 did change, now points to value we've got in srcRepo
			errorCollector.assertEquals(srcClog.getRevision(bm3Local), dstBookmarks.getRevision(bm3));
			// bm4 is not affected
			errorCollector.assertEquals(dstClog.getRevision(bm_4_5), dstBookmarks.getRevision(bm4));
			// bm5 is not known remotely
			errorCollector.assertEquals(null, dstBookmarks.getRevision(bm5));
		} finally {
			server.stop();
		}
	}

	private void checkRepositoriesAreSame(HgRepository srcRepo, HgRepository dstRepo) {
		errorCollector.assertEquals(srcRepo.getChangelog().getRevisionCount(), dstRepo.getChangelog().getRevisionCount());
		errorCollector.assertEquals(srcRepo.getChangelog().getRevision(0), dstRepo.getChangelog().getRevision(0));
		errorCollector.assertEquals(srcRepo.getChangelog().getRevision(TIP), dstRepo.getChangelog().getRevision(TIP));
	}
}