// Copyright 2016 The Cobalt Authors. All Rights Reserved.
//
// Licensed 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.

#include "starboard/android/shared/application_android.h"

#include <android/looper.h>
#include <android/native_activity.h>
#include <time.h>
#include <unistd.h>

#include <algorithm>
#include <string>
#include <vector>

#include "starboard/accessibility.h"
#include "starboard/android/shared/file_internal.h"
#include "starboard/android/shared/input_events_generator.h"
#include "starboard/android/shared/jni_env_ext.h"
#include "starboard/android/shared/jni_utils.h"
#include "starboard/android/shared/window_internal.h"
#include "starboard/common/condition_variable.h"
#include "starboard/common/log.h"
#include "starboard/common/mutex.h"
#include "starboard/common/string.h"
#include "starboard/common/time.h"
#include "starboard/event.h"
#include "starboard/key.h"
#include "starboard/shared/starboard/audio_sink/audio_sink_internal.h"

namespace starboard {
namespace android {
namespace shared {

namespace {
enum {
  kLooperIdAndroidCommand,
  kLooperIdAndroidInput,
  kLooperIdKeyboardInject,
};

const char* AndroidCommandName(
    ApplicationAndroid::AndroidCommand::CommandType type) {
  switch (type) {
    case ApplicationAndroid::AndroidCommand::kUndefined:
      return "Undefined";
    case ApplicationAndroid::AndroidCommand::kStart:
      return "Start";
    case ApplicationAndroid::AndroidCommand::kResume:
      return "Resume";
    case ApplicationAndroid::AndroidCommand::kPause:
      return "Pause";
    case ApplicationAndroid::AndroidCommand::kStop:
      return "Stop";
    case ApplicationAndroid::AndroidCommand::kNativeWindowCreated:
      return "NativeWindowCreated";
    case ApplicationAndroid::AndroidCommand::kNativeWindowDestroyed:
      return "NativeWindowDestroyed";
    case ApplicationAndroid::AndroidCommand::kWindowFocusGained:
      return "WindowFocusGained";
    case ApplicationAndroid::AndroidCommand::kWindowFocusLost:
      return "WindowFocusLost";
    case ApplicationAndroid::AndroidCommand::kDeepLink:
      return "DeepLink";
    default:
      return "unknown";
  }
}
}  // namespace

// "using" doesn't work with class members, so make a local convenience type.
typedef ::starboard::shared::starboard::Application::Event Event;

#if SB_API_VERSION >= 15
ApplicationAndroid::ApplicationAndroid(
    ALooper* looper,
    SbEventHandleCallback sb_event_handle_callback)
#else
ApplicationAndroid::ApplicationAndroid(ALooper* looper)
#endif  // SB_API_VERSION >= 15
    : looper_(looper),
      native_window_(NULL),
      android_command_readfd_(-1),
      android_command_writefd_(-1),
      keyboard_inject_readfd_(-1),
      keyboard_inject_writefd_(-1),
      android_command_condition_(android_command_mutex_),
      activity_state_(AndroidCommand::kUndefined),
      window_(kSbWindowInvalid),
#if SB_API_VERSION >= 15
      QueueApplication(sb_event_handle_callback),
#endif  // SB_API_VERSION >= 15
      last_is_accessibility_high_contrast_text_enabled_(false) {
  // Initialize Time Zone early so that local time works correctly.
  // Called once here to help SbTimeZoneGet*Name()
  tzset();

  // Initialize Android asset access early so that ICU can load its tables
  // from the assets. The use ICU is used in our logging.
  SbFileAndroidInitialize();

  // Enable axes used by Cobalt.
  static const unsigned int required_axes[] = {
      AMOTION_EVENT_AXIS_Z,       AMOTION_EVENT_AXIS_RZ,
      AMOTION_EVENT_AXIS_HAT_X,   AMOTION_EVENT_AXIS_HAT_Y,
      AMOTION_EVENT_AXIS_HSCROLL, AMOTION_EVENT_AXIS_VSCROLL,
      AMOTION_EVENT_AXIS_WHEEL,
  };
  for (auto axis : required_axes) {
    GameActivityPointerAxes_enableAxis(axis);
  }

  int pipefd[2];
  int err;

  err = pipe(pipefd);
  SB_CHECK(err >= 0) << "pipe errno is:" << errno;
  android_command_readfd_ = pipefd[0];
  android_command_writefd_ = pipefd[1];
  ALooper_addFd(looper_, android_command_readfd_, kLooperIdAndroidCommand,
                ALOOPER_EVENT_INPUT, NULL, NULL);

  err = pipe(pipefd);
  SB_CHECK(err >= 0) << "pipe errno is:" << errno;
  keyboard_inject_readfd_ = pipefd[0];
  keyboard_inject_writefd_ = pipefd[1];
  ALooper_addFd(looper_, keyboard_inject_readfd_, kLooperIdKeyboardInject,
                ALOOPER_EVENT_INPUT, NULL, NULL);

  JniEnvExt* env = JniEnvExt::Get();
  jobject local_ref = env->CallStarboardObjectMethodOrAbort(
      "getResourceOverlay", "()Ldev/cobalt/coat/ResourceOverlay;");
  resource_overlay_ = env->ConvertLocalRefToGlobalRef(local_ref);

  env->CallStarboardVoidMethodOrAbort("starboardApplicationStarted", "()V");
}

ApplicationAndroid::~ApplicationAndroid() {
  // Inform StarboardBridge that
  JniEnvExt* env = JniEnvExt::Get();
  env->CallStarboardVoidMethodOrAbort("starboardApplicationStopping", "()V");

  // The application is exiting.
  // Release the global reference.
  if (resource_overlay_) {
    JniEnvExt* env = JniEnvExt::Get();
    env->DeleteGlobalRef(resource_overlay_);
    resource_overlay_ = nullptr;
  }
  ALooper_removeFd(looper_, android_command_readfd_);
  close(android_command_readfd_);
  close(android_command_writefd_);

  ALooper_removeFd(looper_, keyboard_inject_readfd_);
  close(keyboard_inject_readfd_);
  close(keyboard_inject_writefd_);

  {
    // Signal for any potentially waiting window creation or destroy commands.
    ScopedLock lock(android_command_mutex_);
    application_destroying_.store(true);
    android_command_condition_.Signal();
  }
}

void ApplicationAndroid::Initialize() {
  SbAudioSinkPrivate::Initialize();
}

void ApplicationAndroid::Teardown() {
  SbAudioSinkPrivate::TearDown();
  SbFileAndroidTeardown();
}

SbWindow ApplicationAndroid::CreateWindow(const SbWindowOptions* options) {
  if (SbWindowIsValid(window_)) {
    return kSbWindowInvalid;
  }
  ScopedLock lock(input_mutex_);
  window_ = new SbWindowPrivate;
  window_->native_window = native_window_;
  input_events_generator_.reset(new InputEventsGenerator(window_));
  return window_;
}

bool ApplicationAndroid::DestroyWindow(SbWindow window) {
  if (!SbWindowIsValid(window)) {
    return false;
  }

  ScopedLock lock(input_mutex_);
  input_events_generator_.reset();

  SB_DCHECK(window == window_);
  delete window_;
  window_ = kSbWindowInvalid;
  return true;
}

Event* ApplicationAndroid::WaitForSystemEventWithTimeout(int64_t time) {
  // Limit the polling time in case some non-system event is injected.
  const int kMaxPollingTimeMillisecond = 10;

  // Convert from microseconds to milliseconds, taking the ceiling value.
  // If we take the floor, or round, then we end up busy looping every time
  // the next event time is less than one millisecond.
  int timeout_millis = (time + 1000 - 1) / 1000;
  int looper_events;
  int ident = ALooper_pollAll(
      std::min(std::max(timeout_millis, 0), kMaxPollingTimeMillisecond), NULL,
      &looper_events, NULL);

  // Ignore new system events while processing one.
  handle_system_events_ = false;

  switch (ident) {
    case kLooperIdAndroidCommand:
      ProcessAndroidCommand();
      break;
    case kLooperIdKeyboardInject:
      ProcessKeyboardInject();
      break;
  }

  handle_system_events_ = true;

  // Always return NULL since we already dispatched our own system events.
  return NULL;
}

void ApplicationAndroid::WakeSystemEventWait() {
  ALooper_wake(looper_);
}

void ApplicationAndroid::OnResume() {
  JniEnvExt* env = JniEnvExt::Get();
  env->CallStarboardVoidMethodOrAbort("beforeStartOrResume", "()V");
}

void ApplicationAndroid::OnSuspend() {
  JniEnvExt* env = JniEnvExt::Get();
  env->CallStarboardVoidMethodOrAbort("beforeSuspend", "()V");
}

void ApplicationAndroid::StartMediaPlaybackService() {
  JniEnvExt* env = JniEnvExt::Get();
  env->CallStarboardVoidMethodOrAbort("startMediaPlaybackService", "()V");
}

void ApplicationAndroid::StopMediaPlaybackService() {
  JniEnvExt* env = JniEnvExt::Get();
  env->CallStarboardVoidMethodOrAbort("stopMediaPlaybackService", "()V");
}

void ApplicationAndroid::ProcessAndroidCommand() {
  JniEnvExt* env = JniEnvExt::Get();
  AndroidCommand cmd;
  int err = read(android_command_readfd_, &cmd, sizeof(cmd));
  if (err < 0) {
    SB_DCHECK(err >= 0) << "Command read failed. errno=" << errno;
    return;
  }

  SB_LOG(INFO) << "Android command: " << AndroidCommandName(cmd.type);

  // The activity state to which we should sync the starboard state.
  AndroidCommand::CommandType sync_state = AndroidCommand::kUndefined;

  switch (cmd.type) {
    case AndroidCommand::kUndefined:
      break;
    // Starboard resume/suspend is tied to the UI window being created/destroyed
    // (rather than to the Activity lifecycle) since Cobalt can't do anything at
    // all if it doesn't have a window surface to draw on.
    case AndroidCommand::kNativeWindowCreated: {
      {
        ScopedLock lock(android_command_mutex_);
        native_window_ = static_cast<ANativeWindow*>(cmd.data);
        if (window_) {
          window_->native_window = native_window_;
        }
        // Now that we have the window, signal that the Android UI thread can
        // continue, before we start or resume the Starboard app.
        android_command_condition_.Signal();
      }

      if (state() == kStateUnstarted) {
        // This is the initial launch, so we have to start Cobalt now that we
        // have a window.
        env->CallStarboardVoidMethodOrAbort("beforeStartOrResume", "()V");
        DispatchStart(GetAppStartTimestamp());
      } else {
        // Now that we got a window back, change the command for the switch
        // below to sync up with the current activity lifecycle.
        sync_state = activity_state_;
      }
      break;
    }
    case AndroidCommand::kNativeWindowDestroyed: {
      // No need to JNI call StarboardBridge.beforeSuspend() since we did it
      // early in SendAndroidCommand().
      {
        ScopedLock lock(android_command_mutex_);
        // Cobalt can't keep running without a window, even if the Activity
        // hasn't stopped yet. Block until conceal event has been processed.

        // Only process injected events -- don't check system events since
        // that may try to acquire the already-locked android_command_mutex_.
        InjectAndProcess(kSbEventTypeConceal, /* checkSystemEvents */ false);

        if (window_) {
          window_->native_window = NULL;
        }
        native_window_ = NULL;
        // Now that we've suspended the Starboard app, and let go of the window,
        // signal that the Android UI thread can continue.
        android_command_condition_.Signal();
      }
      break;
    }
    case AndroidCommand::kWindowFocusLost:
      break;
    case AndroidCommand::kWindowFocusGained: {
      // Android does not have a publicly-exposed way to
      // register for high-contrast text settings changed events.
      // We assume that it can only change when our focus changes
      // (because the user exits and enters the app) so we check
      // for changes here.
      SbAccessibilityDisplaySettings settings;
      memset(&settings, 0, sizeof(settings));
      if (!SbAccessibilityGetDisplaySettings(&settings)) {
        break;
      }

      bool enabled = settings.has_high_contrast_text_setting &&
                     settings.is_high_contrast_text_enabled;

      if (enabled != last_is_accessibility_high_contrast_text_enabled_) {
        Inject(new Event(kSbEventTypeAccessibilitySettingsChanged, NULL, NULL));
      }
      last_is_accessibility_high_contrast_text_enabled_ = enabled;
      break;
    }

    // Remember the Android activity state to sync to when we have a window.
    case AndroidCommand::kStop:
      SbAtomicBarrier_Increment(&android_stop_count_, -1);
    // Intentional fall-through.
    case AndroidCommand::kStart:
    case AndroidCommand::kResume:
    case AndroidCommand::kPause:
      sync_state = activity_state_ = cmd.type;
      break;
    case AndroidCommand::kDeepLink: {
      char* deep_link = static_cast<char*>(cmd.data);
      SB_LOG(INFO) << "AndroidCommand::kDeepLink: deep_link=" << deep_link
                   << " state=" << state();
      if (deep_link != NULL) {
        if (state() == kStateUnstarted) {
          SetStartLink(deep_link);
          SB_LOG(INFO) << "ApplicationAndroid SetStartLink";
          free(static_cast<void*>(deep_link));
        } else {
          SB_LOG(INFO) << "ApplicationAndroid Inject: kSbEventTypeLink";
          Inject(new Event(kSbEventTypeLink, CurrentMonotonicTime(), deep_link,
                           free));
        }
      }
      break;
    }
  }

  // If there's an outstanding "stop" command, then don't update the app state
  // since it'll be overridden by the upcoming "stop" state.
  if (SbAtomicAcquire_Load(&android_stop_count_) > 0) {
    return;
  }

  // If there's a window, sync the app state to the Activity lifecycle.
  if (native_window_) {
    switch (sync_state) {
      case AndroidCommand::kStart:
        Inject(new Event(kSbEventTypeReveal, NULL, NULL));
        break;
      case AndroidCommand::kResume:
        Inject(new Event(kSbEventTypeFocus, NULL, NULL));
        break;
      case AndroidCommand::kPause:
        Inject(new Event(kSbEventTypeBlur, NULL, NULL));
        break;
      case AndroidCommand::kStop:
        Inject(new Event(kSbEventTypeConceal, NULL, NULL));
        break;
      default:
        break;
    }
  }
}

void ApplicationAndroid::SendAndroidCommand(AndroidCommand::CommandType type,
                                            void* data) {
  SB_LOG(INFO) << "Send Android command: " << AndroidCommandName(type);
  AndroidCommand cmd{type, data};
  ScopedLock lock(android_command_mutex_);
  if (write(android_command_writefd_, &cmd, sizeof(cmd)) == -1) {
    SB_LOG(ERROR) << "Writing Android command failed";
    return;
  }
  // Synchronization only necessary when managing resources.
  switch (type) {
    case AndroidCommand::kNativeWindowCreated:
    case AndroidCommand::kNativeWindowDestroyed:
      while ((native_window_ != data) && !application_destroying_.load()) {
        android_command_condition_.Wait();
      }
      break;
    case AndroidCommand::kStop:
      SbAtomicBarrier_Increment(&android_stop_count_, 1);
      break;
    default:
      break;
  }
}

bool ApplicationAndroid::SendAndroidMotionEvent(
    const GameActivityMotionEvent* event) {
  SB_LOG(INFO) << "Received Motion Event from Android OS."
               << " source:" << event->source;

  bool result = false;

  ScopedLock lock(input_mutex_);
  if (!input_events_generator_) {
    return false;
  }

  // add motion event into the queue.
  InputEventsGenerator::Events app_events;
  result = input_events_generator_->CreateInputEventsFromGameActivityEvent(
      const_cast<GameActivityMotionEvent*>(event), &app_events);

  for (int i = 0; i < app_events.size(); ++i) {
    Inject(app_events[i].release());
  }

  return result;
}

bool ApplicationAndroid::SendAndroidKeyEvent(
    const GameActivityKeyEvent* event) {
  // Find the value reference on
  // https://developer.android.com/reference/android/view/KeyEvent
  SB_LOG(INFO) << "Received Key Event from Android OS. "
               << "keyCode:" << event->keyCode
               << ", modifiers:" << event->modifiers
               << ", source:" << event->source;

  bool result = false;

  ScopedLock lock(input_mutex_);
  if (!input_events_generator_) {
    return false;
  }

  // Add key event to the application queue.
  InputEventsGenerator::Events app_events;
  result = input_events_generator_->CreateInputEventsFromGameActivityEvent(
      const_cast<GameActivityKeyEvent*>(event), &app_events);
  for (int i = 0; i < app_events.size(); i++) {
    Inject(app_events[i].release());
  }

  return result;
}

void ApplicationAndroid::ProcessKeyboardInject() {
  SbKey key;
  int err = read(keyboard_inject_readfd_, &key, sizeof(key));
  SB_DCHECK(err >= 0) << "Keyboard inject read failed: errno=" << errno;
  SB_LOG(INFO) << "Keyboard inject: " << key;
  ScopedLock lock(input_mutex_);
  if (!input_events_generator_) {
    SB_DLOG(WARNING) << "Injected input event ignored without an SbWindow.";
    return;
  }
  InputEventsGenerator::Events app_events;
  input_events_generator_->CreateInputEventsFromSbKey(key, &app_events);
  for (int i = 0; i < app_events.size(); ++i) {
    Inject(app_events[i].release());
  }
}

void ApplicationAndroid::SendKeyboardInject(SbKey key) {
  write(keyboard_inject_writefd_, &key, sizeof(key));
}

extern "C" SB_EXPORT_PLATFORM void
Java_dev_cobalt_coat_CobaltA11yHelper_nativeInjectKeyEvent(JNIEnv* env,
                                                           jobject unused_clazz,
                                                           jint key) {
  ApplicationAndroid::Get()->SendKeyboardInject(static_cast<SbKey>(key));
}

void DeleteSbInputDataWithText(void* ptr) {
  SbInputData* data = static_cast<SbInputData*>(ptr);
  const char* input_text = data->input_text;
  data->input_text = NULL;
  delete input_text;
  ApplicationAndroid::DeleteDestructor<SbInputData>(ptr);
}

void ApplicationAndroid::SbWindowSendInputEvent(const char* input_text,
                                                bool is_composing) {
  char* text = strdup(input_text);
  SbInputData* data = new SbInputData();
  memset(data, 0, sizeof(*data));
  data->window = window_;
  data->type = kSbInputEventTypeInput;
  data->device_type = kSbInputDeviceTypeOnScreenKeyboard;
  data->input_text = text;
  data->is_composing = is_composing;
  Inject(new Event(kSbEventTypeInput, data, &DeleteSbInputDataWithText));
  return;
}

bool ApplicationAndroid::OnSearchRequested() {
  for (int i = 0; i < 2; i++) {
    SbInputData* data = new SbInputData();
    memset(data, 0, sizeof(*data));
    data->window = window_;
    data->key = kSbKeyBrowserSearch;
    data->type = (i == 0) ? kSbInputEventTypePress : kSbInputEventTypeUnpress;
    Inject(new Event(kSbEventTypeInput, data, &DeleteDestructor<SbInputData>));
  }
  return true;
}

extern "C" SB_EXPORT_PLATFORM jboolean
Java_dev_cobalt_coat_StarboardBridge_nativeOnSearchRequested(
    JniEnvExt* env,
    jobject unused_this) {
  return ApplicationAndroid::Get()->OnSearchRequested();
}

void ApplicationAndroid::HandleDeepLink(const char* link_url) {
  SB_LOG(INFO) << "ApplicationAndroid::HandleDeepLink link_url=" << link_url;
  if (link_url == NULL || link_url[0] == '\0') {
    return;
  }
  char* deep_link = strdup(link_url);
  SB_DCHECK(deep_link);

  SendAndroidCommand(AndroidCommand::kDeepLink, deep_link);
}

extern "C" SB_EXPORT_PLATFORM void
Java_dev_cobalt_coat_StarboardBridge_nativeHandleDeepLink(JniEnvExt* env,
                                                          jobject unused_this,
                                                          jstring j_url) {
  if (j_url) {
    std::string utf_str = env->GetStringStandardUTFOrAbort(j_url);
    ApplicationAndroid::Get()->HandleDeepLink(utf_str.c_str());
  }
}

extern "C" SB_EXPORT_PLATFORM void
Java_dev_cobalt_coat_StarboardBridge_nativeStopApp(JniEnvExt* env,
                                                   jobject unused_this,
                                                   jint error_level) {
  ApplicationAndroid::Get()->Stop(error_level);
}

void ApplicationAndroid::SendLowMemoryEvent() {
  Inject(new Event(kSbEventTypeLowMemory, NULL, NULL));
}

extern "C" SB_EXPORT_PLATFORM void
Java_dev_cobalt_coat_CobaltActivity_nativeLowMemoryEvent(JNIEnv* env,
                                                         jobject unused_clazz) {
  ApplicationAndroid::Get()->SendLowMemoryEvent();
}

void ApplicationAndroid::OsNetworkStatusChange(bool became_online) {
  if (state() == kStateUnstarted) {
    // Injecting events before application starts is error-prone.
    return;
  }
  if (became_online) {
    Inject(new Event(kSbEventTypeOsNetworkConnected, NULL, NULL));
  } else {
    Inject(new Event(kSbEventTypeOsNetworkDisconnected, NULL, NULL));
  }
}

int64_t ApplicationAndroid::GetAppStartTimestamp() {
  JniEnvExt* env = JniEnvExt::Get();
  jlong app_start_timestamp =
      env->CallStarboardLongMethodOrAbort("getAppStartTimestamp", "()J");
  return app_start_timestamp;
}

extern "C" SB_EXPORT_PLATFORM jlong
Java_dev_cobalt_coat_StarboardBridge_nativeCurrentMonotonicTime(
    JNIEnv* env,
    jobject jcaller,
    jboolean online) {
  return CurrentMonotonicTime();
}

void ApplicationAndroid::SendDateTimeConfigurationChangedEvent() {
  // Set the timezone to allow SbTimeZoneGetName() to return updated timezone.
  tzset();
  Inject(new Event(kSbEventDateTimeConfigurationChanged, NULL, NULL));
}

extern "C" SB_EXPORT_PLATFORM void
Java_dev_cobalt_coat_CobaltSystemConfigChangeReceiver_nativeDateTimeConfigurationChanged(
    JNIEnv* env,
    jobject jcaller) {
  ApplicationAndroid::Get()->SendDateTimeConfigurationChangedEvent();
}

int ApplicationAndroid::GetOverlayedIntValue(const char* var_name) {
  ScopedLock lock(overlay_mutex_);
  if (overlayed_int_variables_.find(var_name) !=
      overlayed_int_variables_.end()) {
    return overlayed_int_variables_[var_name];
  }
  JniEnvExt* env = JniEnvExt::Get();
  jint value = env->GetIntFieldOrAbort(resource_overlay_, var_name, "I");
  overlayed_int_variables_[var_name] = value;
  return value;
}

std::string ApplicationAndroid::GetOverlayedStringValue(const char* var_name) {
  ScopedLock lock(overlay_mutex_);
  if (overlayed_string_variables_.find(var_name) !=
      overlayed_string_variables_.end()) {
    return overlayed_string_variables_[var_name];
  }
  JniEnvExt* env = JniEnvExt::Get();
  std::string value = env->GetStringStandardUTFOrAbort(
      env->GetStringFieldOrAbort(resource_overlay_, var_name));
  overlayed_string_variables_[var_name] = value;
  return value;
}

bool ApplicationAndroid::GetOverlayedBoolValue(const char* var_name) {
  ScopedLock lock(overlay_mutex_);
  if (overlayed_bool_variables_.find(var_name) !=
      overlayed_bool_variables_.end()) {
    return overlayed_bool_variables_[var_name];
  }
  JniEnvExt* env = JniEnvExt::Get();
  jboolean value =
      env->GetBooleanFieldOrAbort(resource_overlay_, var_name, "Z");
  overlayed_bool_variables_[var_name] = value;
  return value;
}
}  // namespace shared
}  // namespace android
}  // namespace starboard