// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.

#include "pch.h"

#include "TextInputViewManager.h"

#include "Unicode.h"
#include "Utils/XamlIslandUtils.h"

#include <UI.Xaml.Controls.h>
#include <UI.Xaml.Input.h>
#include <UI.Xaml.Shapes.h>
#include <Utils/PropertyHandlerUtils.h>
#include <Utils/PropertyUtils.h>
#include <Utils/ValueUtils.h>

#include <INativeUIManager.h>
#include <IReactInstance.h>
#include <Modules/NativeUIManager.h>
#include <Modules/PaperUIManagerModule.h>
#include <Views/FrameworkElementTransferProperties.h>

#ifdef USE_WINUI3
namespace winrt::Microsoft::UI::Xaml::Controls {
using IPasswordBox4 = ::xaml::Controls::IPasswordBox;
using ITextBox6 = ::xaml::Controls::ITextBox;
}; // namespace winrt::Microsoft::UI::Xaml::Controls
#endif

namespace winrt {
using namespace xaml;
using namespace xaml::Media;
using namespace xaml::Shapes;
} // namespace winrt

namespace Microsoft::ReactNative {
struct Selection {
  int64_t start = -1;
  int64_t end = -1;
};
} // namespace Microsoft::ReactNative

// Such code is better to move to a separate parser layer
template <>
struct json_type_traits<Microsoft::ReactNative::Selection> {
  static Microsoft::ReactNative::Selection parseJson(const winrt::Microsoft::ReactNative::JSValue &json) {
    Microsoft::ReactNative::Selection selection;
    for (auto &item : json.AsObject()) {
      if (item.first == "start") {
        auto start = item.second.AsInt64();
        if (start == start)
          selection.start = start;
      } else if (item.first == "end") {
        auto end = item.second.AsInt64();
        if (end == end)
          selection.end = end;
      }
    }
    return selection;
  }
};

static const std::unordered_map<std::string, xaml::Input::InputScopeNameValue> textBoxKeyboardTypeMap = {
    {"default", xaml::Input::InputScopeNameValue::Default},
    {"number-pad", xaml::Input::InputScopeNameValue::TelephoneNumber},
    {"decimal-pad", xaml::Input::InputScopeNameValue::Digits},
    {"email-address", xaml::Input::InputScopeNameValue::EmailNameOrAddress},
    {"phone-pad", xaml::Input::InputScopeNameValue::TelephoneNumber},
    {"numeric", xaml::Input::InputScopeNameValue::Number},
    {"url", xaml::Input::InputScopeNameValue::Url},
    {"web-search", xaml::Input::InputScopeNameValue::Search}};

static const std::unordered_map<std::string, xaml::Input::InputScopeNameValue> passwordBoxKeyboardTypeMap = {
    {"default", xaml::Input::InputScopeNameValue::Password},
    {"numeric", xaml::Input::InputScopeNameValue::NumericPin}};

static xaml::Input::InputScopeNameValue parseKeyboardType(
    const winrt::Microsoft::ReactNative::JSValue &val,
    const bool isTextBox) {
  auto keyboardTypeMap = isTextBox ? textBoxKeyboardTypeMap : passwordBoxKeyboardTypeMap;

  auto iter = keyboardTypeMap.find(val.AsString());

  if (iter != keyboardTypeMap.end()) {
    return iter->second;
  }

  return isTextBox ? xaml::Input::InputScopeNameValue::Default : xaml::Input::InputScopeNameValue::Password;
}

namespace Microsoft::ReactNative {

class TextInputShadowNode : public ShadowNodeBase {
  using Super = ShadowNodeBase;

 public:
  TextInputShadowNode() = default;
  void createView(const winrt::Microsoft::ReactNative::JSValueObject &) override;
  void updateProperties(winrt::Microsoft::ReactNative::JSValueObject &props) override;

  void dispatchCommand(const std::string &commandId, winrt::Microsoft::ReactNative::JSValueArray &&commandArgs)
      override;

  void AddView(ShadowNode & /*child*/, int64_t /*index*/) override {
    // NYI #5689
    YellowBox("Nested elements in TextInput are currently unsupported on Windows");
  }
  void RemoveChildAt(int64_t /*indexToRemove*/) override {
    // NYI #5689
    YellowBox("Nested elements in TextInput are currently unsupported on Windows");
  }
  void ReplaceChild(const XamlView & /*oldChildView*/, const XamlView & /*newChildView*/) override {
    // NYI #5689
    YellowBox("Nested elements in TextInput are currently unsupported on Windows");
  }

  bool ImplementsPadding() override {
    return true;
  }

  virtual bool NeedsForceLayout() override {
    return true;
  }

 private:
  void dispatchTextInputChangeEvent(winrt::hstring newText);
  void registerEvents();
  void registerPreviewKeyDown();
  void UpdateCaretColorOrHideIfNeeded();
  void setPasswordBoxPlaceholderForeground(
      xaml::Controls::PasswordBox passwordBox,
      const winrt::Microsoft::ReactNative::JSValue &color);
  void SetText(const winrt::Microsoft::ReactNative::JSValue &text);
  void SetSelection(int64_t start, int64_t end);
  winrt::Shape FindCaret(xaml::DependencyObject element);
  bool IsTextBox();

  bool m_initialUpdateComplete = false;
  bool m_autoFocus = false;
  bool m_shouldClearTextOnFocus = false;
  bool m_shouldSelectTextOnFocus = false;
  bool m_contextMenuHidden = false;
  bool m_hideCaret = false;
  bool m_shouldClearTextOnSubmit = false;

  winrt::Microsoft::ReactNative::JSValue m_cursorColor;

  winrt::Microsoft::ReactNative::JSValue m_placeholderTextColor;
  std::vector<HandledKeyboardEvent> m_submitKeyEvents{};

  // Javascripts is running in a different thread. If the typing is very fast,
  // It's possible that two TextChanged are raised but TextInput just got the
  // first response from Javascript. So the first response should be dropped.
  // EventCount is introduced to resolve this problem
  uint32_t m_nativeEventCount{0}; // EventCount to javascript
  uint32_t m_mostRecentEventCount{0}; // EventCount from javascript

 private:
  xaml::Controls::TextBox::TextChanging_revoker m_textBoxTextChangingRevoker{};
  xaml::Controls::TextBox::SelectionChanged_revoker m_textBoxSelectionChangedRevoker{};
  xaml::Controls::TextBox::ContextMenuOpening_revoker m_textBoxContextMenuOpeningRevoker{};

  xaml::Controls::PasswordBox::PasswordChanging_revoker m_passwordBoxPasswordChangingRevoker{};
  xaml::Controls::PasswordBox::PasswordChanged_revoker m_passwordBoxPasswordChangedRevoker{};
  xaml::Controls::PasswordBox::ContextMenuOpening_revoker m_passwordBoxContextMenuOpeningRevoker{};

  xaml::Controls::Control::GotFocus_revoker m_controlGotFocusRevoker{};
  xaml::Controls::Control::LostFocus_revoker m_controlLostFocusRevoker{};
  xaml::Controls::Control::PreviewKeyDown_revoker m_controlPreviewKeyDownRevoker{};
  xaml::Controls::Control::SizeChanged_revoker m_controlSizeChangedRevoker{};
  xaml::Controls::Control::CharacterReceived_revoker m_controlCharacterReceivedRevoker{};
  xaml::Controls::ScrollViewer::ViewChanging_revoker m_scrollViewerViewChangingRevoker{};
  xaml::Controls::Control::Loaded_revoker m_controlLoadedRevoker{};
};

void TextInputShadowNode::createView(const winrt::Microsoft::ReactNative::JSValueObject &props) {
  Super::createView(props);
  registerEvents();
}

void TextInputShadowNode::dispatchTextInputChangeEvent(winrt::hstring newText) {
  if (!m_initialUpdateComplete) {
    return;
  }
  m_nativeEventCount++;
  folly::dynamic eventData =
      folly::dynamic::object("target", m_tag)("text", HstringToDynamic(newText))("eventCount", m_nativeEventCount);
  GetViewManager()->GetReactContext().DispatchEvent(m_tag, "topTextInputChange", std::move(eventData));
}

void TextInputShadowNode::registerEvents() {
  auto control = GetView().as<xaml::Controls::Control>();
  auto tag = m_tag;
  auto isTextBox = IsTextBox();

  // TextChanged is implemented as async event in Xaml. If Javascript is like
  // this:
  //    onChangeText={text => this.setState({text})}
  // And user type 'AB' very fast, then 'B' is possible to be lost in below
  // situation.
  //    Input 'A' -> TextChanged for 'A' -> Javascript processing 'A' -> Input
  //    becomes 'AB' -> Processing javascript response and set text to 'A'
  //    TextChanged for 'AB' but textbox.Text is 'A' -> Javascript processing
  //    'A'
  //
  // TextChanging is used to drop the Javascript response of 'A' and expect
  // another TextChanged event with correct event count.
  if (isTextBox) {
    m_passwordBoxPasswordChangedRevoker = {};
    m_passwordBoxPasswordChangingRevoker = {};
    auto textBox = control.as<xaml::Controls::TextBox>();
    EnsureUniqueTextFlyoutForXamlIsland(textBox);
    m_textBoxTextChangingRevoker = textBox.TextChanging(
        winrt::auto_revoke, [=](auto &&, auto &&) { dispatchTextInputChangeEvent(textBox.Text()); });
  } else {
    m_textBoxTextChangingRevoker = {};
    auto passwordBox = control.as<xaml::Controls::PasswordBox>();
    EnsureUniqueTextFlyoutForXamlIsland(passwordBox);
    if (control.try_as<xaml::Controls::IPasswordBox4>()) {
      m_passwordBoxPasswordChangingRevoker = passwordBox.PasswordChanging(
          winrt::auto_revoke, [=](auto &&, auto &&) { dispatchTextInputChangeEvent(passwordBox.Password()); });
    } else {
      m_passwordBoxPasswordChangedRevoker = passwordBox.PasswordChanged(
          winrt::auto_revoke, [=](auto &&, auto &&) { dispatchTextInputChangeEvent(passwordBox.Password()); });
    }
  }

  if (isTextBox) {
    m_passwordBoxContextMenuOpeningRevoker = {};
    auto textBox = control.as<xaml::Controls::TextBox>();
    m_textBoxContextMenuOpeningRevoker =
        textBox.ContextMenuOpening(winrt::auto_revoke, [=](auto &&, xaml::Controls::ContextMenuEventArgs const &e) {
          if (m_contextMenuHidden) {
            e.Handled(true);
          }
        });
  } else {
    m_textBoxContextMenuOpeningRevoker = {};
    auto passwordBox = control.as<xaml::Controls::PasswordBox>();
    m_passwordBoxContextMenuOpeningRevoker =
        passwordBox.ContextMenuOpening(winrt::auto_revoke, [=](auto &&, xaml::Controls::ContextMenuEventArgs const &e) {
          if (m_contextMenuHidden) {
            e.Handled(true);
          }
        });
  }

  m_controlGotFocusRevoker = control.GotFocus(winrt::auto_revoke, [=](auto &&, auto &&) {
    if (m_shouldClearTextOnFocus) {
      if (isTextBox) {
        control.as<xaml::Controls::TextBox>().ClearValue(xaml::Controls::TextBox::TextProperty());
      } else {
        control.as<xaml::Controls::PasswordBox>().ClearValue(xaml::Controls::PasswordBox::PasswordProperty());
      }
    }

    if (m_shouldSelectTextOnFocus) {
      if (isTextBox) {
        control.as<xaml::Controls::TextBox>().SelectAll();
      } else {
        control.as<xaml::Controls::PasswordBox>().SelectAll();
      }
    }
    UpdateCaretColorOrHideIfNeeded();

    folly::dynamic eventData = folly::dynamic::object("target", tag);
    if (!m_updating)
      GetViewManager()->GetReactContext().DispatchEvent(tag, "topTextInputFocus", std::move(eventData));
  });

  m_controlLostFocusRevoker = control.LostFocus(winrt::auto_revoke, [=](auto &&, auto &&) {
    folly::dynamic eventDataBlur = folly::dynamic::object("target", tag);
    folly::dynamic eventDataEndEditing = {};
    if (isTextBox) {
      eventDataEndEditing =
          folly::dynamic::object("target", tag)("text", HstringToDynamic(control.as<xaml::Controls::TextBox>().Text()));
    } else {
      eventDataEndEditing = folly::dynamic::object("target", tag)(
          "text", HstringToDynamic(control.as<xaml::Controls::PasswordBox>().Password()));
    }
    if (!m_updating) {
      GetViewManager()->GetReactContext().DispatchEvent(tag, "topTextInputBlur", std::move(eventDataBlur));
      GetViewManager()->GetReactContext().DispatchEvent(tag, "topTextInputEndEditing", std::move(eventDataEndEditing));
    }
  });

  registerPreviewKeyDown();

  if (isTextBox) {
    auto textBox = control.as<xaml::Controls::TextBox>();
    m_textBoxSelectionChangedRevoker = textBox.SelectionChanged(winrt::auto_revoke, [=](auto &&, auto &&) {
      folly::dynamic selectionData = folly::dynamic::object("start", textBox.SelectionStart())(
          "end", textBox.SelectionStart() + textBox.SelectionLength());
      folly::dynamic eventData = folly::dynamic::object("target", tag)("selection", std::move(selectionData));
      if (!m_updating)
        GetViewManager()->GetReactContext().DispatchEvent(tag, "topTextInputSelectionChange", std::move(eventData));
    });
  }

  m_controlSizeChangedRevoker =
      control.SizeChanged(winrt::auto_revoke, [=](auto &&, winrt::SizeChangedEventArgs const &args) {
        if (isTextBox) {
          if (control.as<xaml::Controls::TextBox>().TextWrapping() == xaml::TextWrapping::Wrap) {
            folly::dynamic contentSizeData =
                folly::dynamic::object("width", args.NewSize().Width)("height", args.NewSize().Height);
            folly::dynamic eventData = folly::dynamic::object("target", tag)("contentSize", std::move(contentSizeData));
            if (!m_updating)
              GetViewManager()->GetReactContext().DispatchEvent(
                  tag, "topTextInputContentSizeChange", std::move(eventData));
          }
        }
      });

  m_controlLoadedRevoker = control.Loaded(winrt::auto_revoke, [=](auto &&, auto &&) {
    if (m_autoFocus) {
      if (auto uiManager = GetNativeUIManager(GetViewManager()->GetReactContext()).lock()) {
        uiManager->focus(m_tag);
      }
    }

    auto contentElement = control.as<xaml::Controls::IControlProtected>().GetTemplateChild(L"ContentElement");
    auto textBoxView = contentElement.as<xaml::Controls::ScrollViewer>();
    if (textBoxView) {
      m_scrollViewerViewChangingRevoker = textBoxView.ViewChanging(
          winrt::auto_revoke, [=](auto &&, xaml::Controls::ScrollViewerViewChangingEventArgs const &args) {
            if (!m_updating) {
              folly::dynamic offsetData = folly::dynamic::object("x", args.FinalView().HorizontalOffset())(
                  "y", args.FinalView().VerticalOffset());
              folly::dynamic eventData = folly::dynamic::object("target", tag)("contentOffset", std::move(offsetData));
              GetViewManager()->GetReactContext().DispatchEvent(tag, "topTextInputScroll", std::move(eventData));
            }
          });
    }
    UpdateCaretColorOrHideIfNeeded();
  });

  if (control.try_as<xaml::IUIElement7>()) {
    m_controlCharacterReceivedRevoker = control.CharacterReceived(
        winrt::auto_revoke, [=](auto &&, xaml::Input::CharacterReceivedRoutedEventArgs const &args) {
          std::string key;
          wchar_t s[2] = L" ";
          s[0] = args.Character();
          key = Microsoft::Common::Unicode::Utf16ToUtf8(s, 1);

          if (key.compare("\r") == 0) {
            key = "Enter";
          } else if (key.compare("\b") == 0) {
            key = "Backspace";
          }

          if (!m_updating) {
            folly::dynamic eventData = folly::dynamic::object("target", tag)("key", folly::dynamic(key));
            GetViewManager()->GetReactContext().DispatchEvent(tag, "topTextInputKeyPress", std::move(eventData));
          }
        });
  }

  control.as<xaml::UIElement>().AddHandler(
      xaml::UIElement::PointerPressedEvent(),
      winrt::box_value(xaml::Input::PointerEventHandler([=](auto &&, xaml::Input::PointerRoutedEventArgs const &args) {
        folly::dynamic eventData = folly::dynamic::object("target", tag);
        GetViewManager()->GetReactContext().DispatchEvent(tag, "topTextInputPressIn", std::move(eventData));
      })),
      true);

  control.as<xaml::UIElement>().AddHandler(
      xaml::UIElement::PointerReleasedEvent(),
      winrt::box_value(xaml::Input::PointerEventHandler([=](auto &&, xaml::Input::PointerRoutedEventArgs const &args) {
        folly::dynamic eventData = folly::dynamic::object("target", tag);
        GetViewManager()->GetReactContext().DispatchEvent(tag, "topTextInputPressOut", std::move(eventData));
      })),
      true);
}

void TextInputShadowNode::registerPreviewKeyDown() {
  auto control = GetView().as<xaml::Controls::Control>();
  auto tag = m_tag;
  auto isTextBox = IsTextBox();
  m_controlPreviewKeyDownRevoker =
      control.PreviewKeyDown(winrt::auto_revoke, [=](auto &&, xaml::Input::KeyRoutedEventArgs const &args) {
        auto isMultiline = isTextBox && control.as<xaml::Controls::TextBox>().AcceptsReturn();
        auto shouldSubmit = !args.Handled();
        if (shouldSubmit) {
          if (!isMultiline && m_submitKeyEvents.size() == 0) {
            // If no 'submitKeyEvents' are supplied, use the default behavior for single-line TextInput
            shouldSubmit = args.Key() == winrt::Windows::System::VirtualKey::Enter;
          } else if (m_submitKeyEvents.size() > 0) {
            // If 'submitKeyEvents' are supplied, use them to determine whether to emit
            // 'onSubmitEditing' for either single-line or multi-line TextInput

            // This must be kept in sync with the default value for HandledKeyboardEvent.handledEventPhase
            auto defaultEventPhase = HandledEventPhase::Bubbling;
            auto currentEvent = KeyboardHelper::CreateKeyboardEvent(defaultEventPhase, args);
            shouldSubmit = KeyboardHelper::ShouldMarkKeyboardHandled(m_submitKeyEvents, currentEvent);
          } else {
            // If no 'submitKeyEvents' are supplied, do not emit 'onSubmitEditing' for multi-line TextInput
            shouldSubmit = false;
          }
        }

        if (shouldSubmit) {
          folly::dynamic eventDataSubmitEditing = {};
          if (isTextBox) {
            eventDataSubmitEditing = folly::dynamic::object("target", tag)(
                "text", HstringToDynamic(control.as<xaml::Controls::TextBox>().Text()));
          } else {
            eventDataSubmitEditing = folly::dynamic::object("target", tag)(
                "text", HstringToDynamic(control.as<xaml::Controls::PasswordBox>().Password()));
          }

          GetViewManager()->GetReactContext().DispatchEvent(
              tag, "topTextInputSubmitEditing", std::move(eventDataSubmitEditing));

          if (m_shouldClearTextOnSubmit) {
            if (isTextBox) {
              control.as<xaml::Controls::TextBox>().ClearValue(xaml::Controls::TextBox::TextProperty());
            } else {
              control.as<xaml::Controls::PasswordBox>().ClearValue(xaml::Controls::PasswordBox::PasswordProperty());
            }
          }

          // For multi-line TextInput, we have to mark the PreviewKeyDown event as
          // handled to prevent the TextInput from adding a newline character
          if (isMultiline) {
            args.Handled(true);
          }
        }
      });
}

xaml::Shapes::Shape TextInputShadowNode::FindCaret(xaml::DependencyObject element) {
  if (element == nullptr)
    return nullptr;

  if (auto shape = element.try_as<winrt::Shape>())
    return shape;

  int childrenCount = winrt::VisualTreeHelper::GetChildrenCount(element);
  for (int i = 0; i < childrenCount; i++) {
    auto result = FindCaret(winrt::VisualTreeHelper::GetChild(element, i));
    if (result != nullptr)
      return result;
  }

  return nullptr;
}

bool TextInputShadowNode::IsTextBox() {
  return !!GetView().try_as<xaml::Controls::TextBox>();
}

// hacking solution to hide the caret or change its color
void TextInputShadowNode::UpdateCaretColorOrHideIfNeeded() {
  bool updateRequired = false;
  xaml::Media::SolidColorBrush color;

  if (m_hideCaret) {
    updateRequired = true;
    color = xaml::Media::SolidColorBrush(winrt::Colors::Transparent());
  } else if (!m_cursorColor.IsNull()) {
    updateRequired = true;
    color = SolidColorBrushFrom(m_cursorColor);
  }

  if (updateRequired) {
    auto control = GetView().as<xaml::Controls::Control>();
    if (auto caret = FindCaret(control)) {
      caret.CompositeMode(xaml::Media::ElementCompositeMode::Inherit);
      caret.Fill(color);
    }
  }
}

void TextInputShadowNode::setPasswordBoxPlaceholderForeground(
    xaml::Controls::PasswordBox passwordBox,
    const winrt::Microsoft::ReactNative::JSValue &color) {
  m_placeholderTextColor = color.Copy();
  auto defaultRD = xaml::ResourceDictionary();
  auto solidColorBrush = ColorFrom(m_placeholderTextColor);
  defaultRD.Insert(winrt::box_value(L"TextControlPlaceholderForeground"), winrt::box_value(solidColorBrush));
  defaultRD.Insert(winrt::box_value(L"TextControlPlaceholderForegroundFocused"), winrt::box_value(solidColorBrush));
  defaultRD.Insert(winrt::box_value(L"TextControlPlaceholderForegroundPointerOver"), winrt::box_value(solidColorBrush));
  defaultRD.Insert(winrt::box_value(L"TextControlPlaceholderForegroundDisabled"), winrt::box_value(solidColorBrush));
  auto passwordBoxResource = xaml::ResourceDictionary();
  auto themeDictionaries = passwordBoxResource.ThemeDictionaries();
  themeDictionaries.Insert(winrt::box_value(L"Default"), defaultRD);
  passwordBoxResource.Insert(winrt::box_value(L"ThemeDictionaries"), themeDictionaries);
  passwordBox.Resources(passwordBoxResource);
}

void TextInputShadowNode::updateProperties(winrt::Microsoft::ReactNative::JSValueObject &props) {
  m_updating = true;
  auto control = GetView().as<xaml::Controls::Control>();
  auto textBox = control.try_as<xaml::Controls::TextBox>();
  auto passwordBox = control.try_as<xaml::Controls::PasswordBox>();
  auto hasKeyDownEvents = false;

  auto markDirty = false;
  auto isTextBox = IsTextBox();
  for (auto &pair : props) {
    const std::string &propertyName = pair.first;
    const auto &propertyValue = pair.second;

    // Applicable properties for both TextBox and PasswordBox
    if (TryUpdateFontProperties(control, propertyName, propertyValue)) {
      markDirty = true;
      continue;
    } else if (TryUpdateCharacterSpacing(control, propertyName, propertyValue)) {
      markDirty = true;
      continue;
    } else if (propertyName == "allowFontScaling") {
      markDirty = true;
      if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Boolean)
        control.IsTextScaleFactorEnabled(propertyValue.AsBoolean());
      else if (propertyValue.IsNull())
        control.ClearValue(xaml::Controls::Control::IsTextScaleFactorEnabledProperty());
    } else if (propertyName == "clearTextOnFocus") {
      if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Boolean)
        m_shouldClearTextOnFocus = propertyValue.AsBoolean();
    } else if (propertyName == "selectTextOnFocus") {
      if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Boolean)
        m_shouldSelectTextOnFocus = propertyValue.AsBoolean();
    } else if (propertyName == "mostRecentEventCount") {
      if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Double ||
          propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Int64) {
        m_mostRecentEventCount = propertyValue.AsInt32();
      }
    } else if (propertyName == "contextMenuHidden") {
      if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Boolean)
        m_contextMenuHidden = propertyValue.AsBoolean();
    } else if (propertyName == "caretHidden") {
      if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Boolean) {
        m_hideCaret = propertyValue.AsBoolean();
        UpdateCaretColorOrHideIfNeeded();
      }
    } else if (propertyName == "focusable") {
      // parent class also sets isTabStop
      if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Boolean) {
        control.IsEnabled(propertyValue.AsBoolean());
      } else if (propertyValue.IsNull()) {
        control.ClearValue(xaml::Controls::Control::IsEnabledProperty());
      }
    } else if (propertyName == "secureTextEntry") {
      markDirty = true;
      if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Boolean) {
        if (propertyValue.AsBoolean()) {
          if (isTextBox) {
            xaml::Controls::PasswordBox newPasswordBox;
            ReparentView(newPasswordBox);
            isTextBox = false;
            registerEvents();
            control = newPasswordBox.as<xaml::Controls::Control>();
            passwordBox = newPasswordBox;
            if (!m_placeholderTextColor.IsNull()) {
              setPasswordBoxPlaceholderForeground(newPasswordBox, m_placeholderTextColor);
            }
          }
        } else {
          if (!isTextBox) {
            xaml::Controls::TextBox newTextBox;
            ReparentView(newTextBox);
            isTextBox = true;
            registerEvents();
            control = newTextBox.as<xaml::Controls::Control>();
            textBox = newTextBox;
            if (!m_placeholderTextColor.IsNull()) {
              textBox.PlaceholderForeground(SolidColorBrushFrom(m_placeholderTextColor));
            }
          }
        }
      }
    } else if (propertyName == "maxLength") {
      markDirty = true;
      if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Double ||
          propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Int64) {
        control.SetValue(
            isTextBox ? xaml::Controls::TextBox::MaxLengthProperty() : xaml::Controls::PasswordBox::MaxLengthProperty(),
            winrt::PropertyValue::CreateInt32(propertyValue.AsInt32()));
      } else if (propertyValue.IsNull()) {
        control.ClearValue(
            isTextBox ? xaml::Controls::TextBox::MaxLengthProperty()
                      : xaml::Controls::PasswordBox::MaxLengthProperty());
      }
    } else if (propertyName == "placeholder") {
      if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::String) {
        control.SetValue(
            isTextBox ? xaml::Controls::TextBox::PlaceholderTextProperty()
                      : xaml::Controls::PasswordBox::PlaceholderTextProperty(),
            winrt::PropertyValue::CreateString(asHstring(propertyValue)));
      } else if (propertyValue.IsNull()) {
        control.ClearValue(
            isTextBox ? xaml::Controls::TextBox::PlaceholderTextProperty()
                      : xaml::Controls::PasswordBox::PlaceholderTextProperty());
      }
    } else if (propertyName == "cursorColor") {
      m_cursorColor = nullptr;
      if (IsValidColorValue(propertyValue)) {
        m_cursorColor = propertyValue.Copy();
      }
    } else if (propertyName == "selectionColor") {
      if (IsValidColorValue(propertyValue)) {
        control.SetValue(
            isTextBox ? xaml::Controls::TextBox::SelectionHighlightColorProperty()
                      : xaml::Controls::PasswordBox::SelectionHighlightColorProperty(),
            SolidColorBrushFrom(propertyValue));
      } else if (propertyValue.IsNull())
        control.ClearValue(
            isTextBox ? xaml::Controls::TextBox::SelectionHighlightColorProperty()
                      : xaml::Controls::PasswordBox::SelectionHighlightColorProperty());
    } else if (propertyName == "keyboardType") {
      if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::String) {
        auto inputScopeNameValue = parseKeyboardType(propertyValue, isTextBox);
        auto scope = xaml::Input::InputScope();
        auto scopeName = xaml::Input::InputScopeName(inputScopeNameValue);
        auto names = scope.Names();
        names.Append(scopeName);
        control.SetValue(
            isTextBox ? xaml::Controls::TextBox::InputScopeProperty()
                      : xaml::Controls::PasswordBox::InputScopeProperty(),
            scope);
      } else if (propertyValue.IsNull())
        control.ClearValue(
            isTextBox ? xaml::Controls::TextBox::InputScopeProperty()
                      : xaml::Controls::PasswordBox::InputScopeProperty());
    } else if (propertyName == "placeholderTextColor") {
      m_placeholderTextColor = nullptr;
      if (textBox.try_as<xaml::Controls::ITextBox6>() && isTextBox) {
        if (IsValidColorValue(propertyValue)) {
          m_placeholderTextColor = propertyValue.Copy();
          textBox.PlaceholderForeground(SolidColorBrushFrom(propertyValue));
        } else if (propertyValue.IsNull())
          textBox.ClearValue(xaml::Controls::TextBox::PlaceholderForegroundProperty());
      } else if (isTextBox != true && IsValidColorValue(propertyValue)) {
        setPasswordBoxPlaceholderForeground(passwordBox, propertyValue);
      }
    } else if (propertyName == "clearTextOnSubmit") {
      if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Boolean)
        m_shouldClearTextOnSubmit = propertyValue.AsBoolean();
    } else if (propertyName == "submitKeyEvents") {
      if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Array)
        m_submitKeyEvents = KeyboardHelper::FromJS(propertyValue);
      else if (propertyValue.IsNull())
        m_submitKeyEvents.clear();
    } else if (propertyName == "keyDownEvents") {
      hasKeyDownEvents = propertyValue.ItemCount() > 0;
    } else if (propertyName == "autoFocus") {
      if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Boolean)
        m_autoFocus = propertyValue.AsBoolean();
    } else if (propertyName == "editable") {
      if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Boolean) {
        isTextBox ? textBox.IsReadOnly(!propertyValue.AsBoolean()) : passwordBox.IsEnabled(propertyValue.AsBoolean());
      } else if (propertyValue.IsNull()) {
        isTextBox ? textBox.ClearValue(xaml::Controls::TextBox::IsReadOnlyProperty())
                  : passwordBox.ClearValue(xaml::Controls::Control::IsEnabledProperty());
      }
    } else {
      if (isTextBox) { // Applicable properties for TextBox
        if (TryUpdateTextAlignment(textBox, propertyName, propertyValue)) {
          continue;
        } else if (propertyName == "multiline") {
          markDirty = true;
          if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Boolean) {
            const bool isMultiline = propertyValue.AsBoolean();
            textBox.TextWrapping(isMultiline ? xaml::TextWrapping::Wrap : xaml::TextWrapping::NoWrap);
            textBox.AcceptsReturn(isMultiline);
          } else if (propertyValue.IsNull())
            textBox.ClearValue(xaml::Controls::TextBox::TextWrappingProperty());
        } else if (propertyName == "scrollEnabled") {
          if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Boolean &&
              textBox.TextWrapping() == xaml::TextWrapping::Wrap) {
            auto scrollMode =
                propertyValue.AsBoolean() ? xaml::Controls::ScrollMode::Auto : xaml::Controls::ScrollMode::Disabled;
            xaml::Controls::ScrollViewer::SetVerticalScrollMode(textBox, scrollMode);
            xaml::Controls::ScrollViewer::SetHorizontalScrollMode(textBox, scrollMode);
          }
        } else if (propertyName == "spellCheck") {
          if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Boolean)
            textBox.IsSpellCheckEnabled(propertyValue.AsBoolean());
          else if (propertyValue.IsNull())
            textBox.ClearValue(xaml::Controls::TextBox::IsSpellCheckEnabledProperty());
        } else if (propertyName == "text") {
          markDirty = true;
          SetText(propertyValue);
        } else if (propertyName == "autoCapitalize") {
          if (textBox.try_as<xaml::Controls::ITextBox6>()) {
            if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::String) {
              if (propertyValue.AsString() == "characters") {
                textBox.CharacterCasing(xaml::Controls::CharacterCasing::Upper);
              } else { // anything else turns off autoCap (should be "None" but
                       // we don't support "words"/"sentences" yet)
                textBox.CharacterCasing(xaml::Controls::CharacterCasing::Normal);
              }
            } else if (propertyValue.IsNull())
              textBox.ClearValue(xaml::Controls::TextBox::CharacterCasingProperty());
          }
        }
      } else { // Applicable properties for PasswordBox
        if (propertyName == "text" && !isTextBox) {
          markDirty = true;
          SetText(propertyValue);
        }
      }
    }
  }

  if (markDirty) {
    GetViewManager()->MarkDirty(m_tag);
  }

  Super::updateProperties(props);

  // We need to re-register the PreviewKeyDown handler so it is invoked after the ShadowNodeBase handler
  if (hasKeyDownEvents) {
    m_controlPreviewKeyDownRevoker.revoke();
    registerPreviewKeyDown();
  }

  m_updating = false;
  m_initialUpdateComplete = true;
}

void TextInputShadowNode::SetText(const winrt::Microsoft::ReactNative::JSValue &text) {
  auto textBox = this->GetView().try_as<xaml::Controls::TextBox>();
  auto passwordBox = this->GetView().try_as<xaml::Controls::PasswordBox>();

  if (m_mostRecentEventCount == m_nativeEventCount) {
    if (textBox) {
      if (text.Type() == winrt::Microsoft::ReactNative::JSValueType::String) {
        auto oldCursor = textBox.SelectionStart();
        auto oldSelectionLength = textBox.SelectionLength();
        auto oldValue = textBox.Text();
        auto newValue = asHstring(text);
        if (oldValue != newValue) {
          if (!textBox.IsReadOnly()) {
            uint32_t diffStartIndex = 0;
            uint32_t diffEndIndex = 0;
            // Replacing the entire string with the new value resets the text history.
            // Generally speaking, this is undesirable. To mitigate this issue, we can
            // replace text using the XAML TextBox::SelectedText property, which retains
            // undo / redo history. To do so, we use a simple algorithm that finds a
            // single diff in the values:
            // 1. Find first character that mismatches iterating forwards
            while (diffStartIndex < oldValue.size() && diffStartIndex < newValue.size() &&
                   oldValue[diffStartIndex] == newValue[diffStartIndex]) {
              diffStartIndex++;
            }
            // 2. Find last character the mismatches beyond the first mismatch iterating backwards
            while (diffEndIndex < oldValue.size() - diffStartIndex && diffEndIndex < newValue.size() - diffStartIndex &&
                   oldValue[oldValue.size() - diffEndIndex - 1] == newValue[newValue.size() - diffEndIndex - 1]) {
              diffEndIndex++;
            }
            // 3. Select the range between the start and end index in the "old value"
            textBox.SelectionStart(diffStartIndex);
            textBox.SelectionLength(oldValue.size() - diffStartIndex - diffEndIndex);
            // 4. Replace the selected text with the range between start and end index in the "new value"
            // Copies the substring view into a new winrt::hstring due to occasional crash
            winrt::hstring replacementValue{
                std::wstring_view{newValue}.substr(diffStartIndex, newValue.size() - diffStartIndex - diffEndIndex)};
            textBox.SelectedText(replacementValue);
          } else {
            textBox.Text(newValue);
          }

          // Update selection based on the following algorithm:
          // 1. If the new value is the same length as the old value, retain the selection state (start and length)
          // 2. Else set the selection start to the end of the string
          if (oldValue.size() == newValue.size()) {
            textBox.SelectionStart(oldCursor);
            textBox.SelectionLength(oldSelectionLength);
          } else {
            textBox.SelectionStart(newValue.size());
          }
        }
      } else if (text.IsNull())
        textBox.ClearValue(xaml::Controls::TextBox::TextProperty());
    } else {
      if (text.Type() == winrt::Microsoft::ReactNative::JSValueType::String) {
        auto oldValue = passwordBox.Password();
        auto newValue = asHstring(text);
        if (oldValue != newValue) {
          passwordBox.Password(newValue);
        }
      } else if (text.IsNull())
        passwordBox.ClearValue(xaml::Controls::PasswordBox::PasswordProperty());
    }
  }
}

void TextInputShadowNode::SetSelection(int64_t start, int64_t end) {
  if (start < 0 || end < 0 || start > end) {
    return;
  }

  if (auto textBox = this->GetView().try_as<xaml::Controls::TextBox>()) {
    textBox.Select(static_cast<int32_t>(start), static_cast<int32_t>(end - start));
  }
}

void TextInputShadowNode::dispatchCommand(
    const std::string &commandId,
    winrt::Microsoft::ReactNative::JSValueArray &&commandArgs) {
  if (commandId == "focus") {
    if (auto uiManager = GetNativeUIManager(GetViewManager()->GetReactContext()).lock()) {
      uiManager->focus(m_tag);
    }
  } else if (commandId == "blur") {
    if (auto uiManager = GetNativeUIManager(GetViewManager()->GetReactContext()).lock()) {
      uiManager->blur(m_tag);
    }
  } else if (commandId == "setTextAndSelection") {
    m_mostRecentEventCount = commandArgs[0].AsInt32();
    SetText(commandArgs[1]);
    SetSelection(commandArgs[2].AsInt64(), commandArgs[3].AsInt64());
  } else {
    Super::dispatchCommand(commandId, std::move(commandArgs));
  }
}

TextInputViewManager::TextInputViewManager(const Mso::React::IReactContext &context) : Super(context) {}

const wchar_t *TextInputViewManager::GetName() const {
  return L"WindowsTextInput";
}

void TextInputViewManager::GetNativeProps(const winrt::Microsoft::ReactNative::IJSValueWriter &writer) const {
  Super::GetNativeProps(writer);

  React::WriteProperty(writer, L"allowFontScaling", L"boolean");
  React::WriteProperty(writer, L"clearTextOnFocus", L"boolean");
  React::WriteProperty(writer, L"editable", L"boolean");
  React::WriteProperty(writer, L"maxLength", L"int");
  React::WriteProperty(writer, L"multiline", L"boolean");
  React::WriteProperty(writer, L"placeholder", L"string");
  React::WriteProperty(writer, L"placeholderTextColor", L"Color");
  React::WriteProperty(writer, L"scrollEnabled", L"boolean");
  React::WriteProperty(writer, L"cursorColor", L"Color");
  React::WriteProperty(writer, L"selectionColor", L"Color");
  React::WriteProperty(writer, L"selectTextOnFocus", L"boolean");
  React::WriteProperty(writer, L"spellCheck", L"boolean");
  React::WriteProperty(writer, L"submitBehavior", L"string");
  React::WriteProperty(writer, L"text", L"string");
  React::WriteProperty(writer, L"mostRecentEventCount", L"int");
  React::WriteProperty(writer, L"secureTextEntry", L"boolean");
  React::WriteProperty(writer, L"keyboardType", L"string");
  React::WriteProperty(writer, L"contextMenuHidden", L"boolean");
  React::WriteProperty(writer, L"caretHidden", L"boolean");
  React::WriteProperty(writer, L"autoCapitalize", L"string");
  React::WriteProperty(writer, L"clearTextOnSubmit", L"boolean");
  React::WriteProperty(writer, L"submitKeyEvents", L"array");
  React::WriteProperty(writer, L"autoFocus", L"boolean");
}

void TextInputViewManager::GetExportedCustomDirectEventTypeConstants(
    const winrt::Microsoft::ReactNative::IJSValueWriter &writer) const {
  Super::GetExportedCustomDirectEventTypeConstants(writer);

  const PCWSTR eventNames[] = {// Generic events
                               L"Change",
                               L"Focus",
                               L"Blur",
                               L"EndEditing",
                               L"SelectionChange",
                               L"ContentSizeChange",
                               L"KeyPress",
                               L"PressIn",
                               L"PressOut",
                               L"Scroll",
                               L"SubmitEditing"};

  for (auto &eventBaseName : eventNames) {
    using namespace std::string_literals;
    writer.WritePropertyName(L"topTextInput"s + eventBaseName);
    writer.WriteObjectBegin();
    writer.WritePropertyName(L"registrationName");
    writer.WriteString(L"on"s + eventBaseName);
    writer.WriteObjectEnd();
  }
}

ShadowNode *TextInputViewManager::createShadow() const {
  return new TextInputShadowNode();
}

XamlView TextInputViewManager::CreateViewCore(
    int64_t /*tag*/,
    const winrt::Microsoft::ReactNative::JSValueObject &props) {
  const auto secureTextEntry = props.find("secureTextEntry");
  if (secureTextEntry != props.end() &&
      secureTextEntry->second.Type() == winrt::Microsoft::ReactNative::JSValueType::Boolean &&
      secureTextEntry->second.AsBoolean()) {
    xaml::Controls::PasswordBox passwordBox;
    return passwordBox;
  } else {
    xaml::Controls::TextBox textBox;
    return textBox;
  }
}

YGMeasureFunc TextInputViewManager::GetYogaCustomMeasureFunc() const {
  return DefaultYogaSelfMeasureFunc;
}

void TextInputViewManager::TransferInputScope(
    const XamlView &oldView,
    const XamlView &newView,
    const bool copyToPasswordBox) {
  // transfer input scope, only common keyboardType between secureTextEntry
  // on/off is numeric, so only need to transfer input scope "Number" <=>
  // "NumericPin", everything else leave it as default.
  xaml::Input::InputScope inputScope;
  if (copyToPasswordBox) {
    inputScope = oldView.try_as<xaml::Controls::TextBox>().InputScope();
  } else {
    inputScope = oldView.try_as<xaml::Controls::PasswordBox>().InputScope();
  }

  if (inputScope != nullptr) {
    auto nameValue = inputScope.Names().GetAt(0).NameValue();

    if ((nameValue == xaml::Input::InputScopeNameValue::Number && copyToPasswordBox) ||
        (nameValue == xaml::Input::InputScopeNameValue::NumericPin && !copyToPasswordBox)) {
      auto newScope = xaml::Input::InputScope();
      auto scopeName = xaml::Input::InputScopeName(
          copyToPasswordBox ? xaml::Input::InputScopeNameValue::NumericPin : xaml::Input::InputScopeNameValue::Number);
      auto names = newScope.Names();
      names.Append(scopeName);
      newView.SetValue(
          copyToPasswordBox ? xaml::Controls::PasswordBox::InputScopeProperty()
                            : xaml::Controls::TextBox::InputScopeProperty(),
          newScope);
    }
  }
}

void TextInputViewManager::TransferProperties(const XamlView &oldView, const XamlView &newView) {
  if ((oldView.try_as<xaml::Controls::TextBox>() != nullptr &&
       newView.try_as<xaml::Controls::PasswordBox>() != nullptr) ||
      (oldView.try_as<xaml::Controls::PasswordBox>() != nullptr &&
       newView.try_as<xaml::Controls::TextBox>() != nullptr)) {
    bool copyToPasswordBox = oldView.try_as<xaml::Controls::TextBox>() != nullptr;

    // sync common properties between TextBox and PasswordBox
    if (copyToPasswordBox) {
      TransferProperty(
          oldView,
          newView,
          xaml::Controls::TextBox::MaxLengthProperty(),
          xaml::Controls::PasswordBox::MaxLengthProperty());
      TransferProperty(
          oldView,
          newView,
          xaml::Controls::TextBox::PlaceholderTextProperty(),
          xaml::Controls::PasswordBox::PlaceholderTextProperty());
      TransferProperty(
          oldView,
          newView,
          xaml::Controls::TextBox::SelectionHighlightColorProperty(),
          xaml::Controls::PasswordBox::SelectionHighlightColorProperty());
      newView.as<xaml::Controls::PasswordBox>().Password(oldView.as<xaml::Controls::TextBox>().Text());
      // Since both focusable/editable affect isEnabled for PasswordBox, if the oldView is enabled we still need to
      // check isReadOnly
      if (oldView.as<xaml::Controls::TextBox>().IsEnabled()) {
        newView.as<xaml::Controls::PasswordBox>().IsEnabled(!oldView.as<xaml::Controls::TextBox>().IsReadOnly());
      } else {
        newView.as<xaml::Controls::PasswordBox>().IsEnabled(oldView.as<xaml::Controls::TextBox>().IsEnabled());
      }
    } else {
      TransferProperty(
          oldView,
          newView,
          xaml::Controls::PasswordBox::MaxLengthProperty(),
          xaml::Controls::TextBox::MaxLengthProperty());
      TransferProperty(
          oldView,
          newView,
          xaml::Controls::PasswordBox::PlaceholderTextProperty(),
          xaml::Controls::TextBox::PlaceholderTextProperty());
      TransferProperty(
          oldView,
          newView,
          xaml::Controls::PasswordBox::SelectionHighlightColorProperty(),
          xaml::Controls::TextBox::SelectionHighlightColorProperty());
      newView.as<xaml::Controls::TextBox>().Text(oldView.as<xaml::Controls::PasswordBox>().Password());
      // Since both focusable/editable affect isEnabled for PasswordBox, if the oldView is enabled we still need to
      // check isReadOnly
      if (oldView.as<xaml::Controls::PasswordBox>().IsEnabled()) {
        newView.as<xaml::Controls::TextBox>().IsReadOnly(!oldView.as<xaml::Controls::PasswordBox>().IsEnabled());
      } else {
        newView.as<xaml::Controls::TextBox>().IsEnabled(oldView.as<xaml::Controls::PasswordBox>().IsEnabled());
      }
    }

    TransferInputScope(oldView, newView, copyToPasswordBox);
    // Set focus if current control has focus
    auto focusState = oldView.as<xaml::Controls::Control>().FocusState();
    if (focusState != winrt::FocusState::Unfocused) {
      newView.as<xaml::Controls::Control>().Focus(focusState);
    }
  }
  Super::TransferProperties(oldView, newView);
}
} // namespace Microsoft::ReactNative