/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements. See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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.apache.hadoop.fs.contract;

import static org.apache.hadoop.fs.contract.ContractTestUtils.assertCapabilities;
import static org.apache.hadoop.fs.contract.ContractTestUtils.dataset;
import static org.apache.hadoop.fs.contract.ContractTestUtils.getFileStatusEventually;
import static org.apache.hadoop.fs.contract.ContractTestUtils.skip;
import static org.apache.hadoop.fs.contract.ContractTestUtils.touch;
import static org.apache.hadoop.fs.contract.ContractTestUtils.writeDataset;
import static org.apache.hadoop.fs.contract.ContractTestUtils.writeTextFile;
import static org.apache.hadoop.fs.statistics.IOStatisticsLogging.ioStatisticsSourceToString;
import static org.assertj.core.api.Assertions.fail;
import static org.assertj.core.api.Assumptions.assumeThat;

import java.io.FileNotFoundException;
import java.io.IOException;
import org.apache.hadoop.fs.FSDataInputStream;
import org.apache.hadoop.fs.FSDataOutputStream;
import org.apache.hadoop.fs.FileAlreadyExistsException;
import org.apache.hadoop.fs.FileStatus;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.ParentNotDirectoryException;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.fs.StreamCapabilities;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Test creating files, overwrite options etc.
 */
public abstract class AbstractContractCreateTest extends
    AbstractFSContractTestBase {

  private static final Logger LOG =
      LoggerFactory.getLogger(AbstractContractCreateTest.class);

  /**
   * How long to wait for a path to become visible.
   */
  public static final int CREATE_TIMEOUT = 15000;

  protected Path path(String filepath, boolean useBuilder) throws IOException {
    return super.path(filepath  + (useBuilder ? "" : "-builder"));
  }

  private void testCreateNewFile(boolean useBuilder) throws Throwable {
    describe("Foundational 'create a file' test, using builder API=" +
        useBuilder);
    Path path = path("testCreateNewFile", useBuilder);
    byte[] data = dataset(256, 'a', 'z');
    writeDataset(getFileSystem(), path, data, data.length, 1024 * 1024, false,
        useBuilder);
    ContractTestUtils.verifyFileContents(getFileSystem(), path, data);
  }

  @Test
  public void testCreateNewFile() throws Throwable {
    testCreateNewFile(true);
    testCreateNewFile(false);
  }

  private void testCreateFileOverExistingFileNoOverwrite(boolean useBuilder)
      throws Throwable {
    describe("Verify overwriting an existing file fails, using builder API=" +
        useBuilder);
    Path path = path("testCreateFileOverExistingFileNoOverwrite", useBuilder);
    byte[] data = dataset(256, 'a', 'z');
    writeDataset(getFileSystem(), path, data, data.length, 1024, false);
    byte[] data2 = dataset(10 * 1024, 'A', 'Z');
    try {
      writeDataset(getFileSystem(), path, data2, data2.length, 1024, false,
          useBuilder);
      fail("writing without overwrite unexpectedly succeeded");
    } catch (FileAlreadyExistsException expected) {
      //expected
      handleExpectedException(expected);
    } catch (IOException relaxed) {
      handleRelaxedException("Creating a file over a file with overwrite==false",
                             "FileAlreadyExistsException",
                             relaxed);
    }
  }

  @Test
  public void testCreateFileOverExistingFileNoOverwrite() throws Throwable {
    testCreateFileOverExistingFileNoOverwrite(false);
    testCreateFileOverExistingFileNoOverwrite(true);
  }

  private void testOverwriteExistingFile(boolean useBuilder) throws Throwable {
    describe("Overwrite an existing file and verify the new data is there, " +
        "use builder API=" + useBuilder);
    Path path = path("testOverwriteExistingFile", useBuilder);
    byte[] data = dataset(256, 'a', 'z');
    writeDataset(getFileSystem(), path, data, data.length, 1024, false,
        useBuilder);
    ContractTestUtils.verifyFileContents(getFileSystem(), path, data);
    byte[] data2 = dataset(10 * 1024, 'A', 'Z');
    writeDataset(getFileSystem(), path, data2, data2.length, 1024, true,
        useBuilder);
    ContractTestUtils.verifyFileContents(getFileSystem(), path, data2);
  }

  /**
   * This test catches some eventual consistency problems that blobstores exhibit,
   * as we are implicitly verifying that updates are consistent. This
   * is why different file lengths and datasets are used
   */
  @Test
  public void testOverwriteExistingFile() throws Throwable {
    testOverwriteExistingFile(false);
    testOverwriteExistingFile(true);
  }

  private void testOverwriteEmptyDirectory(boolean useBuilder)
      throws Throwable {
    describe("verify trying to create a file over an empty dir fails, " +
        "use builder API=" + useBuilder);
    Path path = path("testOverwriteEmptyDirectory");
    mkdirs(path);
    assertIsDirectory(path);
    byte[] data = dataset(256, 'a', 'z');
    try {
      writeDataset(getFileSystem(), path, data, data.length, 1024, true,
          useBuilder);
      assertIsDirectory(path);
      fail("write of file over empty dir succeeded");
    } catch (FileAlreadyExistsException expected) {
      //expected
      handleExpectedException(expected);
    } catch (IOException e) {
      handleRelaxedException("overwriting a dir with a file ",
                             "FileAlreadyExistsException",
                             e);
    }
    assertIsDirectory(path);
  }

  @Test
  public void testOverwriteEmptyDirectory() throws Throwable {
    testOverwriteEmptyDirectory(false);
    testOverwriteEmptyDirectory(true);
  }

  private void testOverwriteNonEmptyDirectory(boolean useBuilder)
      throws Throwable {
    describe("verify trying to create a file over a non-empty dir fails, " +
        "use builder API=" + useBuilder);
    Path path = path("testOverwriteNonEmptyDirectory");
    mkdirs(path);
    try {
      assertIsDirectory(path);
    } catch (AssertionError failure) {
      // file/directory hack surfaces here
      assumeThat(!isSupported(CREATE_OVERWRITES_DIRECTORY))
          .withFailMessage(failure.toString())
          .isTrue();
      // else: rethrow
      throw failure;
    }
    Path child = new Path(path, "child");
    writeTextFile(getFileSystem(), child, "child file", true);
    byte[] data = dataset(256, 'a', 'z');
    try {
      writeDataset(getFileSystem(), path, data, data.length, 1024,
                   true, useBuilder);
      FileStatus status = getFileSystem().getFileStatus(path);

      boolean isDir = status.isDirectory();
      if (!isDir && isSupported(CREATE_OVERWRITES_DIRECTORY)) {
        // For some file systems, downgrade to a skip so that the failure is
        // visible in test results.
        skip("This Filesystem allows a file to overwrite a directory");
      }
      fail("write of file over dir succeeded");
    } catch (FileAlreadyExistsException expected) {
      //expected
      handleExpectedException(expected);
    } catch (IOException e) {
      handleRelaxedException("overwriting a dir with a file ",
                             "FileAlreadyExistsException",
                             e);
    }
    assertIsDirectory(path);
    assertIsFile(child);
  }

  @Test
  public void testOverwriteNonEmptyDirectory() throws Throwable {
    testOverwriteNonEmptyDirectory(false);
    testOverwriteNonEmptyDirectory(true);
  }

  @Test
  public void testCreatedFileIsImmediatelyVisible() throws Throwable {
    describe("verify that a newly created file exists as soon as open returns");
    Path path = path("testCreatedFileIsImmediatelyVisible");
    try (FSDataOutputStream out = getFileSystem().create(path, false, 4096, (short) 1, 1024)) {
      if (!getFileSystem().exists(path)) {

        if (isSupported(CREATE_VISIBILITY_DELAYED)) {
          // For some file systems, downgrade to a skip so that the failure is
          // visible in test results.
          skip("This Filesystem delays visibility of newly created files");
        }
        assertPathExists("expected path to be visible before anything written",
                         path);
      }
    }
  }

  @Test
  public void testCreatedFileIsVisibleOnFlush() throws Throwable {
    describe("verify that a newly created file exists once a flush has taken "
        + "place");
    Path path = path("testCreatedFileIsVisibleOnFlush");
    FileSystem fs = getFileSystem();
    try (FSDataOutputStream out = fs.create(path, false, 4096, (short) 1, 1024)) {
      out.write('a');
      out.flush();
      if (!fs.exists(path)) {
        if (isSupported(IS_BLOBSTORE) ||
            isSupported(CREATE_VISIBILITY_DELAYED)) {
          // object store or some file systems: downgrade to a skip so that the
          // failure is visible in test results
          skip("For object store or some file systems, newly created files are"
              + " not immediately visible");
        }
        assertPathExists("expected path to be visible before file closed",
            path);
      }
    }
  }

  @Test
  public void testCreatedFileIsEventuallyVisible() throws Throwable {
    describe("verify a written to file is visible after the stream is closed");
    Path path = path("testCreatedFileIsEventuallyVisible");
    FileSystem fs = getFileSystem();
    try (FSDataOutputStream out = fs.create(path, false, 4096, (short) 1, 1024)) {
      out.write(0x01);
      out.close();
      getFileStatusEventually(fs, path, CREATE_TIMEOUT);
    }
  }

  @Test
  public void testFileStatusBlocksizeNonEmptyFile() throws Throwable {
    describe("validate the block size of a filesystem and files within it");
    FileSystem fs = getFileSystem();

    long rootPath = fs.getDefaultBlockSize(path("/"));
    Assertions.assertThat(rootPath)
        .withFailMessage("Root block size is invalid " + rootPath)
        .isPositive();

    Path path = path("testFileStatusBlocksizeNonEmptyFile");
    byte[] data = dataset(256, 'a', 'z');

    writeDataset(fs, path, data, data.length, 1024 * 1024, false);

    validateBlockSize(fs, path, 1);
  }

  @Test
  public void testFileStatusBlocksizeEmptyFile() throws Throwable {
    describe("check that an empty file may return a 0-byte blocksize");
    FileSystem fs = getFileSystem();
    Path path = path("testFileStatusBlocksizeEmptyFile");
    ContractTestUtils.touch(fs, path);
    validateBlockSize(fs, path, 0);
  }

  private void validateBlockSize(FileSystem fs, Path path, int minValue)
      throws IOException, InterruptedException {
    FileStatus status =
        getFileStatusEventually(fs, path, CREATE_TIMEOUT);
    String statusDetails = status.toString();
    Assertions.assertThat(status.getBlockSize())
        .withFailMessage("File status block size too low:  " +
            statusDetails + " min value: " + minValue)
        .isGreaterThanOrEqualTo(minValue);
    long defaultBlockSize = fs.getDefaultBlockSize(path);
    Assertions.assertThat(defaultBlockSize)
        .withFailMessage("fs.getDefaultBlockSize(" + path + ") size " +
            defaultBlockSize + " is below the minimum of " + minValue)
        .isGreaterThanOrEqualTo(minValue);
  }

  @Test
  public void testCreateMakesParentDirs() throws Throwable {
    describe("check that after creating a file its parent directories exist");
    FileSystem fs = getFileSystem();
    Path grandparent = path("testCreateCreatesAndPopulatesParents");
    Path parent = new Path(grandparent, "parent");
    Path child = new Path(parent, "child");
    touch(fs, child);
    Assertions.assertThat(fs.listStatus(parent))
        .withFailMessage("List status of parent should include the 1 child file")
        .hasSize(1);
    Assertions.assertThat(fs.getFileStatus(parent).isDirectory())
        .withFailMessage("Parent directory does not appear to be a directory")
        .isTrue();
    Assertions.assertThat(fs.listStatus(grandparent))
        .withFailMessage("List status of grandparent should include the 1 parent dir")
        .hasSize(1);
    Assertions.assertThat(fs.getFileStatus(grandparent).isDirectory())
        .withFailMessage("Grandparent directory does not appear to be a directory")
        .isTrue();
  }

  @Test
  public void testCreateFileUnderFile() throws Throwable {
    describe("Verify that it is forbidden to create file/file");
    if (isSupported(CREATE_FILE_UNDER_FILE_ALLOWED)) {
      // object store or some file systems: downgrade to a skip so that the
      // failure is visible in test results
      skip("This filesystem supports creating files under files");
    }
    Path grandparent = methodPath();
    Path parent = new Path(grandparent, "parent");
    expectCreateUnderFileFails(
        "creating a file under a file",
        grandparent,
        parent);
  }

  @Test
  public void testCreateUnderFileSubdir() throws Throwable {
    describe("Verify that it is forbidden to create file/dir/file");
    if (isSupported(CREATE_FILE_UNDER_FILE_ALLOWED)) {
      // object store or some file systems: downgrade to a skip so that the
      // failure is visible in test results
      skip("This filesystem supports creating files under files");
    }
    Path grandparent = methodPath();
    Path parent = new Path(grandparent, "parent");
    Path child = new Path(parent, "child");
    expectCreateUnderFileFails(
        "creating a file under a subdirectory of a file",
        grandparent,
        child);
  }

  @Test
  public void testMkdirUnderFile() throws Throwable {
    describe("Verify that it is forbidden to create file/dir");
    Path grandparent = methodPath();
    Path parent = new Path(grandparent, "parent");
    expectMkdirsUnderFileFails("mkdirs() under a file",
        grandparent, parent);
  }

  @Test
  public void testMkdirUnderFileSubdir() throws Throwable {
    describe("Verify that it is forbidden to create file/dir/dir");
    Path grandparent = methodPath();
    Path parent = new Path(grandparent, "parent");
    Path child = new Path(parent, "child");
    expectMkdirsUnderFileFails("mkdirs() file/dir",
        grandparent, child);

    try {
      // create the child
      mkdirs(child);
    } catch (FileAlreadyExistsException | ParentNotDirectoryException ex) {
      // either of these may be raised.
      handleExpectedException(ex);
    } catch (IOException e) {
      handleRelaxedException("creating a file under a subdirectory of a file ",
          "FileAlreadyExistsException",
          e);
    }
  }

  /**
   * Expect that touch() will fail because the parent is a file.
   * @param action action for message
   * @param file filename to create
   * @param descendant path under file
   * @throws Exception failure
   */
  protected void expectCreateUnderFileFails(String action,
      Path file, Path descendant)
      throws Exception {
    createFile(file);
    try {
      // create the child
      createFile(descendant);
    } catch (FileAlreadyExistsException | ParentNotDirectoryException ex) {
      //expected
      handleExpectedException(ex);
    } catch (IOException e) {
      handleRelaxedException(action,
          "ParentNotDirectoryException",
          e);
    }
  }

  protected void expectMkdirsUnderFileFails(String action,
      Path file, Path descendant)
      throws Exception {
    createFile(file);
    try {
      // now mkdirs
      mkdirs(descendant);
    } catch (FileAlreadyExistsException | ParentNotDirectoryException ex) {
      //expected
      handleExpectedException(ex);
    } catch (IOException e) {
      handleRelaxedException(action,
          "ParentNotDirectoryException",
          e);
    }
  }

  private void createFile(Path path) throws IOException {
    byte[] data = dataset(256, 'a', 'z');
    FileSystem fs = getFileSystem();
    writeDataset(fs, path, data, data.length, 1024 * 1024,
        true);
  }

  @Test
  public void testSyncable() throws Throwable {
    describe("test declared and actual Syncable behaviors");
    FileSystem fs = getFileSystem();
    boolean supportsFlush = isSupported(SUPPORTS_HFLUSH);
    boolean supportsSync = isSupported(SUPPORTS_HSYNC);
    boolean metadataUpdatedOnHSync = isSupported(METADATA_UPDATED_ON_HSYNC);

    validateSyncableSemantics(fs,
        supportsSync,
        supportsFlush,
        metadataUpdatedOnHSync);
  }

  /**
   * Validate the semantics of syncable.
   * @param fs filesystem
   * @param supportsSync sync is present
   * @param supportsFlush flush is present.
   * @param metadataUpdatedOnHSync  Is the metadata updated after an hsync?
   * @throws IOException failure
   */
  protected void validateSyncableSemantics(final FileSystem fs,
      final boolean supportsSync,
      final boolean supportsFlush,
      final boolean metadataUpdatedOnHSync)
      throws IOException {
    Path path = methodPath();
    LOG.info("Expecting files under {} to have supportsSync={}"
            + " and supportsFlush={}; metadataUpdatedOnHSync={}",
        path, supportsSync, supportsFlush, metadataUpdatedOnHSync);

    try (FSDataOutputStream out = fs.create(path, true)) {
      LOG.info("Created output stream {}", out);

      // probe stream for support for flush/sync, whose capabilities
      // of supports/does not support must match what is expected
      String[] hflushCapabilities = {
          StreamCapabilities.HFLUSH
      };
      String[] hsyncCapabilities = {
          StreamCapabilities.HSYNC
      };
      if (supportsFlush) {
        assertCapabilities(out, hflushCapabilities, null);
      } else {
        assertCapabilities(out, null, hflushCapabilities);
      }
      if (supportsSync) {
        assertCapabilities(out, hsyncCapabilities, null);
      } else {
        assertCapabilities(out, null, hsyncCapabilities);
      }

      // write one byte, then hflush it
      out.write('a');
      try {
        out.hflush();
        if (!supportsFlush) {
          // FSDataOutputStream silently downgrades to flush() here.
          // This is not good, but if changed some applications
          // break writing to some stores.
          LOG.warn("FS doesn't support Syncable.hflush(),"
              + " but doesn't reject it either.");
        }
      } catch (UnsupportedOperationException e) {
        if (supportsFlush) {
          throw new AssertionError("hflush not supported", e);
        }
      }

      // write a second byte, then hsync it.
      out.write('b');
      try {
        out.hsync();
      } catch (UnsupportedOperationException e) {
        if (supportsSync) {
          throw new AssertionError("HSync not supported", e);
        }
      }

      if (supportsSync) {
        // if sync really worked, data MUST be visible here

        // first the metadata which MUST be present
        final FileStatus st = fs.getFileStatus(path);
        if (metadataUpdatedOnHSync) {
          // not all stores reliably update it, HDFS/webHDFS in particular
          Assertions.assertThat(st.getLen())
              .withFailMessage("Metadata not updated during write " + st)
              .isEqualTo(2);
        }

        // there's no way to verify durability, but we can
        // at least verify a new file input stream reads
        // the data
        try (FSDataInputStream in = fs.open(path)) {
          Assertions.assertThat(in.read()).isEqualTo('a');
          Assertions.assertThat(in.read()).isEqualTo('b');
          Assertions.assertThat(in.read()).isEqualTo(-1);
          LOG.info("Successfully read synced data on a new reader {}", in);
        }
      } else {
        // no sync. Let's do a flush and see what happens.
        out.flush();
        // Now look at the filesystem.
        try (FSDataInputStream in = fs.open(path)) {
          int c = in.read();
          if (c == -1) {
            // nothing was synced; sync and flush really aren't there.
            LOG.info("sync and flush are declared unsupported"
                + " -flushed changes were not saved");

          } else {
            LOG.info("sync and flush are declared unsupported"
                + " - but the stream does offer some sync/flush semantics");
          }
          // close outside a finally as we do want to see any exception raised.
          in.close();

        } catch (FileNotFoundException e) {
          // that's OK if it's an object store, but not if its a real
          // FS
          if (!isSupported(IS_BLOBSTORE)) {
            throw e;
          } else {
            LOG.warn(
                "Output file was not created; this is an object store with different"
                    + " visibility semantics");
          }
        }
      }
      // close the output stream
      out.close();

      final String stats = ioStatisticsSourceToString(out);
      if (!stats.isEmpty()) {
        LOG.info("IOStatistics {}", stats);
      }
    }
  }
}
