/*******************************************************************************
 * Copyright (c) 2009, 2017 Cloudsmith Inc. and others.
 *
 * This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *     Cloudsmith Inc. - initial API and implementation
 *******************************************************************************/
package org.eclipse.equinox.p2.tests.core;

import static java.nio.file.FileVisitResult.CONTINUE;
import static java.nio.file.StandardOpenOption.CREATE_NEW;

import java.io.File;
import java.io.IOException;
import java.nio.file.FileVisitResult;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.SimpleFileVisitor;
import java.nio.file.attribute.BasicFileAttributes;
import org.eclipse.equinox.internal.p2.touchpoint.natives.SimpleBackupStore;
import org.eclipse.equinox.p2.tests.AbstractProvisioningTest;

public class BackupTest extends AbstractProvisioningTest {
	private static final String BUPREFIX = "backup-test";

	private Path sourceDir;

	private Path aDir;
	private Path aaDir;
	private Path aTxt;

	private Path bDir;
	private Path bTxt;

	private Path abDir;

	private Path cTxt;

	private SimpleBackupStore store;

	/**
	 * <pre>
	 * /p2-backup-test
	 *   /a
	 *     /aa
	 *     	 /a.txt
	 *     	 /b.txt
	 *     /ab
	 *     	 /c.txt
	 *   /b
	 * </pre>
	 */
	@Override
	public void setUp() throws IOException {
		// Don't want to backup under /tmp since it may be it's own file system or an
		// in-memory file system
		String userHome = System.getProperty("user.home");

		sourceDir = Path.of(userHome, "p2-backup-test");
		deleteAll(sourceDir);

		aDir = sourceDir.resolve("a");
		Files.createDirectories(aDir);

		aaDir = aDir.resolve("aa");
		Files.createDirectories(aaDir);

		aTxt = aaDir.resolve("a.txt");
		Files.write(aTxt, "A\nA file with an A".getBytes());

		bTxt = aaDir.resolve("b.txt");
		Files.write(bTxt, "B\nA file with a B".getBytes());

		abDir = aDir.resolve("ab");
		Files.createDirectories(abDir);

		cTxt = abDir.resolve("c.txt");
		Files.write(cTxt, "C\nA file with a C".getBytes());

		bDir = sourceDir.resolve("b");
		Files.createDirectories(bDir);

		store = new SimpleBackupStore(null, BUPREFIX);
	}

	@Override
	public void tearDown() throws IOException {
		deleteAll(sourceDir);
	}

	private static void deleteAll(Path path) throws IOException {
		if (!Files.exists(path)) {
			return;
		}

		Files.walkFileTree(path, new SimpleFileVisitor<Path>() {
			@Override
			public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
				Files.delete(file);
				return CONTINUE;
			}

			@Override
			public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
				if (exc != null) {
					throw exc;
				}
				Files.delete(dir);
				return CONTINUE;
			}
		});
	}

	/**
	 * Test that a path containing ".." can be backed up and restored.
	 */
	public void testBackupRelative() throws IOException {
		Path cTxtRelative = aaDir.resolve(aaDir.relativize(cTxt));

		store.backup(cTxtRelative.toFile());
		assertFalse(Files.exists(cTxt));

		Files.write(cTxt, "XXXX\n- This file should be restored with C".getBytes());

		store.restore();
		assertFileContent("Restore of C failed - not original content", cTxt.toFile(), "C");
		assertNoGarbage(store);
	}

	public void testBackupRestore() throws IOException {
		store.backup(aTxt.toFile());
		assertFalse("File not moved to backup - still exists", Files.exists(aTxt));

		Files.write(aTxt, "XXXX\n- This file should be restored with A".getBytes());

		store.backup(bDir.toFile());
		assertFalse("Backed up directory was not moved", Files.isDirectory(bDir));

		store.backupCopy(bTxt.toFile());
		assertFileContent("File should have been copied", bTxt.toFile(), "B");

		store.restore();
		assertFileContent("Restore of A failed - not original content", aTxt.toFile(), "A");
		assertTrue("Empty directory not restored ok", Files.isDirectory(bDir) && Files.list(bDir).count() == 0);
		assertNoGarbage(store);
	}

	public void testBackupDiscard() throws IOException {
		store.backup(aTxt.toFile());
		assertFalse("File not moved to backup - still exists", Files.exists(aTxt));

		Files.write(aTxt, "XXXX\n- This file should be restored with A".getBytes());

		store.backup(bDir.toFile());
		assertFalse("Backed up directory was not moved", Files.exists(bDir));

		store.discard();
		assertFileContent("Discard of a.txt failed - not new content", aTxt.toFile(), "XXXX");
		assertFalse("Empty directory not discarded - still exists", Files.isDirectory(bDir));
		assertNoGarbage(store);
	}

	public void testBackupAll() throws IOException {
		store.backupAll(aDir.toFile());
		assertFalse("File not moved to backup - still exists", Files.exists(aTxt));
		assertFalse("File bTxt not moved to backup - still exists", Files.exists(bTxt));

		Files.createDirectories(aTxt.getParent());
		Files.write(aTxt, "XXXX\n- This file should be restored with A".getBytes(), CREATE_NEW);

		store.restore();
		assertFileContent("A not restored", aTxt.toFile(), "A");
		assertFileContent("B not restored", bTxt.toFile(), "B");
		assertNoGarbage(store);
	}

	public void testBackupCopyAll() throws IOException {
		store.backupCopyAll(aDir.toFile());
		assertTrue("File not copied to backup - does not exist", Files.exists(aTxt));
		assertTrue("File bTxt not copied to backup - does not exists", Files.exists(bTxt));

		Files.write(aTxt, "XXXX\n- This file should be restored with A".getBytes());
		Files.write(bTxt, "XXXX\n- This file should be restored with B".getBytes());

		store.restore();
		assertFileContent("A not restored", aTxt.toFile(), "A");
		assertFileContent("B not restored", bTxt.toFile(), "B");
		assertNoGarbage(store);
	}

	private static void assertNoGarbage(SimpleBackupStore store) {
		File buDir = store.getBackupRoot();
		assertFalse("Backup directory not cleaned up", buDir.exists());
	}
}