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

#import "components/open_from_clipboard/clipboard_recent_content_impl_ios.h"

#import <MobileCoreServices/MobileCoreServices.h>
#import <UIKit/UIKit.h>

#import "base/apple/foundation_util.h"
#import "base/functional/bind.h"
#include "base/notreached.h"
#include "base/strings/sys_string_conversions.h"
#include "base/system/sys_info.h"
#include "components/open_from_clipboard/clipboard_async_wrapper_ios.h"

ContentType const ContentTypeURL = @"ContentTypeURL";
ContentType const ContentTypeText = @"ContentTypeString";
ContentType const ContentTypeImage = @"ContentTypeImage";

namespace {
// Key used to store the pasteboard's current change count. If when resuming
// chrome the pasteboard's change count is different from the stored one, then
// it means that the pasteboard's content has changed.
NSString* const kPasteboardChangeCountKey = @"PasteboardChangeCount";
// Key used to store the last date at which it was detected that the pasteboard
// changed. It is used to evaluate the age of the pasteboard's content.
NSString* const kPasteboardChangeDateKey = @"PasteboardChangeDate";
// Default Scheme to use for urls with no scheme.
NSString* const kDefaultScheme = @"https";

}  // namespace

@interface ClipboardRecentContentImplIOS ()

// The user defaults from the app group used to optimize the pasteboard change
// detection.
@property(nonatomic, strong) NSUserDefaults* sharedUserDefaults;
// The pasteboard's change count. Increases everytime the pasteboard changes.
@property(nonatomic) NSInteger lastPasteboardChangeCount;
// Contains the authorized schemes for URLs.
@property(nonatomic, readonly) NSSet* authorizedSchemes;
// Delegate for metrics.
@property(nonatomic, strong) id<ClipboardRecentContentDelegate> delegate;
// Maximum age of clipboard in seconds.
@property(nonatomic, readonly) NSTimeInterval maximumAgeOfClipboard;
// Whether the clipboard should only be accessed asynchronously.
@property(nonatomic, assign) BOOL onlyUseClipboardAsync;

// A cached version of an already-retrieved URL. This prevents subsequent URL
// requests from triggering the iOS 14 pasteboard notification.
@property(nonatomic, strong) NSURL* cachedURL;
// A cached version of an already-retrieved string. This prevents subsequent
// string requests from triggering the iOS 14 pasteboard notification.
@property(nonatomic, copy) NSString* cachedText;
// A cached version of an already-retrieved image. This prevents subsequent
// image requests from triggering the iOS 14 pasteboard notification.
@property(nonatomic, strong) UIImage* cachedImage;
// A cached set of the content types currently being used for the clipboard.
@property(nonatomic, strong) NSSet<ContentType>* cachedContentTypes;

// Loads information from the user defaults about the latest pasteboard entry.
- (void)loadFromUserDefaults;

// Returns the URL contained in `pasteboard` (if any).
- (NSURL*)URLFromPasteboard:(UIPasteboard*)pasteboard;

// Returns the uptime.
- (NSTimeInterval)uptime;

// Calls |completionHandler| with the result of whether or not the clipboard
// currently contains data matching |contentType|.
- (void)checkForContentType:(ContentType)contentType
                 pasteboard:(UIPasteboard*)pasteboard
          completionHandler:(void (^)(BOOL))completionHandler;

// Checks the clipboard for content matching |types| and calls
// |completionHandler| once all types are checked. This method is called
// recursively and partial results are passed in |results| until all types have
// been checked.
- (void)
    hasContentMatchingRemainingTypes:(NSSet<ContentType>*)types
                          pasteboard:(UIPasteboard*)pasteboard
                             results:
                                 (NSMutableDictionary<ContentType, NSNumber*>*)
                                     results
                   completionHandler:
                       (void (^)(NSSet<ContentType>*))completionHandler;

@end

@implementation ClipboardRecentContentImplIOS

- (instancetype)initWithMaxAge:(NSTimeInterval)maxAge
             authorizedSchemes:(NSSet<NSString*>*)authorizedSchemes
                  userDefaults:(NSUserDefaults*)groupUserDefaults
         onlyUseClipboardAsync:(BOOL)onlyUseClipboardAsync
                      delegate:(id<ClipboardRecentContentDelegate>)delegate {
  self = [super init];
  if (self) {
    _maximumAgeOfClipboard = maxAge;
    _delegate = delegate;
    _authorizedSchemes = authorizedSchemes;
    _sharedUserDefaults = groupUserDefaults;
    _onlyUseClipboardAsync = onlyUseClipboardAsync;

    _lastPasteboardChangeCount = NSIntegerMax;
    [self loadFromUserDefaults];
    [self updateCachedClipboardState];

    [[NSNotificationCenter defaultCenter]
        addObserver:self
           selector:@selector(didBecomeActive:)
               name:UIApplicationDidBecomeActiveNotification
             object:nil];
    [[NSNotificationCenter defaultCenter]
        addObserver:self
           selector:@selector(pasteboardDidChange:)
               name:UIPasteboardChangedNotification
             object:nil];

    __weak __typeof(self) weakSelf = self;
    GetGeneralPasteboard(
        _onlyUseClipboardAsync, base::BindOnce(^(UIPasteboard* pasteboard) {
          [weakSelf updateIfNeededWithPasteboard:pasteboard];
          // Makes sure |last_pasteboard_change_count_| was properly
          // initialized.
          DCHECK_NE(weakSelf.lastPasteboardChangeCount, NSIntegerMax);
        }));
  }
  return self;
}

- (void)dealloc {
  [[NSNotificationCenter defaultCenter] removeObserver:self];
}

- (void)didBecomeActive:(NSNotification*)notification {
  [self loadFromUserDefaults];
  [self updateCachedClipboardState];

  __weak __typeof(self) weakSelf = self;
  GetGeneralPasteboard(self.onlyUseClipboardAsync,
                       base::BindOnce(^(UIPasteboard* pasteboard) {
                         [weakSelf updateIfNeededWithPasteboard:pasteboard];
                       }));
}

#pragma mark - Public

- (NSURL*)recentURLFromClipboard {
  // If the clipboard can only be accessed asynchronously, then this method
  // cannot even check whether the existing cached URL is stil valid.
  if (self.onlyUseClipboardAsync) {
    return nil;
  }
  return [self recentURLFromPasteboard:UIPasteboard.generalPasteboard];
}

- (NSString*)recentTextFromClipboard {
  // If the clipboard can only be accessed asynchronously, then this method
  // cannot even check whether the existing cached text is stil valid.
  if (self.onlyUseClipboardAsync) {
    return nil;
  }

  return [self recentTextFromPasteboard:UIPasteboard.generalPasteboard];
}

- (UIImage*)recentImageFromClipboard {
  // If the clipboard can only be accessed asynchronously, then this method
  // cannot even check whether the existing cached image is stil valid.
  if (self.onlyUseClipboardAsync) {
    return nil;
  }

  return [self recentImageFromPasteboard:UIPasteboard.generalPasteboard];
}

- (NSSet<ContentType>*)cachedClipboardContentTypes {
  if (![self shouldReturnValueOfClipboard:nil]) {
    return nil;
  }
  return self.cachedContentTypes;
}

- (void)hasContentMatchingTypes:(NSSet<ContentType>*)types
              completionHandler:
                  (void (^)(NSSet<ContentType>*))completionHandler {
  __weak __typeof(self) weakSelf = self;
  GetGeneralPasteboard(self.onlyUseClipboardAsync,
                       base::BindOnce(^(UIPasteboard* pasteboard) {
                         [weakSelf hasContentMatchingTypes:types
                                                pasteboard:pasteboard
                                         completionHandler:completionHandler];
                       }));
}

- (void)recentURLFromClipboardAsync:(void (^)(NSURL*))callback {
  __weak __typeof(self) weakSelf = self;
  GetGeneralPasteboard(
      self.onlyUseClipboardAsync, base::BindOnce(^(UIPasteboard* pasteboard) {
        [weakSelf recentURLFromClipboardAsyncWithPasteboard:pasteboard
                                                   callback:callback];
      }));
}

- (void)recentTextFromClipboardAsync:(void (^)(NSString*))callback {
  __weak __typeof(self) weakSelf = self;
  GetGeneralPasteboard(
      self.onlyUseClipboardAsync, base::BindOnce(^(UIPasteboard* pasteboard) {
        [weakSelf recentTextFromClipboardAsyncWithPasteboard:pasteboard
                                                    callback:callback];
      }));
}

- (void)recentImageFromClipboardAsync:(void (^)(UIImage*))callback {
  __weak __typeof(self) weakSelf = self;
  GetGeneralPasteboard(
      self.onlyUseClipboardAsync, base::BindOnce(^(UIPasteboard* pasteboard) {
        [weakSelf recentImageFromClipboardAsyncWithPasteboard:pasteboard
                                                     callback:callback];
      }));
}

- (NSTimeInterval)clipboardContentAge {
  return -[self.lastPasteboardChangeDate timeIntervalSinceNow];
}

- (void)suppressClipboardContent {
  // User cleared the user data. The pasteboard entry must be removed from the
  // omnibox list. Force entry expiration by setting copy date to 1970.
  self.lastPasteboardChangeDate =
      [[NSDate alloc] initWithTimeIntervalSince1970:0];
  [self saveToUserDefaults];
}

- (void)saveToUserDefaults {
  [self.sharedUserDefaults setInteger:self.lastPasteboardChangeCount
                               forKey:kPasteboardChangeCountKey];
  [self.sharedUserDefaults setObject:self.lastPasteboardChangeDate
                              forKey:kPasteboardChangeDateKey];
}

#pragma mark - Private

// Returns whether the pasteboard changed since the last time a pasteboard
// change was detected.
- (BOOL)hasPasteboardChanged:(UIPasteboard*)pasteboard {
  return pasteboard.changeCount != self.lastPasteboardChangeCount;
}

- (void)pasteboardDidChange:(NSNotification*)notification {
  [self updateCachedClipboardState];
}

- (void)updateCachedClipboardState {
  self.cachedContentTypes = nil;

  NSSet<ContentType>* desiredContentTypes = [NSSet
      setWithArray:@[ ContentTypeImage, ContentTypeURL, ContentTypeText ]];
  __weak __typeof(self) weakSelf = self;
  [self hasContentMatchingTypes:desiredContentTypes
              completionHandler:^(NSSet<ContentType>* results) {
                weakSelf.cachedContentTypes = results;
              }];
}

// The synchronous version of this method is kept around for public APIs and old
// iOS versions.
- (NSURL*)recentURLFromPasteboard:(UIPasteboard*)pasteboard {
  [self updateIfNeededWithPasteboard:pasteboard];

  if (![self shouldReturnValueOfClipboard:pasteboard]) {
    return nil;
  }

  return self.cachedURL;
}

// The synchronous version of this method is kept around for public APIs and old
// iOS versions.
- (NSString*)recentTextFromPasteboard:(UIPasteboard*)pasteboard {
  [self updateIfNeededWithPasteboard:pasteboard];

  if (![self shouldReturnValueOfClipboard:pasteboard]) {
    return nil;
  }

  return self.cachedText;
}

// The synchronous version of this method is kept around for public APIs and old
// iOS versions.
- (UIImage*)recentImageFromPasteboard:(UIPasteboard*)pasteboard {
  [self updateIfNeededWithPasteboard:pasteboard];

  if (![self shouldReturnValueOfClipboard:pasteboard]) {
    return nil;
  }

  return self.cachedImage;
}

// Checks for if the given `pasteboard` has content matching the provided
// `types`.
- (void)hasContentMatchingTypes:(NSSet<ContentType>*)types
                     pasteboard:(UIPasteboard*)pasteboard
              completionHandler:
                  (void (^)(NSSet<ContentType>*))completionHandler {
  [self updateIfNeededWithPasteboard:pasteboard];
  if (![self shouldReturnValueOfClipboard:pasteboard] || ![types count]) {
    completionHandler([NSSet set]);
    return;
  }

  [self hasContentMatchingRemainingTypes:types
                              pasteboard:pasteboard
                                 results:[[NSMutableDictionary alloc] init]
                       completionHandler:completionHandler];
}

- (void)
    hasContentMatchingRemainingTypes:(NSSet<ContentType>*)types
                          pasteboard:(UIPasteboard*)pasteboard
                             results:
                                 (NSMutableDictionary<ContentType, NSNumber*>*)
                                     results
                   completionHandler:
                       (void (^)(NSSet<ContentType>*))completionHandler {
  if ([types count] == 0) {
    NSMutableSet<ContentType>* matchingTypes = [NSMutableSet set];
    for (ContentType type in results) {
      if ([results[type] boolValue]) {
        [matchingTypes addObject:type];
      }
    }
    completionHandler(matchingTypes);
    return;
  }

  __weak __typeof(self) weakSelf = self;
  ContentType type = [types anyObject];
  [self checkForContentType:type
                 pasteboard:pasteboard
          completionHandler:^(BOOL hasType) {
            results[type] = @(hasType);

            NSMutableSet* remainingTypes = [types mutableCopy];
            [remainingTypes removeObject:type];
            [weakSelf hasContentMatchingRemainingTypes:remainingTypes
                                            pasteboard:pasteboard
                                               results:results
                                     completionHandler:completionHandler];
          }];
}

- (void)checkForContentType:(ContentType)contentType
                 pasteboard:(UIPasteboard*)pasteboard
          completionHandler:(void (^)(BOOL))completionHandler {
  if ([contentType isEqualToString:ContentTypeText]) {
    [self hasRecentTextFromClipboardInternalWithPasteboard:pasteboard
                                                  callback:^(BOOL hasText) {
                                                    completionHandler(hasText);
                                                  }];
  } else if ([contentType isEqualToString:ContentTypeURL]) {
    [self hasRecentURLFromClipboardInternalWithPasteboard:pasteboard
                                                 callback:^(BOOL hasURL) {
                                                   completionHandler(hasURL);
                                                 }];
  } else if ([contentType isEqualToString:ContentTypeImage]) {
    [self
        hasRecentImageFromClipboardInternalWithPasteboard:pasteboard
                                                 callback:^(BOOL hasImage) {
                                                   completionHandler(hasImage);
                                                 }];
  } else {
    NOTREACHED() << contentType;
  }
}

// The underlying logic to check if the clipboard has a recent URL, with the
// addition of a `pasteboard` parameter to aid in forcing all pasteboard access
// to be async.
- (void)
    hasRecentURLFromClipboardInternalWithPasteboard:(UIPasteboard*)pasteboard
                                           callback:(void (^)(BOOL))callback {
  DCHECK(callback);
  // Use cached value if it exists.
  if (self.cachedURL) {
    callback(YES);
    return;
  }

  NSSet<UIPasteboardDetectionPattern>* urlPattern =
      [NSSet setWithObject:UIPasteboardDetectionPatternProbableWebURL];
  [pasteboard
      detectPatternsForPatterns:urlPattern
              completionHandler:^(NSSet<UIPasteboardDetectionPattern>* patterns,
                                  NSError* error) {
                callback([patterns
                    containsObject:UIPasteboardDetectionPatternProbableWebURL]);
              }];
}

// The underlying logic to check if the clipboard has recent text, with the
// addition of a `pasteboard` parameter to aid in forcing all pasteboard access
// to be async.
- (void)
    hasRecentTextFromClipboardInternalWithPasteboard:(UIPasteboard*)pasteboard
                                            callback:(void (^)(BOOL))callback {
  DCHECK(callback);
  // Use cached value if it exists.
  if (self.cachedText) {
    callback(YES);
    return;
  }

  NSSet<UIPasteboardDetectionPattern>* textPattern =
      [NSSet setWithObject:UIPasteboardDetectionPatternProbableWebSearch];
  [pasteboard
      detectPatternsForPatterns:textPattern
              completionHandler:^(NSSet<UIPasteboardDetectionPattern>* patterns,
                                  NSError* error) {
                callback([patterns
                    containsObject:
                        UIPasteboardDetectionPatternProbableWebSearch]);
              }];
}

// The underlying logic to check if the clipboard has a recent image, with the
// addition of a `pasteboard` parameter to aid in forcing all pasteboard access
// to be async.
- (void)
    hasRecentImageFromClipboardInternalWithPasteboard:(UIPasteboard*)pasteboard
                                             callback:(void (^)(BOOL))callback {
  DCHECK(callback);
  // Use cached value if it exists
  if (self.cachedImage) {
    callback(YES);
    return;
  }

  callback(pasteboard.hasImages);
}

// The underlying logic to check the recent url, with the addition of a
// `pasteboard` parameter to aid in forcing all pasteboard access to be async.
- (void)recentURLFromClipboardAsyncWithPasteboard:(UIPasteboard*)pasteboard
                                         callback:(void (^)(NSURL*))callback {
  DCHECK(callback);
  [self updateIfNeededWithPasteboard:pasteboard];
  if (![self shouldReturnValueOfClipboard:pasteboard]) {
    callback(nil);
    return;
  }

  // Use cached value if it exists.
  if (self.cachedURL) {
    callback(self.cachedURL);
    return;
  }

  __weak __typeof(self) weakSelf = self;
  NSSet<UIPasteboardDetectionPattern>* urlPattern =
      [NSSet setWithObject:UIPasteboardDetectionPatternProbableWebURL];
  [pasteboard detectValuesForPatterns:urlPattern
                    completionHandler:^(
                        NSDictionary<UIPasteboardDetectionPattern, id>* values,
                        NSError* error) {
                      [weakSelf callCompletionHandlerWithValues:values
                                                       callback:callback
                                                          error:error];
                    }];
}

// Helper method for completion handler block to ensure `self` isn't retained.
- (void)callCompletionHandlerWithValues:
            (NSDictionary<UIPasteboardDetectionPattern, id>*)values
                               callback:(void (^)(NSURL*))callback
                                  error:(NSError*)error {
  // On iOS 16, users can deny access to the clipboard.
  if (error) {
    self.cachedURL = nil;
    callback(nil);
    return;
  }
  NSURL* url =
      [NSURL URLWithString:values[UIPasteboardDetectionPatternProbableWebURL]];

  // |detectValuesForPatterns:| will return a url even if the url
  // is missing a scheme. In this case, default to https.
  if (url && url.scheme == nil) {
    NSURLComponents* components = [[NSURLComponents alloc] initWithURL:url
                                               resolvingAgainstBaseURL:NO];
    components.scheme = kDefaultScheme;
    url = components.URL;
  }

  if (![self.authorizedSchemes containsObject:url.scheme]) {
    self.cachedURL = nil;
    callback(nil);
  } else {
    self.cachedURL = url;
    callback(url);
  }
}

// The underlying logic to check the recent text, with the addition of a
// `pasteboard` parameter to aid in forcing all pasteboard access to be async.
- (void)recentTextFromClipboardAsyncWithPasteboard:(UIPasteboard*)pasteboard
                                          callback:
                                              (void (^)(NSString*))callback {
  DCHECK(callback);
  [self updateIfNeededWithPasteboard:pasteboard];
  if (![self shouldReturnValueOfClipboard:pasteboard]) {
    callback(nil);
    return;
  }

  // Use cached value if it exists.
  if (self.cachedText) {
    callback(self.cachedText);
    return;
  }

  __weak __typeof(self) weakSelf = self;
  NSSet<UIPasteboardDetectionPattern>* textPattern =
      [NSSet setWithObject:UIPasteboardDetectionPatternProbableWebSearch];
  [pasteboard detectValuesForPatterns:textPattern
                    completionHandler:^(
                        NSDictionary<UIPasteboardDetectionPattern, id>* values,
                        NSError* error) {
                      NSString* text =
                          values[UIPasteboardDetectionPatternProbableWebSearch];
                      weakSelf.cachedText = text;

                      callback(text);
                    }];
}

// The underlying logic to check the recent image, with the addition of a
// `pasteboard` parameter to aid in forcing all pasteboard access to be async.
- (void)recentImageFromClipboardAsyncWithPasteboard:(UIPasteboard*)pasteboard
                                           callback:
                                               (void (^)(UIImage*))callback {
  DCHECK(callback);
  [self updateIfNeededWithPasteboard:pasteboard];
  if (![self shouldReturnValueOfClipboard:pasteboard]) {
    callback(nil);
    return;
  }

  if (!self.cachedImage) {
    self.cachedImage = pasteboard.image;
  }
  callback(self.cachedImage);
}

// Returns whether the value of the given clipboard should be returned.
- (BOOL)shouldReturnValueOfClipboard:(UIPasteboard*)pasteboard {
  if ([self clipboardContentAge] > self.maximumAgeOfClipboard)
    return NO;

  // It is the common convention on iOS that password managers tag confidential
  // data with the flavor "org.nspasteboard.ConcealedType". Obey this
  // convention; the user doesn't want for their confidential data to be
  // suggested as a search, anyway. See http://nspasteboard.org/ for more info.
  NSArray<NSString*>* types = [pasteboard pasteboardTypes];
  if ([types containsObject:@"org.nspasteboard.ConcealedType"])
    return NO;

  return YES;
}

// If the content of the pasteboard has changed, updates the change count
// and change date.
- (void)updateIfNeededWithPasteboard:(UIPasteboard*)pasteboard {
  if (![self hasPasteboardChanged:pasteboard]) {
    return;
  }

  self.lastPasteboardChangeDate = [NSDate date];
  self.lastPasteboardChangeCount = pasteboard.changeCount;

  // Clear the cache because the pasteboard data has changed.
  self.cachedURL = nil;
  self.cachedText = nil;
  self.cachedImage = nil;

  [self.delegate onClipboardChanged];

  [self saveToUserDefaults];
}

- (NSURL*)URLFromPasteboard:(UIPasteboard*)pasteboard {
  NSURL* url = pasteboard.URL;
  // Usually, even if the user copies plaintext, if it looks like a URL, the URL
  // property is filled. Sometimes, this doesn't happen, for instance when the
  // pasteboard is sync'd from a Mac to the iOS simulator. In this case,
  // fallback and manually check whether the pasteboard contains a url-like
  // string.
  if (!url) {
    url = [NSURL URLWithString:pasteboard.string];
  }
  if (![self.authorizedSchemes containsObject:url.scheme]) {
    return nil;
  }
  return url;
}

- (void)loadFromUserDefaults {
  self.lastPasteboardChangeCount =
      [self.sharedUserDefaults integerForKey:kPasteboardChangeCountKey];
  self.lastPasteboardChangeDate = base::apple::ObjCCastStrict<NSDate>(
      [self.sharedUserDefaults objectForKey:kPasteboardChangeDateKey]);
}

- (NSTimeInterval)uptime {
  return base::SysInfo::Uptime().InSecondsF();
}

@end