/*
    * Copyright (C) 2010, Robin Rosenberg and others
    *
    * This program and the accompanying materials are made available under the
    * terms of the Eclipse Distribution License v. 1.0 which is available at
    * https://www.eclipse.org/org/documents/edl-v10.php.
    *
    * SPDX-License-Identifier: BSD-3-Clause
    */
  package org.eclipse.jgit.internal.storage.file;
  
  import static org.eclipse.jgit.junit.JGitTestUtil.read;
  import static org.eclipse.jgit.junit.JGitTestUtil.write;
  import static org.junit.Assert.assertEquals;
  import static org.junit.Assert.assertFalse;
  import static org.junit.Assert.assertTrue;
  import static org.junit.Assert.fail;
  
  import java.io.File;
  import java.io.IOException;
  import java.io.OutputStream;
  import java.nio.file.Files;
  import java.nio.file.Path;
  import java.nio.file.StandardCopyOption;
  import java.nio.file.StandardOpenOption;
  import java.nio.file.attribute.FileTime;
  import java.time.Duration;
  import java.time.Instant;
  import java.util.ArrayList;
  import java.util.concurrent.TimeUnit;
  
  import org.eclipse.jgit.junit.MockSystemReader;
  import org.eclipse.jgit.util.FS;
  import org.eclipse.jgit.util.FS.FileStoreAttributes;
  import org.eclipse.jgit.util.FileUtils;
  import org.eclipse.jgit.util.Stats;
  import org.eclipse.jgit.util.SystemReader;
  import org.junit.After;
  import org.junit.Assume;
  import org.junit.Before;
  import org.junit.Test;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  public class FileSnapshotTest {
  	private static final Logger LOG = LoggerFactory
  			.getLogger(FileSnapshotTest.class);
  
  	private Path trash;
  
  	private FileStoreAttributes fsAttrCache;
  
  	@Before
  	public void setUp() throws Exception {
  		SystemReader.setInstance(new MockSystemReader());
  		trash = Files.createTempDirectory("tmp_");
  		// measure timer resolution before the test to avoid time critical tests
  		// are affected by time needed for measurement
  		fsAttrCache = FS
  				.getFileStoreAttributes(trash.getParent());
  	}
  
  	@Before
  	@After
  	public void tearDown() throws Exception {
  		FileUtils.delete(trash.toFile(),
  				FileUtils.RECURSIVE | FileUtils.SKIP_MISSING);
  	}
  
  	private static void waitNextTick(Path f) throws IOException {
  		Instant initialLastModified = FS.DETECTED.lastModifiedInstant(f);
  		do {
  			FS.DETECTED.setLastModified(f, Instant.now());
  		} while (FS.DETECTED.lastModifiedInstant(f)
  				.equals(initialLastModified));
  	}
  
  	/**
  	 * Change data and time stamp.
  	 *
  	 * @throws Exception
  	 */
  	@Test
  	public void testActuallyIsModifiedTrivial() throws Exception {
  		Path f1 = createFile("simple");
  		waitNextTick(f1);
  		FileSnapshot save = FileSnapshot.save(f1.toFile());
  		append(f1, (byte) 'x');
  		waitNextTick(f1);
  		assertTrue(save.isModified(f1.toFile()));
  	}
  
  	/**
  	 * Create a file, but don't wait long enough for the difference between file
  	 * system clock and system clock to be significant. Assume the file may have
  	 * been modified. It may have been, but the clock alone cannot determine
  	 * this
  	 *
  	 * @throws Exception
 	 */
 	@Test
 	public void testNewFileWithWait() throws Exception {
 		// if filesystem timestamp resolution is high the snapshot won't be
 		// racily clean
 		Assume.assumeTrue(
 				fsAttrCache.getFsTimestampResolution()
 						.compareTo(Duration.ofMillis(10)) > 0);
 		Path f1 = createFile("newfile");
 		waitNextTick(f1);
 		FileSnapshot save = FileSnapshot.save(f1.toFile());
 		TimeUnit.NANOSECONDS.sleep(
 				fsAttrCache.getFsTimestampResolution().dividedBy(2).toNanos());
 		assertTrue(save.isModified(f1.toFile()));
 	}
 
 	/**
 	 * Same as {@link #testNewFileWithWait()} but do not wait at all
 	 *
 	 * @throws Exception
 	 */
 	@Test
 	public void testNewFileNoWait() throws Exception {
 		// if filesystem timestamp resolution is smaller than time needed to
 		// create a file and FileSnapshot the snapshot won't be racily clean
 		Assume.assumeTrue(fsAttrCache.getFsTimestampResolution()
 				.compareTo(Duration.ofMillis(10)) > 0);
 		for (int i = 0; i < 50; i++) {
 			Instant start = Instant.now();
 			Path f1 = createFile("newfile");
 			FileSnapshot save = FileSnapshot.save(f1.toFile());
 			Duration res = FS.getFileStoreAttributes(f1)
 					.getFsTimestampResolution();
 			Instant end = Instant.now();
 			if (Duration.between(start, end)
 					.compareTo(res.multipliedBy(2)) > 0) {
 				// This test is racy: under load, there may be a delay between createFile() and
 				// FileSnapshot.save(). This can stretch the time between the read TS and FS
 				// creation TS to the point that it exceeds the FS granularity, and we
 				// conclude it cannot be racily clean, and therefore must be really clean.
 				//
 				// This should be relatively uncommon.
 				continue;
 			}
 			// The file wasn't really modified, but it looks just like a "maybe racily clean"
 			// file.
 			assertTrue(save.isModified(f1.toFile()));
 			return;
 		}
 		fail("too much load for this test");
 	}
 
 	/**
 	 * Simulate packfile replacement in same file which may occur if set of
 	 * objects in the pack is the same but pack config was different. On Posix
 	 * filesystems this should change the inode (filekey in java.nio
 	 * terminology).
 	 *
 	 * @throws Exception
 	 */
 	@Test
 	public void testSimulatePackfileReplacement() throws Exception {
 		Assume.assumeFalse(SystemReader.getInstance().isWindows());
 		Path f1 = createFile("file"); // inode y
 		Path f2 = createFile("fool"); // Guarantees new inode x
 		// wait on f2 since this method resets lastModified of the file
 		// and leaves lastModified of f1 untouched
 		waitNextTick(f2);
 		waitNextTick(f2);
 		FileTime timestamp = Files.getLastModifiedTime(f1);
 		FileSnapshot save = FileSnapshot.save(f1.toFile());
 		Files.move(f2, f1, // Now "file" is inode x
 				StandardCopyOption.REPLACE_EXISTING,
 				StandardCopyOption.ATOMIC_MOVE);
 		Files.setLastModifiedTime(f1, timestamp);
 		assertTrue(save.isModified(f1.toFile()));
 		assertTrue("unexpected change of fileKey", save.wasFileKeyChanged());
 		assertFalse("unexpected size change", save.wasSizeChanged());
 		assertFalse("unexpected lastModified change",
 				save.wasLastModifiedChanged());
 		assertFalse("lastModified was unexpectedly racily clean",
 				save.wasLastModifiedRacilyClean());
 	}
 
 	/**
 	 * Append a character to a file to change its size and set original
 	 * lastModified
 	 *
 	 * @throws Exception
 	 */
 	@Test
 	public void testFileSizeChanged() throws Exception {
 		Path f = createFile("file");
 		FileTime timestamp = Files.getLastModifiedTime(f);
 		FileSnapshot save = FileSnapshot.save(f.toFile());
 		append(f, (byte) 'x');
 		Files.setLastModifiedTime(f, timestamp);
 		assertTrue(save.isModified(f.toFile()));
 		assertTrue(save.wasSizeChanged());
 	}
 
 	@Test
 	public void fileSnapshotEquals() throws Exception {
 		// 0 sized FileSnapshot.
 		FileSnapshot fs1 = FileSnapshot.MISSING_FILE;
 		// UNKNOWN_SIZE FileSnapshot.
 		FileSnapshot fs2 = FileSnapshot.save(fs1.lastModifiedInstant());
 
 		assertTrue(fs1.equals(fs2));
 		assertTrue(fs2.equals(fs1));
 	}
 
 	@SuppressWarnings("boxing")
 	@Test
 	public void detectFileModified() throws IOException {
 		int failures = 0;
 		long racyNanos = 0;
 		final int COUNT = 10000;
 		ArrayList<Long> deltas = new ArrayList<>();
 		File f = createFile("test").toFile();
 		for (int i = 0; i < COUNT; i++) {
 			write(f, "a");
 			FileSnapshot snapshot = FileSnapshot.save(f);
 			assertEquals("file should contain 'a'", "a", read(f));
 			write(f, "b");
 			if (!snapshot.isModified(f)) {
 				deltas.add(snapshot.lastDelta());
 				racyNanos = snapshot.lastRacyThreshold();
 				failures++;
 			}
 			assertEquals("file should contain 'b'", "b", read(f));
 		}
 		if (failures > 0) {
 			Stats stats = new Stats();
 			LOG.debug(
 					"delta [ns] since modification FileSnapshot failed to detect");
 			for (Long d : deltas) {
 				stats.add(d);
 				LOG.debug(String.format("%,d", d));
 			}
 			LOG.error(
 					"count, failures, eff. racy threshold [ns], delta min [ns],"
 							+ " delta max [ns], delta avg [ns],"
 							+ " delta stddev [ns]");
 			LOG.error(String.format(
 					"%,d, %,d, %,d, %,.0f, %,.0f, %,.0f, %,.0f", COUNT,
 					failures, racyNanos, stats.min(), stats.max(),
 					stats.avg(), stats.stddev()));
 		}
 		assertTrue(
 				String.format(
 						"FileSnapshot: failures to detect file modifications"
 								+ " %d out of %d\n"
 								+ "timestamp resolution %d µs"
 								+ " min racy threshold %d µs"
 						, failures, COUNT,
 						fsAttrCache.getFsTimestampResolution().toNanos() / 1000,
 						fsAttrCache.getMinimalRacyInterval().toNanos() / 1000),
 				failures == 0);
 	}
 
 	private Path createFile(String string) throws IOException {
 		Files.createDirectories(trash);
 		return Files.createTempFile(trash, string, "tdat");
 	}
 
 	private static void append(Path f, byte b) throws IOException {
 		try (OutputStream os = Files.newOutputStream(f,
 				StandardOpenOption.APPEND)) {
 			os.write(b);
 		}
 	}
 
 }