// Copyright 2017-present the Material Components for iOS 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.

#import "MDCMultilineTextField.h"

#import "private/MDCTextInputCommonFundament.h"
#import "MDCIntrinsicHeightTextView.h"
#import "MDCMultilineTextInputLayoutDelegate.h"
#import "MDCTextField.h"
#import "MDCTextFieldPositioningDelegate.h"
#import "MDCTextInputBorderView.h"
#import "MDCTextInputUnderlineView.h"

#import "MaterialMath.h"
#import "MaterialTypography.h"

/** The key for localization of the @c clearButton accessibilityLabel. */
static NSString *const kClearButtonKey = @"MaterialTextFieldClearButtonAccessibilityLabel";
/** Table name within the bundle used for localizing accessibility values. */
static NSString *const kAccessibilityLocalizationStringsTableName = @"MaterialTextField";
// The Bundle for string resources.
static NSString *const kBundle = @"MaterialTextFields.bundle";
// The font opacity to be used for the caption.
static const CGFloat kButtonFontOpacity = 0.54f;

@interface MDCMultilineTextField () {
  UIColor *_cursorColor;

  MDCIntrinsicHeightTextView *_textView;
}

@property(nonatomic, assign, getter=isEditing) BOOL editing;

@property(nonatomic, assign) CGFloat textViewWidth;

@property(nonatomic, strong) MDCTextInputCommonFundament *fundament;

@property(nonatomic, strong) NSLayoutConstraint *textViewBottomSuperviewBottom;
@property(nonatomic, strong) NSLayoutConstraint *textViewLeading;
@property(nonatomic, strong) NSLayoutConstraint *textViewMinHeight;
@property(nonatomic, strong) NSLayoutConstraint *textViewTop;
@property(nonatomic, strong) NSLayoutConstraint *textViewTrailing;

// textViewTrailingTrailingViewLeading is a constraint from .textView's trailing edge to
// .trailingView's leading edge.
@property(nonatomic, strong) NSLayoutConstraint *textViewTrailingTrailingViewLeading;
@property(nonatomic, strong) NSLayoutConstraint *trailingViewCenterY;
@property(nonatomic, strong) NSLayoutConstraint *trailingViewTrailing;

@end

@implementation MDCMultilineTextField

@synthesize expandsOnOverflow = _expandsOnOverflow;
@synthesize minimumLines = _minimumLines;
@synthesize trailingView = _trailingView;
@synthesize trailingViewMode = _trailingViewMode;
@synthesize mdc_elevationDidChangeBlock = _mdc_elevationDidChangeBlock;
@synthesize mdc_overrideBaseElevation = _mdc_overrideBaseElevation;

- (instancetype)initWithFrame:(CGRect)frame {
  self = [super initWithFrame:frame];
  if (self) {
    _textView = [[MDCIntrinsicHeightTextView alloc] initWithFrame:CGRectZero];
    [self setupTextView];

    _fundament = [[MDCTextInputCommonFundament alloc] initWithTextInput:self];

    [self commonMDCMultilineTextFieldInitialization];
  }

  return self;
}

- (instancetype)initWithCoder:(NSCoder *)aDecoder {
  self = [super initWithCoder:aDecoder];
  if (self) {
    if (!_textView) {
      _textView = [[MDCIntrinsicHeightTextView alloc] initWithFrame:CGRectZero];
    }
    // It should be noted that setupTextView sets many properties of the textView that may have
    // been encoded differently.
    [self setupTextView];

    _fundament = [[MDCTextInputCommonFundament alloc] initWithTextInput:self];

    [self commonMDCMultilineTextFieldInitialization];
  }

  return self;
}

- (instancetype)copyWithZone:(__unused NSZone *)zone {
  MDCMultilineTextField *copy = [[[self class] alloc] initWithFrame:self.frame];

  copy.expandsOnOverflow = self.expandsOnOverflow;
  copy.cursorColor = self.cursorColor;

  // The .fundament creates a .clearButton so setting the clearButton's .tintColor must wait for the
  // final .fundament to be created.
  copy.fundament = [self.fundament copy];
  copy.clearButton.tintColor = self.clearButton.tintColor;

  copy.layoutDelegate = self.layoutDelegate;
  copy.minimumLines = self.minimumLines;
  copy.multilineDelegate = self.multilineDelegate;
  copy.placeholder = self.placeholder;
  copy.text = self.text;
  if ([self.trailingView conformsToProtocol:@protocol(NSCopying)]) {
    copy.trailingView = [self.trailingView copy];
  }
  copy.trailingViewMode = self.trailingViewMode;
  return copy;
}

- (void)commonMDCMultilineTextFieldInitialization {
  self.backgroundColor = [UIColor clearColor];

  self.textColor = _fundament.textColor;
  // TODO: (#4331) This needs to be converted to the new text scheme.
  self.font = [UIFont mdc_standardFontForMaterialTextStyle:MDCFontTextStyleBody1];
  self.clearButton.tintColor = [UIColor colorWithWhite:0 alpha:kButtonFontOpacity];
  NSBundle *bundle = [[self class] bundle];
  NSString *accessibilityLabel =
      [bundle localizedStringForKey:kClearButtonKey
                              value:@"Clear text"
                              table:kAccessibilityLocalizationStringsTableName];
  self.clearButton.accessibilityLabel = accessibilityLabel;

  _cursorColor = MDCTextInputCursorColor();
  [self applyCursorColor];

  self.editable = YES;

  self.expandsOnOverflow = YES;
  _minimumLines = 1;

  [self setupUnderlineConstraints];

  [self setContentCompressionResistancePriority:UILayoutPriorityDefaultHigh + 1
                                        forAxis:UILayoutConstraintAxisVertical];
  _mdc_overrideBaseElevation = -1;
}

- (void)subscribeForNotifications {
  NSNotificationCenter *defaultCenter = [NSNotificationCenter defaultCenter];
  [defaultCenter addObserver:self
                    selector:@selector(textViewDidBeginEditing:)
                        name:UITextViewTextDidBeginEditingNotification
                      object:self.textView];
  [defaultCenter addObserver:self
                    selector:@selector(textViewDidEndEditing:)
                        name:UITextViewTextDidEndEditingNotification
                      object:self.textView];
  [defaultCenter addObserver:self
                    selector:@selector(textViewDidChange:)
                        name:UITextViewTextDidChangeNotification
                      object:self.textView];
}

#pragma mark - UIResponder Overrides

- (BOOL)becomeFirstResponder {
  return [self.textView becomeFirstResponder];
}

- (BOOL)isFirstResponder {
  return self.textView.isFirstResponder;
}

- (BOOL)resignFirstResponder {
  return [self.textView resignFirstResponder];
}

#pragma mark - TextView Implementation

- (void)setupTextView {
  [self insertSubview:self.textView atIndex:0];
  self.textView.translatesAutoresizingMaskIntoConstraints = NO;
  self.textView.scrollEnabled = !_expandsOnOverflow;

  [self.textView setContentHuggingPriority:UILayoutPriorityDefaultLow - 1
                                   forAxis:UILayoutConstraintAxisHorizontal];
  [self.textView setContentHuggingPriority:UILayoutPriorityDefaultLow - 1
                                   forAxis:UILayoutConstraintAxisVertical];
  [self.textView setContentCompressionResistancePriority:UILayoutPriorityDefaultLow - 1
                                                 forAxis:UILayoutConstraintAxisHorizontal];
  [self.textView setContentCompressionResistancePriority:UILayoutPriorityDefaultHigh + 1
                                                 forAxis:UILayoutConstraintAxisVertical];

  self.textView.textContainer.lineBreakMode = NSLineBreakByTruncatingTail;
  self.textView.textContainer.lineFragmentPadding = 0;

  self.textView.textContainerInset = UIEdgeInsetsZero;
  [self subscribeForNotifications];

  self.textView.backgroundColor = [UIColor clearColor];
  self.textView.opaque = NO;
}

#pragma mark - Underline View Implementation

- (void)setupUnderlineConstraints {
  if (!self.underline) {
    return;
  }
  NSLayoutConstraint *underlineLeading =
      [NSLayoutConstraint constraintWithItem:self.underline
                                   attribute:NSLayoutAttributeLeading
                                   relatedBy:NSLayoutRelationEqual
                                      toItem:self
                                   attribute:NSLayoutAttributeLeading
                                  multiplier:1
                                    constant:0];
  underlineLeading.priority = UILayoutPriorityDefaultLow;
  underlineLeading.active = YES;

  NSLayoutConstraint *underlineTrailing =
      [NSLayoutConstraint constraintWithItem:self.underline
                                   attribute:NSLayoutAttributeTrailing
                                   relatedBy:NSLayoutRelationEqual
                                      toItem:self
                                   attribute:NSLayoutAttributeTrailing
                                  multiplier:1
                                    constant:0];
  underlineTrailing.priority = UILayoutPriorityDefaultLow;
  underlineTrailing.active = YES;

  NSLayoutConstraint *underlineYTextView =
      [NSLayoutConstraint constraintWithItem:self.underline
                                   attribute:NSLayoutAttributeBottom
                                   relatedBy:NSLayoutRelationEqual
                                      toItem:self.textView
                                   attribute:NSLayoutAttributeBottom
                                  multiplier:1
                                    constant:MDCTextInputHalfPadding];
  underlineYTextView.priority = UILayoutPriorityDefaultLow;
  underlineYTextView.active = YES;
}

#pragma mark - Layout (UIView)

- (CGSize)intrinsicContentSize {
  if (self.useConstraintsForIntrinsicContentSize) {
    return [super intrinsicContentSize];
  }
  CGSize boundingSize = CGSizeZero;
  boundingSize.width = UIViewNoIntrinsicMetric;

  [self.textView layoutIfNeeded];
  CGFloat estimatedTextViewHeight =
      [self.textView systemLayoutSizeFittingSize:CGSizeMake(CGRectGetWidth(self.textView.bounds), 0)
                   withHorizontalFittingPriority:UILayoutPriorityDefaultLow
                         verticalFittingPriority:UILayoutPriorityDefaultLow]
          .height;

  CGFloat minimumHeight = [self estimatedTextViewLineHeight] * self.minimumLines;
  estimatedTextViewHeight = MAX(estimatedTextViewHeight, minimumHeight);

  boundingSize.height = [self textInsets].top + estimatedTextViewHeight + [self textInsets].bottom;

  return boundingSize;
}

- (CGSize)sizeThatFits:(CGSize)size {
  self.sizeThatFitsWidthHint = size.width;
  CGSize sizeThatFits = [self intrinsicContentSize];
  sizeThatFits.width = self.sizeThatFitsWidthHint;
  self.sizeThatFitsWidthHint = 0;
  return sizeThatFits;
}

- (void)setSizeThatFitsWidthHint:(CGFloat)sizeThatFitsWidthHint {
  self.fundament.sizeThatFitsWidthHint = sizeThatFitsWidthHint;
}

- (CGFloat)sizeThatFitsWidthHint {
  return self.fundament.sizeThatFitsWidthHint;
}

- (void)layoutSubviews {
  [super layoutSubviews];

  if (![self.textView isDescendantOfView:self]) {
    [self setupTextView];
  }
  if (self.subviews.firstObject != self.textView) {
    [self sendSubviewToBack:self.textView];
  }

  [self updateTrailingViewAlpha];

  [self.fundament layoutSubviewsOfInput];
  [self updateBorder];
  [self applyCursorColor];

  if ([self.positioningDelegate respondsToSelector:@selector(textInputDidLayoutSubviews)]) {
    [self.positioningDelegate textInputDidLayoutSubviews];
  }

  [self updateIntrinsicSizeFromTextView];
}

- (void)traitCollectionDidChange:(UITraitCollection *)previousTraitCollection {
  [super traitCollectionDidChange:previousTraitCollection];

  if (self.traitCollectionDidChangeBlock) {
    self.traitCollectionDidChangeBlock(self, previousTraitCollection);
  }
}

- (CGFloat)mdc_currentElevation {
  return 0;
}

- (void)updateConstraints {
  if (!self.textViewLeading) {
    self.textViewLeading = [NSLayoutConstraint constraintWithItem:self.textView
                                                        attribute:NSLayoutAttributeLeading
                                                        relatedBy:NSLayoutRelationEqual
                                                           toItem:self
                                                        attribute:NSLayoutAttributeLeading
                                                       multiplier:1
                                                         constant:self.textInsets.left];
    self.textViewLeading.priority = UILayoutPriorityDefaultLow;
    self.textViewLeading.active = YES;
  }
  self.textViewLeading.constant = self.textInsets.left;

  if (!self.textViewBottomSuperviewBottom) {
    self.textViewBottomSuperviewBottom =
        [NSLayoutConstraint constraintWithItem:self.textView
                                     attribute:NSLayoutAttributeBottom
                                     relatedBy:NSLayoutRelationLessThanOrEqual
                                        toItem:self
                                     attribute:NSLayoutAttributeBottom
                                    multiplier:1
                                      constant:-1 * self.textInsets.bottom];
    self.textViewBottomSuperviewBottom.priority = UILayoutPriorityDefaultLow;
    self.textViewBottomSuperviewBottom.active = YES;
  }
  self.textViewBottomSuperviewBottom.constant = -1 * self.textInsets.bottom;

  if (!self.textViewTop) {
    self.textViewTop = [NSLayoutConstraint constraintWithItem:self.textView
                                                    attribute:NSLayoutAttributeTop
                                                    relatedBy:NSLayoutRelationEqual
                                                       toItem:self
                                                    attribute:NSLayoutAttributeTop
                                                   multiplier:1
                                                     constant:self.textInsets.top];
    self.textViewTop.priority = UILayoutPriorityDefaultLow + 1;
    self.textViewTop.active = YES;
  }
  self.textViewTop.constant = self.textInsets.top;

  if (!self.textViewTrailing) {
    self.textViewTrailing = [NSLayoutConstraint constraintWithItem:self.textView
                                                         attribute:NSLayoutAttributeTrailing
                                                         relatedBy:NSLayoutRelationEqual
                                                            toItem:self.clearButton
                                                         attribute:NSLayoutAttributeLeading
                                                        multiplier:1
                                                          constant:-1 * [self textInsets].right];
    self.textViewTrailing.priority = UILayoutPriorityDefaultLow;
    self.textViewTrailing.active = YES;
  }
  self.textViewTrailing.constant = -1 * [self textInsets].right;

  if (!self.textViewMinHeight) {
    self.textViewMinHeight = [NSLayoutConstraint
        constraintWithItem:self.textView
                 attribute:NSLayoutAttributeHeight
                 relatedBy:NSLayoutRelationGreaterThanOrEqual
                    toItem:nil
                 attribute:NSLayoutAttributeNotAnAttribute
                multiplier:1
                  constant:[self estimatedTextViewLineHeight] * self.minimumLines];
    self.textViewMinHeight.priority = UILayoutPriorityDefaultLow + 1;
  }
  self.textViewMinHeight.active = YES;
  self.textViewMinHeight.constant = [self estimatedTextViewLineHeight] * self.minimumLines;
  [self.fundament updateConstraintsOfInput];

  [self updateTrailingViewLayout];
  [self updateIntrinsicSizeFromTextView];

  // This must always be the last message in this method.
  [super updateConstraints];
}

+ (BOOL)requiresConstraintBasedLayout {
  return YES;
}

- (CGFloat)estimatedTextViewLineHeight {
  CGFloat scale = UIScreen.mainScreen.scale;
  return ceil(self.textView.font.lineHeight * scale) / scale;
}

- (void)updateIntrinsicSizeFromTextView {
  if ([self textViewWidthDidChange]) {
    [self invalidateIntrinsicContentSize];
  }
}

- (BOOL)textViewWidthDidChange {
  BOOL widthDidChange = NO;
  CGFloat currentTextViewWidth = CGRectGetWidth(self.textView.bounds);

  if (self.textViewWidth != currentTextViewWidth) {
    widthDidChange = YES;
  }
  self.textViewWidth = currentTextViewWidth;

  return widthDidChange;
}

#pragma mark - Touch (UIView)

- (UIView *)hitTest:(CGPoint)point withEvent:(UIEvent *)event {
  UIView *receiver = [super hitTest:point withEvent:event];

  // We do this so the hit zone to become first responder is larger than just the small text view.
  if (receiver == self && self.isEditing == NO) {
    return self.textView;
  }

  return receiver;
}

#pragma mark - Trailing View Implementation

- (void)updateTrailingViewLayout {
  if (!self.trailingView) {
    return;
  }

  self.trailingView.translatesAutoresizingMaskIntoConstraints = NO;

  if (![self.trailingView isDescendantOfView:self]) {
    [self addSubview:self.trailingView];
  }

  if (!self.trailingViewTrailing) {
    self.trailingViewTrailing = [NSLayoutConstraint constraintWithItem:self.trailingView
                                                             attribute:NSLayoutAttributeTrailing
                                                             relatedBy:NSLayoutRelationEqual
                                                                toItem:self.clearButton
                                                             attribute:NSLayoutAttributeTrailing
                                                            multiplier:1
                                                              constant:0];
  }
  self.trailingViewTrailing.active = YES;

  if (!self.trailingViewCenterY) {
    self.trailingViewCenterY = [NSLayoutConstraint constraintWithItem:self.trailingView
                                                            attribute:NSLayoutAttributeCenterY
                                                            relatedBy:NSLayoutRelationEqual
                                                               toItem:self.clearButton
                                                            attribute:NSLayoutAttributeCenterY
                                                           multiplier:1
                                                             constant:0];
  }
  self.trailingViewCenterY.active = YES;

  if (!self.textViewTrailingTrailingViewLeading) {
    self.textViewTrailingTrailingViewLeading =
        [NSLayoutConstraint constraintWithItem:self.textView
                                     attribute:NSLayoutAttributeTrailing
                                     relatedBy:NSLayoutRelationEqual
                                        toItem:self.trailingView
                                     attribute:NSLayoutAttributeLeading
                                    multiplier:1
                                      constant:self.textViewTrailing.constant];
  }
  self.textViewTrailingTrailingViewLeading.active = !MDCCGFloatEqual([self trailingViewAlpha], 0);
}

- (void)updateTrailingViewAlpha {
  self.trailingView.alpha = [self trailingViewAlpha];
}

- (CGFloat)trailingViewAlpha {
  // The trailing view has the same behavior as .rightView in UITextField: It has visual precedence
  // over the clear button.
  CGFloat trailingViewAlpha;
  switch (self.trailingViewMode) {
    case UITextFieldViewModeAlways:
      trailingViewAlpha = 1;
      break;
    case UITextFieldViewModeWhileEditing:
      trailingViewAlpha = self.isEditing ? 1 : 0;
      break;
    case UITextFieldViewModeUnlessEditing:
      trailingViewAlpha = self.isEditing ? 0 : 1;
      break;
    case UITextFieldViewModeNever:
      trailingViewAlpha = 0;
      break;
    default:
      NSAssert(NO, @"Invalid enumeration value %li.", (long)self.trailingViewMode);
      trailingViewAlpha = self.trailingViewAlpha;
      break;
  }
  return trailingViewAlpha;
}

#pragma mark - Border Implementation

- (UIBezierPath *)defaultBorderPath {
  CGRect borderBound = self.bounds;
  borderBound.size.height = self.underline.center.y;
  return [UIBezierPath
      bezierPathWithRoundedRect:borderBound
              byRoundingCorners:UIRectCornerTopLeft | UIRectCornerTopRight
                    cornerRadii:CGSizeMake(MDCTextInputBorderRadius, MDCTextInputBorderRadius)];
}

- (void)updateBorder {
  self.borderView.borderPath = self.borderPath;
}

#pragma mark - Applying Color

- (void)applyCursorColor {
  self.textView.tintColor = self.cursorColor;
}

#pragma mark - Properties Implementation

- (NSAttributedString *)attributedPlaceholder {
  return self.fundament.attributedPlaceholder;
}

- (void)setAttributedPlaceholder:(NSAttributedString *)attributedPlaceholder {
  self.fundament.attributedPlaceholder = attributedPlaceholder;
}

- (NSAttributedString *)attributedText {
  return self.textView.attributedText;
}

- (void)setAttributedText:(NSAttributedString *)attributedText {
  self.textView.attributedText = attributedText;
  [self.fundament didSetText];
  [[NSNotificationCenter defaultCenter] postNotificationName:MDCTextFieldTextDidSetTextNotification
                                                      object:self];
}

- (UIBezierPath *)borderPath {
  return self.fundament.borderPath ? self.fundament.borderPath : [self defaultBorderPath];
}

- (void)setBorderPath:(UIBezierPath *)borderPath {
  if (![self.fundament.borderPath isEqual:borderPath]) {
    self.fundament.borderPath = borderPath;
    [self updateBorder];
  }
}

- (MDCTextInputBorderView *)borderView {
  return self.fundament.borderView;
}

- (void)setBorderView:(MDCTextInputBorderView *)borderView {
  self.fundament.borderView = borderView;
}

- (UIButton *)clearButton {
  return self.fundament.clearButton;
}

- (UITextFieldViewMode)clearButtonMode {
  return self.fundament.clearButtonMode;
}

- (void)setClearButtonMode:(UITextFieldViewMode)clearButtonMode {
  self.fundament.clearButtonMode = clearButtonMode;
}

- (UIColor *)cursorColor {
  return _cursorColor ?: MDCTextInputCursorColor();
}

- (void)setCursorColor:(UIColor *)cursorColor {
  _cursorColor = cursorColor;
  [self applyCursorColor];
}

- (void)setEditable:(BOOL)editable {
  [self.textView setEditable:editable];
  self.fundament.enabled = editable;
}

- (BOOL)isEnabled {
  return self.fundament.isEnabled && self.textView.isEditable;
}

- (void)setEnabled:(BOOL)enabled {
  self.fundament.enabled = enabled;
  self.textView.editable = enabled;
  [[NSNotificationCenter defaultCenter]
      postNotificationName:MDCTextInputDidToggleEnabledNotification
                    object:self];
}

- (void)setExpandsOnOverflow:(BOOL)expandsOnOverflow {
  if (_expandsOnOverflow != expandsOnOverflow) {
    _expandsOnOverflow = expandsOnOverflow;
    self.textView.scrollEnabled = !expandsOnOverflow;
    [self setNeedsUpdateConstraints];
  }
}

- (UIFont *)font {
  if (_textView) {
    return _textView.font;
  }
  return self.textView.font;
}

- (void)setFont:(UIFont *)font {
  if (self.textView.font != font) {
    UIFont *previousFont = self.textView.font;
    [self.textView setFont:font];
    [_fundament didSetFont:previousFont];
  }
}

- (BOOL)hidesPlaceholderOnInput {
  return self.fundament.hidesPlaceholderOnInput;
}

- (void)setHidesPlaceholderOnInput:(BOOL)hidesPlaceholderOnInput {
  self.fundament.hidesPlaceholderOnInput = hidesPlaceholderOnInput;
}

- (UILabel *)leadingUnderlineLabel {
  return self.fundament.leadingUnderlineLabel;
}

- (NSUInteger)minimumLines {
  if (_minimumLines < 1) {
    _minimumLines = 1;
  }
  return _minimumLines;
}

- (void)setMinimumLines:(NSUInteger)minimumLines {
  if (_minimumLines != minimumLines) {
    _minimumLines = minimumLines > 0 ? minimumLines : 1;
    [self setNeedsUpdateConstraints];
  }
}

- (NSString *)placeholder {
  return self.fundament.placeholder;
}

- (void)setPlaceholder:(NSString *)placeholder {
  [self.fundament setPlaceholder:placeholder];
}

- (UILabel *)placeholderLabel {
  return self.fundament.placeholderLabel;
}

- (id<MDCTextInputPositioningDelegate>)positioningDelegate {
  return self.fundament.positioningDelegate;
}

- (void)setPositioningDelegate:(id<MDCTextInputPositioningDelegate>)positioningDelegate {
  self.fundament.positioningDelegate = positioningDelegate;
}

- (NSString *)text {
  return self.textView.text;
}

- (void)setText:(NSString *)text {
  [self.textView setText:text];
  [self.fundament didSetText];
  [[NSNotificationCenter defaultCenter] postNotificationName:MDCTextFieldTextDidSetTextNotification
                                                      object:self];
}

- (UIColor *)textColor {
  return self.fundament.textColor;
}

- (void)setTextColor:(UIColor *)textColor {
  [self.textView setTextColor:textColor];
  self.fundament.textColor = textColor;
}

- (UIEdgeInsets)textInsets {
  return self.fundament.textInsets;
}

- (MDCTextInputTextInsetsMode)textInsetsMode {
  return self.fundament.textInsetsMode;
}

- (void)setTextInsetsMode:(MDCTextInputTextInsetsMode)textInsetsMode {
  self.fundament.textInsetsMode = textInsetsMode;
}

- (MDCIntrinsicHeightTextView *)textView {
  if (!_textView) {
    _textView = [[MDCIntrinsicHeightTextView alloc] initWithFrame:CGRectZero];
    [self setupTextView];
    [self setupUnderlineConstraints];
  }
  return _textView;
}

- (void)setTextView:(MDCIntrinsicHeightTextView *)textView {
  if (![_textView isEqual:textView]) {
    [_textView removeFromSuperview];
    _textView = textView;
    if (textView) {
      [self setupTextView];
      [self setupUnderlineConstraints];
    }
  }
}

- (UILabel *)trailingUnderlineLabel {
  return self.fundament.trailingUnderlineLabel;
}

- (void)setTrailingView:(UIView *)trailingView {
  if (_trailingView != trailingView) {
    [_trailingView removeFromSuperview];
    [self addSubview:trailingView];
    _trailingView = trailingView;

    // Remove constraints related to the previous trailingView.
    self.trailingViewTrailing = nil;
    self.trailingViewCenterY = nil;
    self.textViewTrailingTrailingViewLeading = nil;

    [self setNeedsUpdateConstraints];
  }
}

- (MDCTextInputUnderlineView *)underline {
  return self.fundament.underline;
}

- (BOOL)hasTextContent {
  return self.text.length > 0;
}

- (void)clearText {
  self.text = nil;
}

#pragma mark - UITextView Notification Observation

- (void)textViewDidBeginEditing:(__unused NSNotification *)note {
  self.editing = YES;
  [self.fundament didBeginEditing];
}

- (void)textViewDidChange:(__unused NSNotification *)note {
  [self.fundament didChange];
  CGSize currentSize = self.bounds.size;
  CGSize requiredSize = [self sizeThatFits:CGSizeMake(currentSize.width, CGFLOAT_MAX)];
  if (currentSize.height != requiredSize.height && self.layoutDelegate &&
      [self.layoutDelegate respondsToSelector:@selector(multilineTextField:
                                                      didChangeContentSize:)]) {
    id<MDCMultilineTextInputLayoutDelegate> delegate =
        (id<MDCMultilineTextInputLayoutDelegate>)self.layoutDelegate;
    [delegate multilineTextField:self didChangeContentSize:requiredSize];
  }
}

- (void)textViewDidEndEditing:(__unused NSNotification *)note {
  self.editing = NO;
  [self.fundament didEndEditing];
}

#pragma mark - Accessibility

- (NSInteger)accessibilityElementCount {
  if (self.isAccessibilityElement) {
    return [super accessibilityElementCount];
  } else {
    return [self accessibilityElements].count;
  }
}

- (NSString *)accessibilityValue {
  NSString *value = [self.text length] ? self.text : self.placeholder;

  if (self.leadingUnderlineLabel.text.length > 0) {
    [value stringByAppendingFormat:@"%@ %@", [super accessibilityValue],
                                   self.leadingUnderlineLabel.accessibilityLabel];
  }

  return value;
}

- (NSString *)accessibilityLabel {
  if (self.isAccessibilityElement) {
    NSMutableArray *accessibilityStrings = [[NSMutableArray alloc] init];
    if ([super accessibilityLabel].length > 0) {
      [accessibilityStrings addObject:[super accessibilityLabel]];
    } else if (self.placeholderLabel.accessibilityLabel.length > 0) {
      [accessibilityStrings addObject:self.placeholderLabel.accessibilityLabel];
    }
    if (self.leadingUnderlineLabel.accessibilityLabel.length > 0) {
      [accessibilityStrings addObject:self.leadingUnderlineLabel.accessibilityLabel];
    }
    if (self.trailingUnderlineLabel.accessibilityLabel.length > 0) {
      [accessibilityStrings addObject:self.trailingUnderlineLabel.accessibilityLabel];
    }
    return accessibilityStrings.count > 0 ? [accessibilityStrings componentsJoinedByString:@", "]
                                          : nil;
  } else {
    return [super accessibilityLabel];
  }
}

- (NSArray *)accessibilityElements {
  if (self.isAccessibilityElement) {
    return [super accessibilityElements];
  } else {
    NSMutableArray *mutableElements = [super accessibilityElements] == nil
                                          ? [[NSMutableArray alloc] init]
                                          : [[super accessibilityElements] mutableCopy];

    if (self.placeholderLabel.isAccessibilityElement) {
      [mutableElements insertObject:self.placeholderLabel atIndex:0];
    }

    if (self.textView.isAccessibilityElement) {
      [mutableElements addObject:self.textView];
    }

    if (self.leadingUnderlineLabel.isAccessibilityElement) {
      [mutableElements addObject:self.leadingUnderlineLabel];
    }

    if (self.clearButton.isAccessibilityElement && self.isEditing) {
      [mutableElements addObject:self.clearButton];
    }

    if (self.trailingUnderlineLabel.isAccessibilityElement) {
      [mutableElements addObject:self.trailingUnderlineLabel];
    }

    return [mutableElements copy];
  }
}

- (BOOL)mdc_adjustsFontForContentSizeCategory {
  return _fundament.mdc_adjustsFontForContentSizeCategory;
}

- (void)mdc_setAdjustsFontForContentSizeCategory:(BOOL)adjusts {
  // Prior to iOS 9 RTL was not automatically applied, so we don't need to apply any fixes.
  if ([self.textView respondsToSelector:@selector(setAdjustsFontForContentSizeCategory:)]) {
    [self.textView setAdjustsFontForContentSizeCategory:adjusts];
  }

  [_fundament mdc_setAdjustsFontForContentSizeCategory:adjusts];
}

#pragma mark - Resource Bundle

+ (NSBundle *)bundle {
  static NSBundle *bundle = nil;
  static dispatch_once_t onceToken;
  dispatch_once(&onceToken, ^{
    bundle = [NSBundle bundleWithPath:[self bundlePathWithName:kBundle]];
  });

  return bundle;
}

+ (NSString *)bundlePathWithName:(NSString *)bundleName {
  NSBundle *bundle = [NSBundle bundleForClass:[MDCMultilineTextField class]];
  NSString *resourcePath = [(nil == bundle ? [NSBundle mainBundle] : bundle) resourcePath];
  return [resourcePath stringByAppendingPathComponent:bundleName];
}

@end