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

#import "ios/testing/hardware_keyboard_util.h"

#import <dlfcn.h>
#import <objc/runtime.h>

#import "base/test/ios/wait_util.h"

#pragma mark - Private API from IOKit to support CreateHIDKeyEvent

typedef UInt32 IOOptionBits;

typedef struct __IOHIDEvent* IOHIDEventRef;

extern "C" {

// This function is privately defined in IOKit framework.
IOHIDEventRef IOHIDEventCreateKeyboardEvent(CFAllocatorRef,
                                            uint64_t,
                                            uint32_t,
                                            uint32_t,
                                            boolean_t,
                                            IOOptionBits);
}

// This enum is defined in IOKit framework.
typedef enum {
  kUIKeyboardInputRepeat = 1 << 0,
  kUIKeyboardInputPopupVariant = 1 << 1,
  kUIKeyboardInputMultitap = 1 << 2,
  kUIKeyboardInputSkipCandidateSelection = 1 << 3,
  kUIKeyboardInputDeadKey = 1 << 4,
  kUIKeyboardInputModifierFlagsChanged = 1 << 5,
  kUIKeyboardInputFlick = 1 << 6,
  kUIKeyboardInputPreProcessed = 1 << 7,
} UIKeyboardInputFlags;

// This enum is defined in IOKit framework.
enum {
  kHIDUsage_KeyboardA = 0x04,
  kHIDUsage_Keyboard1 = 0x1E,
  kHIDUsage_Keyboard2 = 0x1F,
  kHIDUsage_Keyboard3 = 0x20,
  kHIDUsage_Keyboard4 = 0x21,
  kHIDUsage_Keyboard5 = 0x22,
  kHIDUsage_Keyboard6 = 0x23,
  kHIDUsage_Keyboard7 = 0x24,
  kHIDUsage_Keyboard8 = 0x25,
  kHIDUsage_Keyboard9 = 0x26,
  kHIDUsage_Keyboard0 = 0x27,
  kHIDUsage_KeyboardReturnOrEnter = 0x28,
  kHIDUsage_KeyboardEscape = 0x29,
  kHIDUsage_KeyboardDeleteOrBackspace = 0x2A,
  kHIDUsage_KeyboardTab = 0x2B,
  kHIDUsage_KeyboardSpacebar = 0x2C,
  kHIDUsage_KeyboardHyphen = 0x2D,
  kHIDUsage_KeyboardEqualSign = 0x2E,
  kHIDUsage_KeyboardOpenBracket = 0x2F,
  kHIDUsage_KeyboardCloseBracket = 0x30,
  kHIDUsage_KeyboardBackslash = 0x31,
  kHIDUsage_KeyboardSemicolon = 0x33,
  kHIDUsage_KeyboardQuote = 0x34,
  kHIDUsage_KeyboardGraveAccentAndTilde = 0x35,
  kHIDUsage_KeyboardComma = 0x36,
  kHIDUsage_KeyboardPeriod = 0x37,
  kHIDUsage_KeyboardSlash = 0x38,
  kHIDUsage_KeyboardCapsLock = 0x39,
  kHIDUsage_KeyboardF1 = 0x3A,
  kHIDUsage_KeyboardF12 = 0x45,
  kHIDUsage_KeyboardPrintScreen = 0x46,
  kHIDUsage_KeyboardInsert = 0x49,
  kHIDUsage_KeyboardHome = 0x4A,
  kHIDUsage_KeyboardPageUp = 0x4B,
  kHIDUsage_KeyboardDeleteForward = 0x4C,
  kHIDUsage_KeyboardEnd = 0x4D,
  kHIDUsage_KeyboardPageDown = 0x4E,
  kHIDUsage_KeyboardRightArrow = 0x4F,
  kHIDUsage_KeyboardLeftArrow = 0x50,
  kHIDUsage_KeyboardDownArrow = 0x51,
  kHIDUsage_KeyboardUpArrow = 0x52,
  kHIDUsage_KeypadNumLock = 0x53,
  kHIDUsage_KeyboardF13 = 0x68,
  kHIDUsage_KeyboardF24 = 0x73,
  kHIDUsage_KeyboardMenu = 0x76,
  kHIDUsage_KeypadComma = 0x85,
  kHIDUsage_KeyboardLeftControl = 0xE0,
  kHIDUsage_KeyboardLeftShift = 0xE1,
  kHIDUsage_KeyboardLeftAlt = 0xE2,
  kHIDUsage_KeyboardLeftGUI = 0xE3,
  kHIDUsage_KeyboardRightControl = 0xE4,
  kHIDUsage_KeyboardRightShift = 0xE5,
  kHIDUsage_KeyboardRightAlt = 0xE6,
  kHIDUsage_KeyboardRightGUI = 0xE7,
};

// This function is privately defined in IOKit framework.
static uint32_t keyCodeForFunctionKey(NSString* key) {
  // Compare the input string with the function-key names (i.e. "F1",...,"F24").
  for (int i = 1; i <= 12; ++i) {
    if ([key isEqualToString:[NSString stringWithFormat:@"F%d", i]]) {
      return kHIDUsage_KeyboardF1 + i - 1;
    }
  }
  for (int i = 13; i <= 24; ++i) {
    if ([key isEqualToString:[NSString stringWithFormat:@"F%d", i]]) {
      return kHIDUsage_KeyboardF13 + i - 13;
    }
  }
  return 0;
}

// This function is privately defined in IOKit framework.
static inline uint32_t hidUsageCodeForCharacter(NSString* key) {
  const int uppercaseAlphabeticOffset = 'A' - kHIDUsage_KeyboardA;
  const int lowercaseAlphabeticOffset = 'a' - kHIDUsage_KeyboardA;
  const int numericNonZeroOffset = '1' - kHIDUsage_Keyboard1;
  if (key.length == 1) {
    // Handle alphanumeric characters and basic symbols.
    int keyCode = [key characterAtIndex:0];
    if (97 <= keyCode && keyCode <= 122) {  // Handle a-z.
      return keyCode - lowercaseAlphabeticOffset;
    }

    if (65 <= keyCode && keyCode <= 90) {  // Handle A-Z.
      return keyCode - uppercaseAlphabeticOffset;
    }

    if (49 <= keyCode && keyCode <= 57) {  // Handle 1-9.
      return keyCode - numericNonZeroOffset;
    }

    // Handle all other cases.
    switch (keyCode) {
      case '`':
      case '~':
        return kHIDUsage_KeyboardGraveAccentAndTilde;
      case '!':
        return kHIDUsage_Keyboard1;
      case '@':
        return kHIDUsage_Keyboard2;
      case '#':
        return kHIDUsage_Keyboard3;
      case '$':
        return kHIDUsage_Keyboard4;
      case '%':
        return kHIDUsage_Keyboard5;
      case '^':
        return kHIDUsage_Keyboard6;
      case '&':
        return kHIDUsage_Keyboard7;
      case '*':
        return kHIDUsage_Keyboard8;
      case '(':
        return kHIDUsage_Keyboard9;
      case ')':
      case '0':
        return kHIDUsage_Keyboard0;
      case '-':
      case '_':
        return kHIDUsage_KeyboardHyphen;
      case '=':
      case '+':
        return kHIDUsage_KeyboardEqualSign;
      case '\b':
        return kHIDUsage_KeyboardDeleteOrBackspace;
      case '\t':
        return kHIDUsage_KeyboardTab;
      case '[':
      case '{':
        return kHIDUsage_KeyboardOpenBracket;
      case ']':
      case '}':
        return kHIDUsage_KeyboardCloseBracket;
      case '\\':
      case '|':
        return kHIDUsage_KeyboardBackslash;
      case ';':
      case ':':
        return kHIDUsage_KeyboardSemicolon;
      case '\'':
      case '"':
        return kHIDUsage_KeyboardQuote;
      case '\r':
      case '\n':
        return kHIDUsage_KeyboardReturnOrEnter;
      case ',':
      case '<':
        return kHIDUsage_KeyboardComma;
      case '.':
      case '>':
        return kHIDUsage_KeyboardPeriod;
      case '/':
      case '?':
        return kHIDUsage_KeyboardSlash;
      case ' ':
        return kHIDUsage_KeyboardSpacebar;
    }
  }

  uint32_t keyCode = keyCodeForFunctionKey(key);
  if (keyCode) {
    return keyCode;
  }

  if ([key isEqualToString:@"capsLock"] ||
      [key isEqualToString:@"capsLockKey"]) {
    return kHIDUsage_KeyboardCapsLock;
  }
  if ([key isEqualToString:@"pageUp"]) {
    return kHIDUsage_KeyboardPageUp;
  }
  if ([key isEqualToString:@"pageDown"]) {
    return kHIDUsage_KeyboardPageDown;
  }
  if ([key isEqualToString:@"home"]) {
    return kHIDUsage_KeyboardHome;
  }
  if ([key isEqualToString:@"insert"]) {
    return kHIDUsage_KeyboardInsert;
  }
  if ([key isEqualToString:@"end"]) {
    return kHIDUsage_KeyboardEnd;
  }
  if ([key isEqualToString:@"escape"]) {
    return kHIDUsage_KeyboardEscape;
  }
  if ([key isEqualToString:@"return"] || [key isEqualToString:@"enter"]) {
    return kHIDUsage_KeyboardReturnOrEnter;
  }
  if ([key isEqualToString:@"leftArrow"]) {
    return kHIDUsage_KeyboardLeftArrow;
  }
  if ([key isEqualToString:@"rightArrow"]) {
    return kHIDUsage_KeyboardRightArrow;
  }
  if ([key isEqualToString:@"upArrow"]) {
    return kHIDUsage_KeyboardUpArrow;
  }
  if ([key isEqualToString:@"downArrow"]) {
    return kHIDUsage_KeyboardDownArrow;
  }
  if ([key isEqualToString:@"delete"]) {
    return kHIDUsage_KeyboardDeleteOrBackspace;
  }
  if ([key isEqualToString:@"forwardDelete"]) {
    return kHIDUsage_KeyboardDeleteForward;
  }
  if ([key isEqualToString:@"leftCommand"] ||
      [key isEqualToString:@"metaKey"]) {
    return kHIDUsage_KeyboardLeftGUI;
  }
  if ([key isEqualToString:@"rightCommand"]) {
    return kHIDUsage_KeyboardRightGUI;
  }
  if ([key isEqualToString:@"clear"]) {  // Num Lock / Clear
    return kHIDUsage_KeypadNumLock;
  }
  if ([key isEqualToString:@"leftControl"] ||
      [key isEqualToString:@"ctrlKey"]) {
    return kHIDUsage_KeyboardLeftControl;
  }
  if ([key isEqualToString:@"rightControl"]) {
    return kHIDUsage_KeyboardRightControl;
  }
  if ([key isEqualToString:@"leftShift"] || [key isEqualToString:@"shiftKey"]) {
    return kHIDUsage_KeyboardLeftShift;
  }
  if ([key isEqualToString:@"rightShift"]) {
    return kHIDUsage_KeyboardRightShift;
  }
  if ([key isEqualToString:@"leftAlt"] || [key isEqualToString:@"altKey"]) {
    return kHIDUsage_KeyboardLeftAlt;
  }
  if ([key isEqualToString:@"rightAlt"]) {
    return kHIDUsage_KeyboardRightAlt;
  }
  if ([key isEqualToString:@"numpadComma"]) {
    return kHIDUsage_KeypadComma;
  }

  return 0;
}

typedef NS_OPTIONS(NSInteger, BKSKeyModifierFlags) {
  BKSKeyModifierShift = 1 << 17,
  BKSKeyModifierControl = 1 << 18,
  BKSKeyModifierAlternate = 1 << 19,
  BKSKeyModifierCommand = 1 << 20,
};

@interface BKSHIDEventBaseAttributes : NSObject
@end

@interface BKSHIDEventDigitizerAttributes : BKSHIDEventBaseAttributes
@property(nonatomic) BKSKeyModifierFlags activeModifiers;
@end

// These are privately defined in IOKit framework.
enum { kHIDPage_KeyboardOrKeypad = 0x07, kHIDPage_VendorDefinedStart = 0xFF00 };

enum {
  kIOHIDEventOptionNone = 0,
};

// From
// https://github.com/WebKit/WebKit/blob/32d692229b2aa815346811da6a8db51f260090fe/Source/WTF/wtf/cocoa/SoftLinking.h
#define SOFT_LINK_PRIVATE_FRAMEWORK(framework)                              \
  static void* framework##Library() {                                       \
    static void* frameworkLibrary = ^{                                      \
      void* result = dlopen("/System/Library/PrivateFrameworks/" #framework \
                            ".framework/" #framework,                       \
                            RTLD_NOW);                                      \
      return result;                                                        \
    }();                                                                    \
    return frameworkLibrary;                                                \
  }

#ifdef __cplusplus
#define WTF_EXTERN_C_BEGIN extern "C" {
#define WTF_EXTERN_C_END }
#else
#define WTF_EXTERN_C_BEGIN
#define WTF_EXTERN_C_END
#endif

#define SOFT_LINK(framework, functionName, resultType, parameterDeclarations, \
                  parameterNames)                                             \
  WTF_EXTERN_C_BEGIN                                                          \
  resultType functionName parameterDeclarations;                              \
  WTF_EXTERN_C_END                                                            \
  static resultType init##functionName parameterDeclarations;                 \
  static resultType(*softLink##functionName) parameterDeclarations =          \
      init##functionName;                                                     \
                                                                              \
  static resultType init##functionName parameterDeclarations {                \
    softLink##functionName = (resultType(*) parameterDeclarations)dlsym(      \
        framework##Library(), #functionName);                                 \
    return softLink##functionName parameterNames;                             \
  }                                                                           \
                                                                              \
  inline __attribute__((__always_inline__))                                   \
  resultType functionName parameterDeclarations {                             \
    return softLink##functionName parameterNames;                             \
  }

// From
// https://github.com/WebKit/WebKit/blob/32d692229b2aa815346811da6a8db51f260090fe/Tools/WebKitTestRunner/ios/HIDEventGenerator.mm
SOFT_LINK_PRIVATE_FRAMEWORK(BackBoardServices)
SOFT_LINK(BackBoardServices,
          BKSHIDEventSetDigitizerInfo,
          void,
          (IOHIDEventRef digitizerEvent,
           uint32_t contextID,
           uint8_t systemGestureisPossible,
           uint8_t isSystemGestureStateChangeEvent,
           CFStringRef displayUUID,
           CFTimeInterval initialTouchTimestamp,
           float maxForce),
          (digitizerEvent,
           contextID,
           systemGestureisPossible,
           isSystemGestureStateChangeEvent,
           displayUUID,
           initialTouchTimestamp,
           maxForce))
SOFT_LINK(BackBoardServices,
          BKSHIDEventGetDigitizerAttributes,
          BKSHIDEventDigitizerAttributes*,
          (IOHIDEventRef event),
          (event))

#pragma mark - Private API to fake keyboard events.

// Convenience wrapper for IOHIDEventCreateKeyboardEvent.
IOHIDEventRef CreateHIDKeyEvent(NSString* character,
                                uint64_t timestamp,
                                bool isKeyDown) {
  return IOHIDEventCreateKeyboardEvent(
      kCFAllocatorDefault, timestamp, kHIDPage_KeyboardOrKeypad,
      hidUsageCodeForCharacter(character), isKeyDown, kIOHIDEventOptionNone);
}

// A fake class that mirrors UIPhysicalKeyboardEvent private class' fields.
// This class is never used, but it allows to call UIPhysicalKeyboardEvent's API
// by casting an instance of UIPhysicalKeyboardEvent to PhysicalKeyboardEvent.
@interface PhysicalKeyboardEvent : UIEvent
+ (id)_eventWithInput:(id)arg1 inputFlags:(int)arg2;
- (void)_setHIDEvent:(IOHIDEventRef)event keyboard:(void*)gsKeyboard;
// >=iOS17 only.
- (void)_setModifierFlags:(UIKeyModifierFlags)flags;
// <=iOS16 only.
@property(nonatomic) UIKeyModifierFlags _modifierFlags;
@end

// Private API in UIKit.
@interface UIApplication ()
- (void)_enqueueHIDEvent:(IOHIDEventRef)event;
- (void)handleKeyUIEvent:(id)event;
- (void)handleKeyHIDEvent:(id)event;
@end

@interface UIWindow ()
- (uint32_t)_contextId;
@end

#pragma mark - Implementation

using base::test::ios::kWaitForUIElementTimeout;

namespace {

// Delay between simulated keyboard press events.
const double kKeyPressDelay = 0.02;

// Utility to describe modifier flags. Useful in debugging.
[[maybe_unused]] NSString* DescribeFlags(UIKeyModifierFlags flags);
NSString* DescribeFlags(UIKeyModifierFlags flags) {
  NSMutableString* s = [[NSMutableString alloc] init];
  if (flags & UIKeyModifierAlphaShift) {
    [s appendString:@"CapsLock+"];
  }
  if (flags & UIKeyModifierShift) {
    [s appendString:@"Shift+"];
  }
  if (flags & UIKeyModifierControl) {
    [s appendString:@"Ctrl+"];
  }
  if (flags & UIKeyModifierAlternate) {
    [s appendString:@"Alt+"];
  }
  if (flags & UIKeyModifierCommand) {
    [s appendString:@"Command+"];
  }
  if (flags & UIKeyModifierNumericPad) {
    [s appendString:@"NumPad+"];
  }

  return s;
}

uint32_t GetContextId() {
  for (UIScene* scene in UIApplication.sharedApplication.connectedScenes) {
    UIWindowScene* windowScene = (UIWindowScene*)scene;
    for (UIWindow* window in windowScene.windows) {
      if (window.isKeyWindow) {
        return window._contextId;
      }
    }
  }
  return 0;
}

// Sends an individual keyboard press event.
void SendKBEventWithModifiers(UIKeyModifierFlags flags, NSString* input) {
  // Fake up an event.
  PhysicalKeyboardEvent* keyboardEvent =
      [NSClassFromString(@"UIPhysicalKeyboardEvent") _eventWithInput:input
                                                          inputFlags:0];
  if (@available(iOS 17, *)) {
    [keyboardEvent _setModifierFlags:flags];
  } else {
    keyboardEvent._modifierFlags = flags;
  }
  IOHIDEventRef hidEvent =
      CreateHIDKeyEvent(input, keyboardEvent.timestamp, true);
  [keyboardEvent _setHIDEvent:hidEvent keyboard:0];
  [[UIApplication sharedApplication] handleKeyUIEvent:keyboardEvent];
}

// Simulate pressing a hardware keyboard key.
void PressKey(NSString* key) {
  IOHIDEventRef event = CreateHIDKeyEvent(key, mach_absolute_time(), true);
  uint32_t contextId = GetContextId();
  BKSHIDEventSetDigitizerInfo(event, contextId, false, false, NULL, 0, 0);
  [[UIApplication sharedApplication] _enqueueHIDEvent:event];
}

// Simulate releasing a hardware keyboard key.
void ReleaseKey(NSString* key) {
  IOHIDEventRef event = CreateHIDKeyEvent(key, mach_absolute_time(), false);
  uint32_t contextId = GetContextId();
  BKSHIDEventSetDigitizerInfo(event, contextId, false, false, NULL, 0, 0);
  [[UIApplication sharedApplication] _enqueueHIDEvent:event];
}

// Lifts the keypresses one by one.
// Once all keypresses are reversed, executes |completion| on the main thread.
void UnwindFakeKeyboardPressWithFlags(UIKeyModifierFlags flags,
                                      NSString* input,
                                      void (^completion)()) {
  if (flags == 0 && input.length == 0) {
    if (completion) {
      completion();
    }
    return;
  }

  auto block = ^(NSTimer* timer) {
    // First release all the non-modifier
    // keys.
    if (input.length > 0) {
      NSString* remainingInput = [input substringFromIndex:1];

      SendKBEventWithModifiers(flags, remainingInput);
      UnwindFakeKeyboardPressWithFlags(flags, remainingInput, completion);
      return;
    }

    // Unwind the modifier keys.
    for (int i = 16; i < 22; i++) {
      UIKeyModifierFlags flag = 1 << i;
      if (flags & flag) {
        SendKBEventWithModifiers(flags & ~flag, input);
        UnwindFakeKeyboardPressWithFlags(flags & ~flag, input, completion);
      }
    }
  };
  [NSTimer scheduledTimerWithTimeInterval:kKeyPressDelay
                                  repeats:false
                                    block:block];
}

// Programmatically simulates pressing the keys one by one, starting with
// modifier keys and moving to input string through recursion, then calls
// unwindFakeKeyboardPressWithFlags to release the pressed keys in reverse
// order.
// Once all key downs and key ups are simulated, executes |completion| on the
// main thread.
void SimulatePhysicalKeyboardEventInternal(UIKeyModifierFlags flags,
                                           NSString* input,
                                           UIKeyModifierFlags previousFlags,
                                           NSString* previousInput,
                                           void (^completion)()) {
  auto block = ^(NSTimer* timer) {
    // First dial in all the modifier keys.
    for (int i = 15; i < 25; i++) {
      UIKeyModifierFlags flag = 1 << i;
      if (flags & flag) {
        SendKBEventWithModifiers(previousFlags ^ flag, previousInput);
        SimulatePhysicalKeyboardEventInternal(flags & ~flag, input,
                                              previousFlags ^ flag,
                                              previousInput, completion);
        return;
      }
    }

    // Now add the next input char.
    if (input.length > 0) {
      NSString* pressedKey = [input substringToIndex:1];
      NSString* remainingInput = [input substringFromIndex:1];
      NSString* alreadyPressedString =
          [previousInput stringByAppendingString:pressedKey];

      SendKBEventWithModifiers(previousFlags, alreadyPressedString);
      SimulatePhysicalKeyboardEventInternal(flags, remainingInput,
                                            previousFlags, alreadyPressedString,
                                            completion);
    } else {
      // Time to unwind the presses.
      UnwindFakeKeyboardPressWithFlags(previousFlags, previousInput,
                                       completion);
    }
  };
  [NSTimer scheduledTimerWithTimeInterval:kKeyPressDelay
                                  repeats:false
                                    block:block];
}

}  // namespace

#pragma mark - Public

namespace chrome_test_util {

void SimulatePhysicalKeyboardEvent(UIKeyModifierFlags flags, NSString* input) {
  // No modifier keys pressed.
  if (flags == 0) {
    if (hidUsageCodeForCharacter(input)) {
      // Input is a keyboard key.
      PressKey(input);
      ReleaseKey(input);
      return;
    }

    // If there are no modifier keys and the input is not a keyboard key. Our
    // intention is then to type the input.
    for (NSUInteger i = 0; i < [input length]; i++) {
      NSRange range = NSMakeRange(i, 1);
      NSString* key = [input substringWithRange:range];
      PressKey(key);
      ReleaseKey(key);
    }
    return;
  }

  // Input with modifier keys.
  __block BOOL keyPressesFinished = NO;

  SimulatePhysicalKeyboardEventInternal(flags, input, 0, @"", ^{
    keyPressesFinished = YES;
  });

  BOOL __unused result =
      base::test::ios::WaitUntilConditionOrTimeout(kWaitForUIElementTimeout, ^{
        return keyPressesFinished;
      });
}

}  // namespace chrome_test_util