// Copyright 2020-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 "MDCBaseTextArea.h"

#import <CoreGraphics/CoreGraphics.h>
#import <QuartzCore/QuartzCore.h>

#import "MDCBaseTextAreaDelegate.h"
#import "MDCTextControlLabelBehavior.h"
#import "MDCTextControlState.h"
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wprivate-header"
#import "MDCBaseTextAreaLayout.h"
#import "MDCBaseTextAreaTextView.h"
#import "MDCTextControlStyleBase.h"
#import "MDCTextControl.h"
#import "MDCTextControlAssistiveLabelDrawPriority.h"
#import "MDCTextControlAssistiveLabelView.h"
#import "MDCTextControlColorViewModel.h"
#import "MDCTextControlGradientManager.h"
#import "MDCTextControlHorizontalPositioning.h"
#import "MDCTextControlHorizontalPositioningReference.h"
#import "MDCTextControlLabelAnimation.h"
#import "MDCTextControlLabelSupport.h"
#import "MDCTextControlPlaceholderSupport.h"
#pragma clang diagnostic pop

static char *const kKVOContextMDCBaseTextArea = "kKVOContextMDCBaseTextArea";

static const CGFloat kMDCBaseTextAreaDefaultMinimumNumberOfVisibleLines = (CGFloat)2.0;
static const CGFloat kMDCBaseTextAreaDefaultMaximumNumberOfVisibleLines = (CGFloat)4.0;

@interface MDCBaseTextArea () <MDCTextControl,
                               MDCBaseTextAreaTextViewDelegate,
                               UIGestureRecognizerDelegate>

#pragma mark MDCTextControl properties
@property(strong, nonatomic) UILabel *label;
@property(nonatomic, strong) UILabel *placeholderLabel;
@property(nonatomic, strong) MDCTextControlAssistiveLabelView *assistiveLabelView;
@property(strong, nonatomic) MDCBaseTextAreaLayout *layout;
@property(nonatomic, assign) MDCTextControlState textControlState;
@property(nonatomic, assign) MDCTextControlLabelPosition labelPosition;
@property(nonatomic, assign) CGRect normalLabelFrame;
@property(nonatomic, assign) CGRect floatingLabelFrame;
@property(nonatomic, assign) NSTimeInterval animationDuration;
/**
 * This property is set in every layout cycle, in preLayoutSubviews, right after the current
 * labelPosition is determined . It's set to YES if the labelPosition changed and NO if it didn't.
 * It's referred to in animateLabel (called from postLayoutSubviews) when deciding on a label
 * animation duration. If it's NO, the label gets an animation duration of 0, to avoid buggy looking
 * frame/text animations. Otherwise, it uses the value in the animationDuration property.
 */
@property(nonatomic, assign) BOOL labelPositionChanged;

@property(nonatomic, strong)
    NSMutableDictionary<NSNumber *, MDCTextControlColorViewModel *> *colorViewModels;

@property(strong, nonatomic) UIView *maskedTextViewContainerView;
@property(strong, nonatomic) MDCBaseTextAreaTextView *baseTextAreaTextView;

@property(nonatomic, strong) MDCTextControlGradientManager *gradientManager;

@property(strong, nonatomic) UITapGestureRecognizer *tapGesture;
@property(nonatomic, assign) CGSize cachedIntrinsicContentSize;
@property(nonatomic, assign) CGFloat cachedNumberOfLinesOfText;

@end

@implementation MDCBaseTextArea
@synthesize containerStyle = _containerStyle;
@synthesize assistiveLabelDrawPriority = _assistiveLabelDrawPriority;
@synthesize customAssistiveLabelDrawPriority = _customAssistiveLabelDrawPriority;
@synthesize adjustsFontForContentSizeCategory = _adjustsFontForContentSizeCategory;

#pragma mark Object Lifecycle

- (instancetype)initWithFrame:(CGRect)frame {
  self = [super initWithFrame:frame];
  if (self) {
    [self commonMDCBaseTextAreaInit];
  }
  return self;
}

- (instancetype)initWithCoder:(NSCoder *)aDecoder {
  self = [super initWithCoder:aDecoder];
  if (self) {
    [self commonMDCBaseTextAreaInit];
  }
  return self;
}

- (void)commonMDCBaseTextAreaInit {
  [self initializeProperties];
  [self setUpTapGesture];
  [self setUpColorViewModels];
  [self setUpLabel];
  [self setUpAssistiveLabels];
  [self setUpTextView];
  [self setUpPlaceholderLabel];
  [self observeTextViewNotifications];
  [self observeLabelKeyPaths];
}

- (void)dealloc {
  [self removeObservers];
}

#pragma mark Setup

- (void)initializeProperties {
  self.animationDuration = kMDCTextControlDefaultAnimationDuration;
  self.labelBehavior = MDCTextControlLabelBehaviorFloats;
  self.labelPosition = [self determineCurrentLabelPosition];
  self.textControlState = [self determineCurrentTextControlState];
  self.containerStyle = [[MDCTextControlStyleBase alloc] init];
  self.colorViewModels = [[NSMutableDictionary alloc] init];
  self.minimumNumberOfVisibleRows = kMDCBaseTextAreaDefaultMinimumNumberOfVisibleLines;
  self.maximumNumberOfVisibleRows = kMDCBaseTextAreaDefaultMaximumNumberOfVisibleLines;
  self.gradientManager = [[MDCTextControlGradientManager alloc] init];
  self.placeholderColor = [self defaultPlaceholderColor];
}

- (void)setUpTapGesture {
  self.tapGesture = [[UITapGestureRecognizer alloc] initWithTarget:self
                                                            action:@selector(handleTap:)];
  [self addGestureRecognizer:self.tapGesture];
}

- (void)setUpColorViewModels {
  self.colorViewModels = [[NSMutableDictionary alloc] init];
  self.colorViewModels[@(MDCTextControlStateNormal)] =
      [[MDCTextControlColorViewModel alloc] initWithState:MDCTextControlStateNormal];
  self.colorViewModels[@(MDCTextControlStateEditing)] =
      [[MDCTextControlColorViewModel alloc] initWithState:MDCTextControlStateEditing];
  self.colorViewModels[@(MDCTextControlStateDisabled)] =
      [[MDCTextControlColorViewModel alloc] initWithState:MDCTextControlStateDisabled];
}

- (void)setUpAssistiveLabels {
  self.assistiveLabelDrawPriority = MDCTextControlAssistiveLabelDrawPriorityTrailing;
  self.assistiveLabelView = [[MDCTextControlAssistiveLabelView alloc] init];
  [self addSubview:self.assistiveLabelView];
}

- (void)setUpLabel {
  self.label = [[UILabel alloc] init];
  [self addSubview:self.label];
}

- (void)setUpPlaceholderLabel {
  self.placeholderLabel = [[UILabel alloc] init];
  [self.textView addSubview:self.placeholderLabel];
}

- (void)setUpTextView {
  self.maskedTextViewContainerView = [[UIView alloc] init];
  [self addSubview:self.maskedTextViewContainerView];

  self.baseTextAreaTextView = [[MDCBaseTextAreaTextView alloc] init];
  self.baseTextAreaTextView.textAreaTextViewDelegate = self;
  [self.maskedTextViewContainerView addSubview:self.baseTextAreaTextView];
}

#pragma mark UIView Overrides

- (void)layoutSubviews {
  [self preLayoutSubviews];
  [super layoutSubviews];
  [self postLayoutSubviews];
}

- (CGSize)sizeThatFits:(CGSize)size {
  return [self preferredSizeWithWidth:size.width];
}

- (CGSize)intrinsicContentSize {
  self.cachedIntrinsicContentSize = [self preferredSizeWithWidth:CGRectGetWidth(self.bounds)];
  return self.cachedIntrinsicContentSize;
}

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

- (void)setSemanticContentAttribute:(UISemanticContentAttribute)semanticContentAttribute {
  [super setSemanticContentAttribute:semanticContentAttribute];

  self.textView.semanticContentAttribute = semanticContentAttribute;
  self.placeholderLabel.semanticContentAttribute = semanticContentAttribute;
  [self setNeedsLayout];
}

- (void)setEnabled:(BOOL)enabled {
  [super setEnabled:enabled];
  self.textView.editable = enabled;
  [self setNeedsLayout];
}

#pragma mark Private Layout

- (void)preLayoutSubviews {
  self.textControlState = [self determineCurrentTextControlState];
  MDCTextControlLabelPosition previousLabelPosition = self.labelPosition;
  self.labelPosition = [self determineCurrentLabelPosition];
  self.labelPositionChanged = previousLabelPosition != self.labelPosition;
  self.placeholderLabel.attributedText = [self determineAttributedPlaceholder];
  self.placeholderLabel.numberOfLines = (NSInteger)self.numberOfLinesOfVisibleText;
  MDCTextControlColorViewModel *colorViewModel =
      [self textControlColorViewModelForState:self.textControlState];
  [self applyColorViewModel:colorViewModel withLabelPosition:self.labelPosition];
  CGSize fittingSize = CGSizeMake(CGRectGetWidth(self.frame), CGFLOAT_MAX);
  self.layout = [self calculateLayoutWithSize:fittingSize];
  self.floatingLabelFrame = self.layout.labelFrameFloating;
  self.normalLabelFrame = self.layout.labelFrameNormal;
}

- (void)postLayoutSubviews {
  self.maskedTextViewContainerView.frame = self.containerFrame;
  self.textView.frame = self.layout.textViewFrame;
  self.placeholderLabel.hidden = self.layout.placeholderLabelHidden;
  self.placeholderLabel.frame = self.layout.placeholderLabelFrame;
  self.assistiveLabelView.frame = self.layout.assistiveLabelViewFrame;
  self.assistiveLabelView.layout = self.layout.assistiveLabelViewLayout;
  [self.assistiveLabelView setNeedsLayout];
  [self animateLabel];
  [self updateSideViews];
  [self.containerStyle applyStyleToTextControl:self animationDuration:self.animationDuration];
  [self layoutGradientLayers];
  [self scrollToSelectedText];
  if ([self widthHasChanged] || [self calculatedHeightHasChanged]) {
    [self handleIntrinsicContentSizeChange];
  }
}

- (void)updateSideViews {
  if (self.layout.displaysLeadingView) {
    if (self.leadingView) {
      if (self.leadingView.superview != self) {
        [self addSubview:self.leadingView];
      }
      self.leadingView.frame = self.layout.leadingViewFrame;
    }
  } else {
    [self.leadingView removeFromSuperview];
  }

  if (self.layout.displaysTrailingView) {
    if (self.trailingView) {
      if (self.trailingView.superview != self) {
        [self addSubview:self.trailingView];
      }
      self.trailingView.frame = self.layout.trailingViewFrame;
    }
  } else {
    [self.trailingView removeFromSuperview];
  }
}

- (void)scrollToSelectedText {
  //  Undesirable things happen to the text view's contentOffset when adding new lines in a growing
  //  MDCBaseTextArea in iOS versions 11 and 12. Specifically, hitting return will appear to result
  //  in two newlines, instead of one, but it's really just contentOffset being set. This line seems
  //  to prevent this issue without creating any others.
  [self.textView scrollRangeToVisible:self.textView.selectedRange];
}

- (MDCBaseTextAreaLayout *)calculateLayoutWithSize:(CGSize)size {
  CGFloat clampedCustomAssistiveLabelDrawPriority =
      [self clampedCustomAssistiveLabelDrawPriority:self.customAssistiveLabelDrawPriority];
  id<MDCTextControlVerticalPositioningReference> verticalPositioningReference =
      [self createVerticalPositioningReference];
  id<MDCTextControlHorizontalPositioning> horizontalPositioningReference =
      [self createHorizontalPositioningReference];
  return [[MDCBaseTextAreaLayout alloc] initWithSize:size
                        verticalPositioningReference:verticalPositioningReference
                      horizontalPositioningReference:horizontalPositioningReference
                                                text:self.baseTextAreaTextView.text
                                                font:self.normalFont
                                        floatingFont:self.floatingFont
                                               label:self.label
                                       labelPosition:self.labelPosition
                                       labelBehavior:self.labelBehavior
                                    placeholderLabel:self.placeholderLabel
                                         leadingView:self.leadingView
                                     leadingViewMode:self.leadingViewMode
                                        trailingView:self.trailingView
                                    trailingViewMode:self.trailingViewMode
                               leadingAssistiveLabel:self.assistiveLabelView.leadingAssistiveLabel
                              trailingAssistiveLabel:self.assistiveLabelView.trailingAssistiveLabel
                          assistiveLabelDrawPriority:self.assistiveLabelDrawPriority
                    customAssistiveLabelDrawPriority:clampedCustomAssistiveLabelDrawPriority
                                               isRTL:self.shouldLayoutForRTL
                                           isEditing:self.textView.isFirstResponder];
}

- (id<MDCTextControlVerticalPositioningReference>)createVerticalPositioningReference {
  return [self.containerStyle
      positioningReferenceWithFloatingFontLineHeight:self.floatingFont.lineHeight
                                normalFontLineHeight:self.normalFont.lineHeight
                                       textRowHeight:(self.normalFont.lineHeight +
                                                      self.normalFont.leading)
                                    numberOfTextRows:self.numberOfLinesOfVisibleText
                                             density:self.verticalDensity
                            preferredContainerHeight:self.preferredContainerHeight
                              isMultilineTextControl:YES];
}

- (id<MDCTextControlHorizontalPositioning>)createHorizontalPositioningReference {
  id<MDCTextControlHorizontalPositioning> horizontalPositioningReference =
      self.containerStyle.horizontalPositioningReference;
  if (self.leadingEdgePaddingOverride) {
    horizontalPositioningReference.leadingEdgePadding =
        (CGFloat)[self.leadingEdgePaddingOverride doubleValue];
  }
  if (self.trailingEdgePaddingOverride) {
    horizontalPositioningReference.trailingEdgePadding =
        (CGFloat)[self.trailingEdgePaddingOverride doubleValue];
  }
  if (self.horizontalInterItemSpacingOverride) {
    horizontalPositioningReference.horizontalInterItemSpacing =
        (CGFloat)[self.horizontalInterItemSpacingOverride doubleValue];
  }
  return horizontalPositioningReference;
}

- (CGFloat)clampedCustomAssistiveLabelDrawPriority:(CGFloat)customPriority {
  CGFloat value = customPriority;
  if (value < 0) {
    value = 0;
  } else if (value > 1) {
    value = 1;
  }
  return value;
}

- (CGSize)preferredSizeWithWidth:(CGFloat)width {
  CGSize fittingSize = CGSizeMake(width, CGFLOAT_MAX);
  MDCBaseTextAreaLayout *layout = [self calculateLayoutWithSize:fittingSize];
  return CGSizeMake(width, layout.calculatedHeight);
}

- (BOOL)widthHasChanged {
  return CGRectGetWidth(self.bounds) != self.cachedIntrinsicContentSize.width;
}

- (BOOL)calculatedHeightHasChanged {
  return self.layout.calculatedHeight != self.cachedIntrinsicContentSize.height;
}

- (void)handleIntrinsicContentSizeChange {
  [self invalidateIntrinsicContentSize];
  if ([self.baseTextAreaDelegate respondsToSelector:@selector(baseTextArea:shouldChangeSize:)]) {
    CGSize preferredSize = CGSizeMake(CGRectGetWidth(self.bounds), self.layout.calculatedHeight);
    [self.baseTextAreaDelegate baseTextArea:self shouldChangeSize:preferredSize];
  }
}

- (void)layoutGradientLayers {
  CGRect gradientLayerFrame = self.containerFrame;
  self.gradientManager.horizontalGradient.frame = gradientLayerFrame;
  self.gradientManager.verticalGradient.frame = gradientLayerFrame;
  self.gradientManager.horizontalGradient.locations = self.layout.horizontalGradientLocations;
  self.gradientManager.verticalGradient.locations = self.layout.verticalGradientLocations;
  self.maskedTextViewContainerView.layer.mask = [self.gradientManager combinedGradientMaskLayer];
}

- (CGFloat)numberOfLinesOfText {
  // For more context on measuring the lines in a UITextView see here:
  // https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/TextLayout/Tasks/CountLines.html
  NSLayoutManager *layoutManager = self.textView.layoutManager;
  NSUInteger numberOfGlyphs = layoutManager.numberOfGlyphs;
  NSRange lineRange = NSMakeRange(0, 1);
  NSUInteger index = 0;
  NSUInteger numberOfLines = 0;
  while (index < numberOfGlyphs) {
    [layoutManager lineFragmentRectForGlyphAtIndex:index effectiveRange:&lineRange];
    index = NSMaxRange(lineRange);
    numberOfLines += 1;
  }

  BOOL textEndsInNewLine =
      self.textView.text.length > 0 &&
      [self.textView.text characterAtIndex:self.textView.text.length - 1] == '\n';
  if (textEndsInNewLine) {
    numberOfLines += 1;
  }
  BOOL numberOfLinesChanged = self.cachedNumberOfLinesOfText != (CGFloat)numberOfLines;
  if (numberOfLinesChanged) {
    [self setNeedsLayout];
  }
  self.cachedNumberOfLinesOfText = (CGFloat)numberOfLines;
  return (CGFloat)numberOfLines;
}

- (CGFloat)numberOfLinesOfVisibleText {
  CGFloat numberOfLinesOfText = [self numberOfLinesOfText];
  if (numberOfLinesOfText < self.minimumNumberOfVisibleRows) {
    return self.minimumNumberOfVisibleRows;
  } else if (numberOfLinesOfText > self.maximumNumberOfVisibleRows) {
    return self.maximumNumberOfVisibleRows;
  }
  return numberOfLinesOfText;
}

#pragma mark Dynamic Type

- (void)setAdjustsFontForContentSizeCategory:(BOOL)adjustsFontForContentSizeCategory {
  _adjustsFontForContentSizeCategory = adjustsFontForContentSizeCategory;
  self.textView.adjustsFontForContentSizeCategory = adjustsFontForContentSizeCategory;
  self.leadingAssistiveLabel.adjustsFontForContentSizeCategory = adjustsFontForContentSizeCategory;
  self.trailingAssistiveLabel.adjustsFontForContentSizeCategory = adjustsFontForContentSizeCategory;
}

#pragma mark MDCTextControlState

- (MDCTextControlState)determineCurrentTextControlState {
  BOOL isEnabled = self.enabled && self.baseTextAreaTextView.isEditable;
  BOOL isEditing = self.textView.isFirstResponder;
  return MDCTextControlStateWith(isEnabled, isEditing);
}

#pragma mark Placeholder

- (NSAttributedString *)determineAttributedPlaceholder {
  if ([self shouldPlaceholderBeVisible]) {
    NSDictionary<NSAttributedStringKey, id> *attributes = @{
      NSParagraphStyleAttributeName : [self defaultPlaceholderParagraphStyle],
      NSForegroundColorAttributeName : self.placeholderColor,
      NSFontAttributeName : self.normalFont
    };
    return [[NSAttributedString alloc] initWithString:self.placeholder attributes:attributes];
  } else {
    return nil;
  }
}

- (BOOL)shouldPlaceholderBeVisible {
  return MDCTextControlShouldPlaceholderBeVisibleWithPlaceholder(
      self.placeholder, self.textView.text, self.labelPosition);
}

/**
 This method provides the default paragraph style object for the placeholder label. Without this
 it's much harder to get the placeholder to be perfectly vertically aligned with the text in the
 text view.
 */
- (NSParagraphStyle *)defaultPlaceholderParagraphStyle {
  static NSParagraphStyle *paragraphStyle = nil;
  static dispatch_once_t onceToken;
  dispatch_once(&onceToken, ^{
    id attribute =
        [self defaultUiTextFieldPlaceholderAttributeWithKey:NSParagraphStyleAttributeName];
    if ([attribute isKindOfClass:[NSParagraphStyle class]]) {
      paragraphStyle = (NSParagraphStyle *)attribute;
    }
  });
  return paragraphStyle;
}

- (UIColor *)defaultPlaceholderColor {
  static UIColor *placeholderColor = nil;
  static dispatch_once_t onceToken;
  dispatch_once(&onceToken, ^{
    id attribute =
        [self defaultUiTextFieldPlaceholderAttributeWithKey:NSForegroundColorAttributeName];
    if ([attribute isKindOfClass:[UIColor class]]) {
      placeholderColor = (UIColor *)attribute;
    }
  });
  return placeholderColor;
}

- (id)defaultUiTextFieldPlaceholderAttributeWithKey:(NSAttributedStringKey)attributedStringKey {
  UITextField *textField = [[UITextField alloc] init];
  textField.placeholder = @"placeholder";
  NSAttributedString *attributedPlaceholder = textField.attributedPlaceholder;
  NSDictionary *attributeKeysToAttributes =
      [attributedPlaceholder attributesAtIndex:0
                         longestEffectiveRange:nil
                                       inRange:NSMakeRange(0, attributedPlaceholder.length)];
  for (NSAttributedStringKey key in attributeKeysToAttributes) {
    if (key == attributedStringKey) {
      return attributeKeysToAttributes[attributedStringKey];
    }
  }
  return nil;
}

#pragma mark Label

- (void)animateLabel {
  NSTimeInterval animationDuration = self.labelPositionChanged ? self.animationDuration : 0.0f;
  __weak MDCBaseTextArea *weakSelf = self;
  [MDCTextControlLabelAnimation animateLabel:self.label
                                       state:self.labelPosition
                            normalLabelFrame:self.layout.labelFrameNormal
                          floatingLabelFrame:self.layout.labelFrameFloating
                                  normalFont:self.normalFont
                                floatingFont:self.floatingFont
                    labelTruncationIsPresent:self.layout.labelTruncationIsPresent
                           animationDuration:animationDuration
                                  completion:^(BOOL finished) {
                                    if (finished) {
                                      // Ensure that the label position is correct in case of
                                      // competing animations.
                                      weakSelf.label.frame = [weakSelf.layout
                                          labelFrameWithLabelPosition:self.labelPosition];
                                    }
                                  }];
}

- (BOOL)canLabelFloat {
  return self.labelBehavior == MDCTextControlLabelBehaviorFloats;
}

- (MDCTextControlLabelPosition)determineCurrentLabelPosition {
  return MDCTextControlLabelPositionWith(self.label.text.length > 0, self.textView.text.length > 0,
                                         self.canLabelFloat, self.textView.isFirstResponder);
}

#pragma mark Custom Accessors

- (void)setLeadingEdgePaddingOverride:(NSNumber *)leadingEdgePaddingOverride {
  _leadingEdgePaddingOverride = leadingEdgePaddingOverride;
  [self setNeedsLayout];
}

- (void)setTrailingEdgePaddingOverride:(NSNumber *)trailingEdgePaddingOverride {
  _trailingEdgePaddingOverride = trailingEdgePaddingOverride;
  [self setNeedsLayout];
}

- (UITextView *)textView {
  return self.baseTextAreaTextView;
}

- (void)setPlaceholder:(NSString *)placeholder {
  _placeholder = placeholder;
  [self setNeedsLayout];
}

- (void)setPlaceholderColor:(UIColor *)placeholderColor {
  _placeholderColor = placeholderColor ?: [self defaultPlaceholderColor];
}

- (void)setVerticalDensity:(CGFloat)verticalDensity {
  _verticalDensity = verticalDensity;
  [self setNeedsLayout];
}

#pragma mark MDCTextControl Protocol Accessors

- (void)setLeadingView:(UIView *)leadingView {
  [_leadingView removeFromSuperview];
  _leadingView = leadingView;
  [self setNeedsLayout];
}

- (void)setTrailingView:(UIView *)trailingView {
  [_trailingView removeFromSuperview];
  _trailingView = trailingView;
  [self setNeedsLayout];
}

- (void)setLeadingViewMode:(UITextFieldViewMode)leadingViewMode {
  _leadingViewMode = leadingViewMode;
  [self setNeedsLayout];
}

- (void)setTrailingViewMode:(UITextFieldViewMode)trailingViewMode {
  _trailingViewMode = trailingViewMode;
  [self setNeedsLayout];
}

- (void)setContainerStyle:(id<MDCTextControlStyle>)containerStyle {
  id<MDCTextControlStyle> oldStyle = _containerStyle;
  if (oldStyle) {
    [oldStyle removeStyleFrom:self];
  }
  _containerStyle = containerStyle;
  [_containerStyle applyStyleToTextControl:self animationDuration:self.animationDuration];
}

- (CGRect)containerFrame {
  return CGRectMake(0, 0, CGRectGetWidth(self.frame), self.layout.containerHeight);
}

- (UILabel *)leadingAssistiveLabel {
  return self.assistiveLabelView.leadingAssistiveLabel;
}

- (UILabel *)trailingAssistiveLabel {
  return self.assistiveLabelView.trailingAssistiveLabel;
}

#pragma mark Fonts

- (UIFont *)normalFont {
  return self.baseTextAreaTextView.font ?: MDCTextControlDefaultUITextFieldFont();
}

- (UIFont *)floatingFont {
  return [self.containerStyle floatingFontWithNormalFont:self.normalFont];
}

#pragma mark MDCBaseTextAreaTextViewDelegate

- (void)textAreaTextView:(MDCBaseTextAreaTextView *)textView
    willBecomeFirstResponder:(BOOL)willBecome {
  if (textView == self.baseTextAreaTextView) {
    [self setNeedsLayout];
  }
}

- (void)textAreaTextView:(MDCBaseTextAreaTextView *)textView
    willResignFirstResponder:(BOOL)willResign {
  if (textView == self.baseTextAreaTextView) {
    [self setNeedsLayout];
  }
}

#pragma mark Internationalization

- (BOOL)shouldLayoutForRTL {
  if (self.semanticContentAttribute == UISemanticContentAttributeForceRightToLeft) {
    return YES;
  } else if (self.semanticContentAttribute == UISemanticContentAttributeForceLeftToRight) {
    return NO;
  } else {
    return self.effectiveUserInterfaceLayoutDirection == UIUserInterfaceLayoutDirectionRightToLeft;
  }
}

#pragma mark Coloring

- (void)applyColorViewModel:(MDCTextControlColorViewModel *)colorViewModel
          withLabelPosition:(MDCTextControlLabelPosition)labelPosition {
  UIColor *labelColor = [UIColor clearColor];
  if (labelPosition == MDCTextControlLabelPositionNormal) {
    labelColor = colorViewModel.normalLabelColor;
  } else if (labelPosition == MDCTextControlLabelPositionFloating) {
    labelColor = colorViewModel.floatingLabelColor;
  }
  if (![self.textView.textColor isEqual:colorViewModel.textColor]) {
    self.textView.textColor = colorViewModel.textColor;
  }
  if (![self.leadingAssistiveLabel.textColor isEqual:colorViewModel.leadingAssistiveLabelColor]) {
    self.leadingAssistiveLabel.textColor = colorViewModel.leadingAssistiveLabelColor;
  }
  if (![self.trailingAssistiveLabel.textColor isEqual:colorViewModel.trailingAssistiveLabelColor]) {
    self.trailingAssistiveLabel.textColor = colorViewModel.trailingAssistiveLabelColor;
  }
  if (![self.label.textColor isEqual:labelColor]) {
    self.label.textColor = labelColor;
  }
}

- (void)setTextControlColorViewModel:(MDCTextControlColorViewModel *)TextControlColorViewModel
                            forState:(MDCTextControlState)textControlState {
  self.colorViewModels[@(textControlState)] = TextControlColorViewModel;
}

- (MDCTextControlColorViewModel *)textControlColorViewModelForState:
    (MDCTextControlState)textControlState {
  MDCTextControlColorViewModel *colorViewModel = self.colorViewModels[@(textControlState)];
  if (!colorViewModel) {
    colorViewModel = [[MDCTextControlColorViewModel alloc] initWithState:textControlState];
  }
  return colorViewModel;
}

#pragma mark Color Accessors

- (void)setNormalLabelColor:(nonnull UIColor *)labelColor forState:(MDCTextControlState)state {
  MDCTextControlColorViewModel *colorViewModel = [self textControlColorViewModelForState:state];
  colorViewModel.normalLabelColor = labelColor;
  [self setNeedsLayout];
}

- (UIColor *)normalLabelColorForState:(MDCTextControlState)state {
  MDCTextControlColorViewModel *colorViewModel = [self textControlColorViewModelForState:state];
  return colorViewModel.normalLabelColor;
}

- (void)setFloatingLabelColor:(nonnull UIColor *)labelColor forState:(MDCTextControlState)state {
  MDCTextControlColorViewModel *colorViewModel = [self textControlColorViewModelForState:state];
  colorViewModel.floatingLabelColor = labelColor;
  [self setNeedsLayout];
}

- (UIColor *)floatingLabelColorForState:(MDCTextControlState)state {
  MDCTextControlColorViewModel *colorViewModel = [self textControlColorViewModelForState:state];
  return colorViewModel.floatingLabelColor;
}

- (void)setTextColor:(nonnull UIColor *)labelColor forState:(MDCTextControlState)state {
  MDCTextControlColorViewModel *colorViewModel = [self textControlColorViewModelForState:state];
  colorViewModel.textColor = labelColor;
  [self setNeedsLayout];
}

- (UIColor *)textColorForState:(MDCTextControlState)state {
  MDCTextControlColorViewModel *colorViewModel = [self textControlColorViewModelForState:state];
  return colorViewModel.textColor;
}

- (void)setLeadingAssistiveLabelColor:(nonnull UIColor *)assistiveLabelColor
                             forState:(MDCTextControlState)state {
  MDCTextControlColorViewModel *colorViewModel = [self textControlColorViewModelForState:state];
  colorViewModel.leadingAssistiveLabelColor = assistiveLabelColor;
  [self setNeedsLayout];
}

- (UIColor *)leadingAssistiveLabelColorForState:(MDCTextControlState)state {
  MDCTextControlColorViewModel *colorViewModel = [self textControlColorViewModelForState:state];
  return colorViewModel.leadingAssistiveLabelColor;
}

- (void)setTrailingAssistiveLabelColor:(nonnull UIColor *)assistiveLabelColor
                              forState:(MDCTextControlState)state {
  MDCTextControlColorViewModel *colorViewModel = [self textControlColorViewModelForState:state];
  colorViewModel.trailingAssistiveLabelColor = assistiveLabelColor;
  [self setNeedsLayout];
}

- (UIColor *)trailingAssistiveLabelColorForState:(MDCTextControlState)state {
  MDCTextControlColorViewModel *colorViewModel = [self textControlColorViewModelForState:state];
  return colorViewModel.trailingAssistiveLabelColor;
}

#pragma mark User Actions

- (void)handleTap:(UITapGestureRecognizer *)tap {
  if (tap.state == UIGestureRecognizerStateEnded) {
    if (!self.textView.isFirstResponder) {
      [self.textView becomeFirstResponder];
    }
  }
}

- (void)textViewChanged:(NSNotification *)notification {
  if (notification.object == self.baseTextAreaTextView) {
    [self setNeedsLayout];
  }
}

#pragma mark Notifications

- (void)observeTextViewNotifications {
  [[NSNotificationCenter defaultCenter] addObserver:self
                                           selector:@selector(textViewChanged:)
                                               name:UITextViewTextDidChangeNotification
                                             object:nil];
}

#pragma mark - Key-value observing

- (void)observeLabelKeyPaths {
  for (NSString *keyPath in [MDCBaseTextArea assistiveLabelKeyPaths]) {
    [self.leadingAssistiveLabel addObserver:self
                                 forKeyPath:keyPath
                                    options:NSKeyValueObservingOptionNew
                                    context:kKVOContextMDCBaseTextArea];
    [self.trailingAssistiveLabel addObserver:self
                                  forKeyPath:keyPath
                                     options:NSKeyValueObservingOptionNew
                                     context:kKVOContextMDCBaseTextArea];
  }
  for (NSString *keyPath in [MDCBaseTextArea labelKeyPaths]) {
    [self.label addObserver:self
                 forKeyPath:keyPath
                    options:NSKeyValueObservingOptionNew
                    context:kKVOContextMDCBaseTextArea];
  }
}

- (void)removeObservers {
  for (NSString *keyPath in [MDCBaseTextArea assistiveLabelKeyPaths]) {
    [self.leadingAssistiveLabel removeObserver:self
                                    forKeyPath:keyPath
                                       context:kKVOContextMDCBaseTextArea];
    [self.trailingAssistiveLabel removeObserver:self
                                     forKeyPath:keyPath
                                        context:kKVOContextMDCBaseTextArea];
  }
  for (NSString *keyPath in [MDCBaseTextArea labelKeyPaths]) {
    [self.label removeObserver:self forKeyPath:keyPath context:kKVOContextMDCBaseTextArea];
  }
}

- (void)observeValueForKeyPath:(NSString *)keyPath
                      ofObject:(id)object
                        change:(NSDictionary<NSKeyValueChangeKey, id> *)change
                       context:(void *)context {
  if (context == kKVOContextMDCBaseTextArea) {
    if (object == self.leadingAssistiveLabel || object == self.trailingAssistiveLabel) {
      for (NSString *labelKeyPath in [MDCBaseTextArea assistiveLabelKeyPaths]) {
        if ([labelKeyPath isEqualToString:keyPath]) {
          [self setNeedsLayout];
          break;
        }
      }
    } else if (object == self.label)
      for (NSString *labelKeyPath in [MDCBaseTextArea labelKeyPaths]) {
        if ([labelKeyPath isEqualToString:keyPath]) {
          [self setNeedsLayout];
          break;
        }
      }
  }
}

+ (NSArray<NSString *> *)assistiveLabelKeyPaths {
  static NSArray<NSString *> *keyPaths = nil;
  static dispatch_once_t onceToken;
  dispatch_once(&onceToken, ^{
    keyPaths = @[
      NSStringFromSelector(@selector(text)),
      NSStringFromSelector(@selector(font)),
    ];
  });
  return keyPaths;
}

+ (NSArray<NSString *> *)labelKeyPaths {
  static NSArray<NSString *> *keyPaths = nil;
  static dispatch_once_t onceToken;
  dispatch_once(&onceToken, ^{
    keyPaths = @[
      NSStringFromSelector(@selector(text)),
    ];
  });
  return keyPaths;
}

@end