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

#include "content/browser/renderer_host/render_widget_host_view_tvos_uiview.h"

#include "base/strings/sys_string_conversions.h"
#include "components/input/native_web_keyboard_event.h"
#include "third_party/blink/public/common/input/web_input_event.h"
#include "third_party/blink/public/common/input/web_keyboard_event.h"
#include "ui/base/ime/mojom/ime_types.mojom-shared.h"
#include "ui/events/base_event_utils.h"
#include "ui/events/keycodes/dom/dom_code.h"
#include "ui/events/keycodes/dom/dom_key.h"
#include "ui/events/keycodes/keyboard_codes.h"

static void* kObservingContext = &kObservingContext;

namespace {

UIKeyboardType keyboardTypeForInputType(ui::TextInputType inputType) {
  // TODO(crbug.com/411452047): Implement textFieldShouldEndEditing to detect
  // invalid contents in the text field. When texts are inserted via a H/W
  // connected keyboard, it's still possible to insert invalid contents.
  switch (inputType) {
    case ui::TextInputType::TEXT_INPUT_TYPE_SEARCH:
      return UIKeyboardTypeWebSearch;
    case ui::TextInputType::TEXT_INPUT_TYPE_EMAIL:
      return UIKeyboardTypeEmailAddress;
    case ui::TextInputType::TEXT_INPUT_TYPE_NUMBER:
      return UIKeyboardTypeNumberPad;
    case ui::TextInputType::TEXT_INPUT_TYPE_TELEPHONE:
      return UIKeyboardTypePhonePad;
    case ui::TextInputType::TEXT_INPUT_TYPE_URL:
      return UIKeyboardTypeURL;
    default:
      return UIKeyboardTypeASCIICapable;
  }
}

}  // namespace

@implementation RenderWidgetUIView

#pragma mark - Public

- (instancetype)initWithWidget:
    (base::WeakPtr<content::RenderWidgetHostViewIOS>)view {
  self = [self init];
  if (self) {
    _view = view;
    self.autoresizingMask =
        UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;

    UITapGestureRecognizer* tapGesture =
        [[UITapGestureRecognizer alloc] initWithTarget:self
                                                action:@selector(tapGesture:)];
    [self addGestureRecognizer:tapGesture];

    UISwipeGestureRecognizer* swipeLeftGesture =
        [[UISwipeGestureRecognizer alloc]
            initWithTarget:self
                    action:@selector(swipeGesture:)];
    swipeLeftGesture.direction = UISwipeGestureRecognizerDirectionLeft;
    [self addGestureRecognizer:swipeLeftGesture];

    UISwipeGestureRecognizer* swipeRightGesture =
        [[UISwipeGestureRecognizer alloc]
            initWithTarget:self
                    action:@selector(swipeGesture:)];
    swipeRightGesture.direction = UISwipeGestureRecognizerDirectionRight;
    [self addGestureRecognizer:swipeRightGesture];

    UISwipeGestureRecognizer* swipeUpGesture = [[UISwipeGestureRecognizer alloc]
        initWithTarget:self
                action:@selector(swipeGesture:)];
    swipeUpGesture.direction = UISwipeGestureRecognizerDirectionUp;
    [self addGestureRecognizer:swipeUpGesture];

    UISwipeGestureRecognizer* swipeDownGesture =
        [[UISwipeGestureRecognizer alloc]
            initWithTarget:self
                    action:@selector(swipeGesture:)];
    swipeDownGesture.direction = UISwipeGestureRecognizerDirectionDown;
    [self addGestureRecognizer:swipeDownGesture];
  }
  return self;
}

// Contrary to iOS, on tvOS the on-screen keyboard takes the entire screen, so
// instead of showing it when an input element is focused, we require a tap to
// do it.
- (void)onUpdateTextInputState:(const ui::mojom::TextInputState&)state
                    withBounds:(CGRect)bounds {
  // Check for the visibility request and policy if VK APIs are enabled.
  if (state.vk_policy == ui::mojom::VirtualKeyboardPolicy::MANUAL) {
    // policy is manual.
    if (state.last_vk_visibility_request ==
        ui::mojom::VirtualKeyboardVisibilityRequest::SHOW) {
      [self showKeyboard:state];
    } else if (state.last_vk_visibility_request ==
               ui::mojom::VirtualKeyboardVisibilityRequest::HIDE) {
      [self hideAndDeleteKeyboard];
    }
  } else {
    bool hide = state.always_hide_ime ||
                state.mode == ui::TextInputMode::TEXT_INPUT_MODE_NONE ||
                state.type == ui::TextInputType::TEXT_INPUT_TYPE_NONE;
    if (hide) {
      [self hideAndDeleteKeyboard];
    } else if (state.show_ime_if_needed) {
      [self showKeyboard:state];
    }
  }
}

- (void)updateView:(UIScrollView*)view {
  [view addSubview:self];
  view.scrollEnabled = NO;
  // Remove all existing gestureRecognizers since the header might be reused.
  for (UIGestureRecognizer* recognizer in view.gestureRecognizers) {
    [view removeGestureRecognizer:recognizer];
  }
  [view addObserver:self
         forKeyPath:NSStringFromSelector(@selector(contentInset))
            options:NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld
            context:kObservingContext];
}

- (void)removeView {
  UIScrollView* view = (UIScrollView*)[self superview];
  [view removeObserver:self
            forKeyPath:NSStringFromSelector(@selector(contentInset))];
  [self removeFromSuperview];
}

#pragma mark - Private

- (void)tapGesture:(UIGestureRecognizer*)gestureRecognizer {
  if ([gestureRecognizer state] != UIGestureRecognizerStateEnded) {
    return;
  }

  const ui::mojom::TextInputState* state = [self editState];
  if (state && state->mode != ui::TextInputMode::TEXT_INPUT_MODE_NONE &&
      state->type != ui::TextInputType::TEXT_INPUT_TYPE_NONE) {
    [self showKeyboard:*state];
    return;
  }

  blink::WebKeyboardEvent event(blink::WebInputEvent::Type::kKeyDown,
                                blink::WebInputEvent::kNoModifiers,
                                ui::EventTimeForNow());
  event.native_key_code = UIKeyboardHIDUsageKeyboardReturnOrEnter;
  event.dom_code = static_cast<int>(ui::DomCode::ENTER);
  event.dom_key = ui::DomKey::ENTER;
  event.windows_key_code = ui::VKEY_RETURN;

  // Copied from components/input/web_input_event_builders_mac.mm's
  // WebKeyboardEventBuilder::Build().
  // This is necessary due to way some HTML elements process keyboard activation
  // (e.g. blink::HTMLElement::HandleKeyboardActivation()).
  event.text[0] = '\r';
  event.unmodified_text[0] = '\r';

  _view->SendKeyEvent(
      input::NativeWebKeyboardEvent(event, _view->GetNativeView()));

  // We also need to send a keyup event so that e.g. checkboxes are properly
  // activated/deactivated with the keyboard.
  event.SetType(blink::WebInputEvent::Type::kKeyUp);
  event.SetTimeStamp(ui::EventTimeForNow());
  _view->SendKeyEvent(
      input::NativeWebKeyboardEvent(event, _view->GetNativeView()));
}

- (void)swipeGesture:(UISwipeGestureRecognizer*)gestureRecognizer {
  if ([gestureRecognizer state] != UIGestureRecognizerStateEnded) {
    return;
  }

  const UISwipeGestureRecognizerDirection direction =
      gestureRecognizer.direction;

  blink::WebKeyboardEvent event(blink::WebInputEvent::Type::kKeyDown,
                                blink::WebInputEvent::kNoModifiers,
                                ui::EventTimeForNow());

  switch (direction) {
    case UISwipeGestureRecognizerDirectionLeft:
      event.native_key_code = UIKeyboardHIDUsageKeyboardLeftArrow;
      event.dom_code = static_cast<int>(ui::DomCode::ARROW_LEFT);
      event.dom_key = ui::DomKey::ARROW_LEFT;
      event.windows_key_code = ui::VKEY_LEFT;
      break;
    case UISwipeGestureRecognizerDirectionRight:
      event.native_key_code = UIKeyboardHIDUsageKeyboardRightArrow;
      event.dom_code = static_cast<int>(ui::DomCode::ARROW_RIGHT);
      event.dom_key = ui::DomKey::ARROW_RIGHT;
      event.windows_key_code = ui::VKEY_RIGHT;
      break;
    case UISwipeGestureRecognizerDirectionUp:
      event.native_key_code = UIKeyboardHIDUsageKeyboardUpArrow;
      event.dom_code = static_cast<int>(ui::DomCode::ARROW_UP);
      event.dom_key = ui::DomKey::ARROW_UP;
      event.windows_key_code = ui::VKEY_UP;
      break;
    case UISwipeGestureRecognizerDirectionDown:
      event.native_key_code = UIKeyboardHIDUsageKeyboardDownArrow;
      event.dom_code = static_cast<int>(ui::DomCode::ARROW_DOWN);
      event.dom_key = ui::DomKey::ARROW_DOWN;
      event.windows_key_code = ui::VKEY_DOWN;
      break;
  }

  _view->SendKeyEvent(
      input::NativeWebKeyboardEvent(event, _view->GetNativeView()));
}

- (void)showKeyboard:(const ui::mojom::TextInputState&)state {
  if (_textFieldForAllTextInput) {
    return;
  }

  _textFieldForAllTextInput = [[UITextField alloc] init];
  _textFieldForAllTextInput.delegate = self;
  _textFieldForAllTextInput.keyboardType = keyboardTypeForInputType(state.type);
  if (state.value.has_value()) {
    _textFieldForAllTextInput.text =
        base::SysUTF16ToNSString(state.value.value());
  }
  if (state.type == ui::TextInputType::TEXT_INPUT_TYPE_PASSWORD) {
    _textFieldForAllTextInput.secureTextEntry = YES;
    // state.value.value() contains "\u2022" characters instead of actual text,
    // so it makes more sense to just start with an empty field to avoid the
    // case of a bogus value being set and used if the user just presses "done"
    // on the on-screen keyboard.
    _textFieldForAllTextInput.text = nil;
  }

  [self addSubview:_textFieldForAllTextInput];
  [_textFieldForAllTextInput becomeFirstResponder];
}

- (void)hideAndDeleteKeyboard {
  [_textFieldForAllTextInput removeFromSuperview];
  _textFieldForAllTextInput = nil;
}

- (const ui::mojom::TextInputState*)editState {
  if (!_view || !_view->GetTextInputManager()) {
    return nil;
  }
  return _view->GetTextInputManager()->GetTextInputState();
}

#pragma mark - CALayerFrameSinkProvider

- (ui::CALayerFrameSink*)frameSink {
  return _view.get();
}

#pragma mark - NSObject

- (void)observeValueForKeyPath:(NSString*)keyPath
                      ofObject:(id)object
                        change:(NSDictionary*)change
                       context:(void*)context {
  CHECK(_view);
  if (context == kObservingContext) {
    _view->ContentInsetChanged();
  } else {
    [super observeValueForKeyPath:keyPath
                         ofObject:object
                           change:change
                          context:context];
  }
}

#pragma mark - UIResponder

- (BOOL)canBecomeFirstResponder {
  return YES;
}

- (BOOL)isFirstResponder {
  return
      [super isFirstResponder] || [_textFieldForAllTextInput isFirstResponder];
}

- (BOOL)becomeFirstResponder {
  CHECK(_view);
  const BOOL result = [super becomeFirstResponder];
  const BOOL keyboard_is_hidden =
      !_textFieldForAllTextInput || [_textFieldForAllTextInput isHidden];
  if (keyboard_is_hidden &&
      (result || _view->CanBecomeFirstResponderForTesting())) {
    _view->OnFirstResponderChanged();
  }
  return result;
}

- (BOOL)resignFirstResponder {
  const BOOL result = [super resignFirstResponder];
  const BOOL keyboard_is_hidden =
      !_textFieldForAllTextInput || [_textFieldForAllTextInput isHidden];
  if (_view && keyboard_is_hidden &&
      (result || _view->CanResignFirstResponderForTesting())) {
    _view->OnFirstResponderChanged();
  }
  return result;
}

#pragma mark - UITextFieldDelegate

- (void)textFieldDidEndEditing:(UITextField*)textField
                        reason:(UITextFieldDidEndEditingReason)reason {
  CHECK_EQ(textField, _textFieldForAllTextInput);
  if (reason == UITextFieldDidEndEditingReasonCommitted) {
    const ui::mojom::TextInputState* state = [self editState];
    const gfx::Range range = state ? gfx::Range(0, state->selection.GetMax())
                                   : gfx::Range::InvalidRange();
    _view->ImeCommitText(base::SysNSStringToUTF16(textField.text), range, 0);
  }

  [self hideAndDeleteKeyboard];
}

#pragma mark - UIView

- (BOOL)canBecomeFocused {
  return YES;
}

- (void)layoutSubviews {
  CHECK(_view);
  [super layoutSubviews];
  _view->UpdateScreenInfo();

  // TODO(dtapuska): This isn't correct, we need to figure out when the window
  // gains/loses focus.
  _view->SetActive(true);
}

@end