/*
 * Copyright (C) 2010 Google Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *     * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above
 * copyright notice, this list of conditions and the following disclaimer
 * in the documentation and/or other materials provided with the
 * distribution.
 *     * Neither the name of Google Inc. nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "modules/filesystem/DOMFileSystemSync.h"

#include "bindings/core/v8/ExceptionState.h"
#include "core/fileapi/File.h"
#include "core/fileapi/FileError.h"
#include "modules/filesystem/DOMFilePath.h"
#include "modules/filesystem/DirectoryEntrySync.h"
#include "modules/filesystem/ErrorCallback.h"
#include "modules/filesystem/FileEntrySync.h"
#include "modules/filesystem/FileSystemCallbacks.h"
#include "modules/filesystem/FileWriterBaseCallback.h"
#include "modules/filesystem/FileWriterSync.h"
#include "platform/FileMetadata.h"
#include "public/platform/WebFileSystem.h"
#include "public/platform/WebFileSystemCallbacks.h"
#include "wtf/PtrUtil.h"
#include <memory>

namespace blink {

class FileWriterBase;

DOMFileSystemSync* DOMFileSystemSync::create(DOMFileSystemBase* fileSystem) {
  return new DOMFileSystemSync(fileSystem->m_context, fileSystem->name(),
                               fileSystem->type(), fileSystem->rootURL());
}

DOMFileSystemSync::DOMFileSystemSync(ExecutionContext* context,
                                     const String& name,
                                     FileSystemType type,
                                     const KURL& rootURL)
    : DOMFileSystemBase(context, name, type, rootURL),
      m_rootEntry(DirectoryEntrySync::create(this, DOMFilePath::root)) {}

DOMFileSystemSync::~DOMFileSystemSync() {}

void DOMFileSystemSync::reportError(ErrorCallbackBase* errorCallback,
                                    FileError::ErrorCode fileError) {
  errorCallback->invoke(fileError);
}

DirectoryEntrySync* DOMFileSystemSync::root() {
  return m_rootEntry.get();
}

namespace {

class CreateFileHelper final : public AsyncFileSystemCallbacks {
 public:
  class CreateFileResult : public GarbageCollected<CreateFileResult> {
   public:
    static CreateFileResult* create() { return new CreateFileResult(); }

    bool m_failed;
    int m_code;
    Member<File> m_file;

    DEFINE_INLINE_TRACE() { visitor->trace(m_file); }

   private:
    CreateFileResult() : m_failed(false), m_code(0) {}
  };

  static std::unique_ptr<AsyncFileSystemCallbacks> create(
      CreateFileResult* result,
      const String& name,
      const KURL& url,
      FileSystemType type) {
    return wrapUnique(static_cast<AsyncFileSystemCallbacks*>(
        new CreateFileHelper(result, name, url, type)));
  }

  void didFail(int code) override {
    m_result->m_failed = true;
    m_result->m_code = code;
  }

  ~CreateFileHelper() override {}

  void didCreateSnapshotFile(const FileMetadata& metadata,
                             PassRefPtr<BlobDataHandle> snapshot) override {
    // We can't directly use the snapshot blob data handle because the content
    // type on it hasn't been set.  The |snapshot| param is here to provide a a
    // chain of custody thru thread bridging that is held onto until *after*
    // we've coined a File with a new handle that has the correct type set on
    // it. This allows the blob storage system to track when a temp file can and
    // can't be safely deleted.

    m_result->m_file =
        DOMFileSystemBase::createFile(metadata, m_url, m_type, m_name);
  }

  bool shouldBlockUntilCompletion() const override { return true; }

 private:
  CreateFileHelper(CreateFileResult* result,
                   const String& name,
                   const KURL& url,
                   FileSystemType type)
      : m_result(result), m_name(name), m_url(url), m_type(type) {}

  Persistent<CreateFileResult> m_result;
  String m_name;
  KURL m_url;
  FileSystemType m_type;
};

}  // namespace

File* DOMFileSystemSync::createFile(const FileEntrySync* fileEntry,
                                    ExceptionState& exceptionState) {
  KURL fileSystemURL = createFileSystemURL(fileEntry);
  CreateFileHelper::CreateFileResult* result(
      CreateFileHelper::CreateFileResult::create());
  fileSystem()->createSnapshotFileAndReadMetadata(
      fileSystemURL, CreateFileHelper::create(result, fileEntry->name(),
                                              fileSystemURL, type()));
  if (result->m_failed) {
    exceptionState.throwDOMException(
        result->m_code, "Could not create '" + fileEntry->name() + "'.");
    return nullptr;
  }
  return result->m_file.get();
}

namespace {

class ReceiveFileWriterCallback final : public FileWriterBaseCallback {
 public:
  static ReceiveFileWriterCallback* create() {
    return new ReceiveFileWriterCallback();
  }

  void handleEvent(FileWriterBase*) override {}

 private:
  ReceiveFileWriterCallback() {}
};

class LocalErrorCallback final : public ErrorCallbackBase {
 public:
  static LocalErrorCallback* create(FileError::ErrorCode& errorCode) {
    return new LocalErrorCallback(errorCode);
  }

  void invoke(FileError::ErrorCode error) override {
    DCHECK_NE(error, FileError::kOK);
    m_errorCode = error;
  }

 private:
  explicit LocalErrorCallback(FileError::ErrorCode& errorCode)
      : m_errorCode(errorCode) {}

  FileError::ErrorCode& m_errorCode;
};

}  // namespace

FileWriterSync* DOMFileSystemSync::createWriter(
    const FileEntrySync* fileEntry,
    ExceptionState& exceptionState) {
  ASSERT(fileEntry);

  FileWriterSync* fileWriter = FileWriterSync::create();
  ReceiveFileWriterCallback* successCallback =
      ReceiveFileWriterCallback::create();
  FileError::ErrorCode errorCode = FileError::kOK;
  LocalErrorCallback* errorCallback = LocalErrorCallback::create(errorCode);

  std::unique_ptr<AsyncFileSystemCallbacks> callbacks =
      FileWriterBaseCallbacks::create(fileWriter, successCallback,
                                      errorCallback, m_context);
  callbacks->setShouldBlockUntilCompletion(true);

  fileSystem()->createFileWriter(createFileSystemURL(fileEntry), fileWriter,
                                 std::move(callbacks));
  if (errorCode != FileError::kOK) {
    FileError::throwDOMException(exceptionState, errorCode);
    return 0;
  }
  return fileWriter;
}

DEFINE_TRACE(DOMFileSystemSync) {
  DOMFileSystemBase::trace(visitor);
  visitor->trace(m_rootEntry);
}

}  // namespace blink