// Copyright 2014 The Chromium OS Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <clocale>
#include <sstream>

#include "ppapi/cpp/instance.h"
#include "ppapi/cpp/instance_handle.h"
#include "ppapi/cpp/logging.h"
#include "ppapi/cpp/module.h"
#include "ppapi/cpp/var_dictionary.h"
#include "ppapi/utility/threading/lock.h"
#include "ppapi/utility/threading/simple_thread.h"

#include "compressor.h"
#include "request.h"
#include "volume.h"

namespace {

typedef std::map<std::string, Volume*>::const_iterator volume_iterator;
typedef std::map<int, Compressor*>::const_iterator compressor_iterator;

// An internal implementation of JavaScriptMessageSenderInterface. This class
// handles all communication from the module to the JavaScript code. Thread
// safety is ensured only for PNaCl, not NaCl. See crbug.com/412692 and
// crbug.com/413513.
class JavaScriptMessageSender : public JavaScriptMessageSenderInterface {
 public:
  // JavaScriptMessageSender does not own the instance pointer.
  explicit JavaScriptMessageSender(pp::Instance* instance)
      : instance_(instance) {}

  virtual void SendFileSystemError(const std::string& file_system_id,
                                   const std::string& request_id,
                                   const std::string& message) {
    JavaScriptPostMessage(
        request::CreateFileSystemError(file_system_id, request_id, message));
  }

  virtual void SendCompressorError(int compressor_id,
                                   const std::string& message) {
    JavaScriptPostMessage(
        request::CreateCompressorError(compressor_id, message));
  }

  virtual void SendFileChunkRequest(const std::string& file_system_id,
                                    const std::string& request_id,
                                    int64_t offset,
                                    int64_t bytes_to_read) {
    PP_DCHECK(offset >= 0);
    PP_DCHECK(bytes_to_read > 0);
    JavaScriptPostMessage(request::CreateReadChunkRequest(
        file_system_id, request_id, offset, bytes_to_read));
  }

  virtual void SendPassphraseRequest(const std::string& file_system_id,
                                     const std::string& request_id) {
    JavaScriptPostMessage(request::CreateReadPassphraseRequest(
        file_system_id, request_id));
  }

  virtual void SendReadMetadataDone(const std::string& file_system_id,
                                    const std::string& request_id,
                                    const pp::VarDictionary& metadata) {
    JavaScriptPostMessage(request::CreateReadMetadataDoneResponse(
        file_system_id, request_id, metadata));
  }

  virtual void SendOpenFileDone(const std::string& file_system_id,
                                const std::string& request_id) {
    JavaScriptPostMessage(
        request::CreateOpenFileDoneResponse(file_system_id, request_id));
  }

  virtual void SendCloseFileDone(const std::string& file_system_id,
                                 const std::string& request_id,
                                 const std::string& open_request_id) {
    JavaScriptPostMessage(request::CreateCloseFileDoneResponse(
        file_system_id, request_id, open_request_id));
  }

  virtual void SendReadFileDone(const std::string& file_system_id,
                                const std::string& request_id,
                                const pp::VarArrayBuffer& array_buffer,
                                bool has_more_data) {
    JavaScriptPostMessage(request::CreateReadFileDoneResponse(
        file_system_id, request_id, array_buffer, has_more_data));
  }

  virtual void SendConsoleLog(const std::string& file_system_id,
                              const std::string& request_id,
                              const std::string& src_file,
                              int src_line,
                              const std::string& src_func,
                              const std::string& message) {
    JavaScriptPostMessage(request::CreateConsoleLog(
        file_system_id, request_id, src_file, src_line, src_func, message));
  }

  virtual void SendCreateArchiveDone(int compressor_id) {
    JavaScriptPostMessage(request::CreateCreateArchiveDoneResponse(
        compressor_id));
  }

  virtual void SendReadFileChunk(int compressor_id, int64_t length) {
    JavaScriptPostMessage(request::CreateReadFileChunkRequest(
        compressor_id, length));
  }

  virtual void SendWriteChunk(int compressor_id,
      const pp::VarArrayBuffer& array_buffer,
      int64_t length) {
    JavaScriptPostMessage(request::CreateWriteChunkRequest(
        compressor_id, array_buffer, length));
  }

  virtual void SendAddToArchiveDone(int compressor_id) {
    JavaScriptPostMessage(request::CreateAddToArchiveDoneResponse(
        compressor_id));
  }

  virtual void SendCloseArchiveDone(int compressor_id) {
    JavaScriptPostMessage(request::CreateCloseArchiveDoneResponse(
        compressor_id));
  }

 private:
  // Posts a message to JavaScript. This is prone to races in case of using
  // NaCl instead of PNaCl. See crbug.com/413513.
  void JavaScriptPostMessage(const pp::VarDictionary& message) {
    instance_->PostMessage(message);
  }

  pp::Instance* instance_;
};

}  // namespace

// An instance for every "embed" in the web page. For this extension only one
// "embed" is necessary.
class NaclArchiveInstance : public pp::Instance {
 public:
  explicit NaclArchiveInstance(PP_Instance instance)
      : pp::Instance(instance),
        instance_handle_(instance),
        message_sender_(this) {}

  virtual ~NaclArchiveInstance() {
    for (volume_iterator iterator = volumes_.begin();
         iterator != volumes_.end();
         ++iterator) {
      delete iterator->second;
    }
  }

  // Handler for messages coming in from JS via postMessage().
  virtual void HandleMessage(const pp::Var& var_message) {
    PP_DCHECK(var_message.is_dictionary());
    pp::VarDictionary var_dict(var_message);

    PP_DCHECK(var_dict.Get(request::key::kOperation).is_int());
    int operation = var_dict.Get(request::key::kOperation).AsInt();

    if (request::IsPackRequest(operation))
      HandlePackMessage(var_dict, operation);
    else
      HandleUnpackMessage(var_dict, operation);
  }

 private:

  // Processes unpack messages.
  void HandleUnpackMessage(const pp::VarDictionary& var_dict,
      const int operation) {

    PP_DCHECK(var_dict.Get(request::key::kFileSystemId).is_string());
    std::string file_system_id =
        var_dict.Get(request::key::kFileSystemId).AsString();

    PP_DCHECK(var_dict.Get(request::key::kRequestId).is_string());
    std::string request_id = var_dict.Get(request::key::kRequestId).AsString();

    // Processes operation.
    switch (operation) {
      case request::READ_METADATA: {
        ReadMetadata(var_dict, file_system_id, request_id);
        break;
      }

      case request::READ_CHUNK_DONE:
        ReadChunkDone(var_dict, file_system_id, request_id);
        break;

      case request::READ_CHUNK_ERROR:
        ReadChunkError(file_system_id, request_id);
        break;

      case request::READ_PASSPHRASE_DONE:
        ReadPassphraseDone(var_dict, file_system_id, request_id);
        break;

      case request::READ_PASSPHRASE_ERROR:
        ReadPassphraseError(file_system_id, request_id);
        break;

      case request::OPEN_FILE:
        OpenFile(var_dict, file_system_id, request_id);
        break;

      case request::CLOSE_FILE:
        CloseFile(var_dict, file_system_id, request_id);
        break;

      case request::READ_FILE:
        ReadFile(var_dict, file_system_id, request_id);
        break;

      case request::CLOSE_VOLUME: {
        volume_iterator iterator = volumes_.find(file_system_id);
        PP_DCHECK(iterator != volumes_.end());
        delete iterator->second;
        volumes_.erase(file_system_id);
        break;
      }

      default:
        PP_NOTREACHED();
    }
  }

  // Processes pack messages.
  void HandlePackMessage(const pp::VarDictionary& var_dict,
      const int operation) {
    PP_DCHECK(var_dict.Get(request::key::kCompressorId).is_int());
    int compressor_id =
        var_dict.Get(request::key::kCompressorId).AsInt();

    switch (operation) {
      case request::CREATE_ARCHIVE: {
        CreateArchive(compressor_id);
        break;
      }

      case request::ADD_TO_ARCHIVE: {
        AddToArchive(var_dict, compressor_id);
        break;
      }

      case request::READ_FILE_CHUNK_DONE: {
        ReadFileChunkDone(var_dict, compressor_id);
        break;
      }

      case request::WRITE_CHUNK_DONE: {
        WriteChunkDone(var_dict, compressor_id);
        break;
      }

      case request::CLOSE_ARCHIVE: {
        CloseArchive(var_dict, compressor_id);
        break;
      }

      default:
        PP_NOTREACHED();
    }
  }

  // Reads the metadata for the corresponding volume for file_system_id. This
  // should be called only once and before any other operation like OpenFile,
  // ReadFile, etc.
  // Reading metadata or opening a file could work even if the Volume exists
  // or not, but as the JavaScript code doesn't use this feature there is no
  // reason to allow it. If the logic on JavaScript changes then this can be
  // updated. But in current design if we read metadata for an existing Volume,
  // then there is a programmer error on JavaScript side.
  void ReadMetadata(const pp::VarDictionary& var_dict,
                    const std::string& file_system_id,
                    const std::string& request_id) {
    // Should not call ReadMetadata for a Volume already present in NaCl.
    PP_DCHECK(volumes_.find(file_system_id) == volumes_.end());

    Volume* volume =
        new Volume(instance_handle_, file_system_id, &message_sender_);
    if (!volume->Init()) {
      message_sender_.SendFileSystemError(
          file_system_id,
          request_id,
          "Could not create a volume for: " + file_system_id + ".");
      delete volume;
      return;
    }
    volumes_[file_system_id] = volume;

    PP_DCHECK(var_dict.Get(request::key::kEncoding).is_string());
    PP_DCHECK(var_dict.Get(request::key::kArchiveSize).is_string());

    volume->ReadMetadata(
        request_id,
        var_dict.Get(request::key::kEncoding).AsString(),
        request::GetInt64FromString(var_dict, request::key::kArchiveSize));
  }

  void ReadChunkDone(const pp::VarDictionary& var_dict,
                     const std::string& file_system_id,
                     const std::string& request_id) {
    PP_DCHECK(var_dict.Get(request::key::kChunkBuffer).is_array_buffer());
    pp::VarArrayBuffer array_buffer(var_dict.Get(request::key::kChunkBuffer));

    PP_DCHECK(var_dict.Get(request::key::kOffset).is_string());
    int64_t read_offset =
        request::GetInt64FromString(var_dict, request::key::kOffset);

    volume_iterator iterator = volumes_.find(file_system_id);
    // Volume was unmounted so ignore the read chunk operation.
    // Possible scenario for read ahead.
    if (iterator == volumes_.end())
      return;
    iterator->second->ReadChunkDone(request_id, array_buffer, read_offset);
  }

  void ReadChunkError(const std::string& file_system_id,
                      const std::string& request_id) {
    volume_iterator iterator = volumes_.find(file_system_id);
    // Volume was unmounted so ignore the read chunk operation.
    // Possible scenario for read ahead.
    if (iterator == volumes_.end())
      return;
    iterator->second->ReadChunkError(request_id);
  }

  void ReadPassphraseDone(const pp::VarDictionary& var_dict,
                          const std::string& file_system_id,
                          const std::string& request_id) {
    PP_DCHECK(var_dict.Get(request::key::kPassphrase).is_string());
    std::string passphrase(var_dict.Get(request::key::kPassphrase).AsString());

    volume_iterator iterator = volumes_.find(file_system_id);
    // Volume was unmounted so ignore the read passphrase operation.
    if (iterator == volumes_.end())
      return;
    iterator->second->ReadPassphraseDone(request_id, passphrase);
  }

  void ReadPassphraseError(const std::string& file_system_id,
                           const std::string& request_id) {
    volume_iterator iterator = volumes_.find(file_system_id);
    // Volume was unmounted so ignore the read chunk operation.
    if (iterator == volumes_.end())
      return;
    iterator->second->ReadPassphraseError(request_id);
  }

  void OpenFile(const pp::VarDictionary& var_dict,
                const std::string& file_system_id,
                const std::string& request_id) {
    PP_DCHECK(var_dict.Get(request::key::kIndex).is_string());
    int64_t index =
        request::GetInt64FromString(var_dict, request::key::kIndex);

    PP_DCHECK(var_dict.Get(request::key::kEncoding).is_string());
    std::string encoding(var_dict.Get(request::key::kEncoding).AsString());

    PP_DCHECK(var_dict.Get(request::key::kArchiveSize).is_string());
    int64_t archive_size =
        request::GetInt64FromString(var_dict, request::key::kArchiveSize);

    volume_iterator iterator = volumes_.find(file_system_id);
    PP_DCHECK(iterator != volumes_.end());  // Should call OpenFile after
                                            // ReadMetadata.
    iterator->second->OpenFile(request_id, index, encoding, archive_size);
  }

  void CloseFile(const pp::VarDictionary& var_dict,
                 const std::string& file_system_id,
                 const std::string& request_id) {
    PP_DCHECK(var_dict.Get(request::key::kOpenRequestId).is_string());
    std::string open_request_id(
        var_dict.Get(request::key::kOpenRequestId).AsString());

    volume_iterator iterator = volumes_.find(file_system_id);
    PP_DCHECK(iterator !=
              volumes_.end());  // Should call CloseFile after OpenFile.

    iterator->second->CloseFile(request_id, open_request_id);
  }

  void ReadFile(const pp::VarDictionary& var_dict,
                const std::string& file_system_id,
                const std::string& request_id) {
    PP_DCHECK(var_dict.Get(request::key::kOpenRequestId).is_string());
    PP_DCHECK(var_dict.Get(request::key::kOffset).is_string());
    PP_DCHECK(var_dict.Get(request::key::kLength).is_string());

    volume_iterator iterator = volumes_.find(file_system_id);
    PP_DCHECK(iterator !=
              volumes_.end());  // Should call ReadFile after OpenFile.

    // Passing the entire dictionary because pp::CompletionCallbackFactory
    // cannot create callbacks with more than 3 parameters. Here we need 4:
    // request_id, open_request_id, offset and length.
    iterator->second->ReadFile(request_id, var_dict);
  }

  // Requests libarchive to create an archive object for the given compressor_id.
  void CreateArchive(int compressor_id) {
    Compressor* compressor =
        new Compressor(instance_handle_, compressor_id, &message_sender_);
    if (!compressor->Init()) {
      std::stringstream ss;
      ss << compressor_id;
      message_sender_.SendCompressorError(
          compressor_id,
          "Could not create a compressor for compressor id: " + ss.str() + ".");
      delete compressor;
      return;
    }
    compressors_[compressor_id] = compressor;

    compressor->CreateArchive();
  }

  void AddToArchive(const pp::VarDictionary& var_dict,
                    int compressor_id) {
    compressor_iterator iterator = compressors_.find(compressor_id);
    PP_DCHECK(iterator != compressors_.end());

    iterator->second->AddToArchive(var_dict);
  }

  void ReadFileChunkDone(const pp::VarDictionary& var_dict,
                         const int compressor_id) {
    compressor_iterator iterator = compressors_.find(compressor_id);
    PP_DCHECK(iterator != compressors_.end());

    iterator->second->ReadFileChunkDone(var_dict);
  }

  void WriteChunkDone(const pp::VarDictionary& var_dict,
                      int compressor_id) {
    compressor_iterator iterator = compressors_.find(compressor_id);
    PP_DCHECK(iterator != compressors_.end());

    iterator->second->WriteChunkDone(var_dict);
  }

  void CloseArchive(const pp::VarDictionary& var_dict,
                    int compressor_id) {
    compressor_iterator iterator = compressors_.find(compressor_id);

    if (iterator != compressors_.end())
      iterator->second->CloseArchive(var_dict);
  }

  // A map that holds for every opened archive its instance. The key is the file
  // system id of the archive.
  std::map<std::string, Volume*> volumes_;

  // A map from compressor ids to compressors.
  std::map<int, Compressor*> compressors_;

  // An pp::InstanceHandle used to create pp::SimpleThread in Volume.
  pp::InstanceHandle instance_handle_;

  // An object used to send messages to JavaScript.
  JavaScriptMessageSender message_sender_;
};

// The Module class. The browser calls the CreateInstance() method to create
// an instance of your NaCl module on the web page. The browser creates a new
// instance for each <embed> tag with type="application/x-pnacl" or
// type="application/x-nacl".
class NaclArchiveModule : public pp::Module {
 public:
  NaclArchiveModule() : pp::Module() {}
  virtual ~NaclArchiveModule() {}

  // Create and return a NaclArchiveInstance object.
  // @param[in] instance The browser-side instance.
  // @return the plugin-side instance.
  virtual pp::Instance* CreateInstance(PP_Instance instance) {
    return new NaclArchiveInstance(instance);
  }
};

namespace pp {

// Factory function called by the browser when the module is first loaded.
// The browser keeps a singleton of this module.  It calls the
// CreateInstance() method on the object you return to make instances.  There
// is one instance per <embed> tag on the page.  This is the main binding
// point for your NaCl module with the browser.
Module* CreateModule() {
  std::setlocale(LC_ALL, "en_US.UTF-8");
  return new NaclArchiveModule();
}

}  // namespace pp