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

#include "components/open_from_clipboard/clipboard_recent_content_ios.h"

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

#include <memory>

#include "base/functional/bind.h"
#include "base/strings/sys_string_conversions.h"
#include "base/strings/utf_string_conversions.h"
#import "base/test/ios/wait_util.h"
#include "base/test/task_environment.h"
#import "components/open_from_clipboard/clipboard_recent_content_impl_ios.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "testing/platform_test.h"

using base::test::ios::WaitUntilConditionOrTimeout;
using base::test::ios::kWaitForCookiesTimeout;
using base::test::ios::kWaitForActionTimeout;

namespace {

UIImage* TestUIImage(UIColor* color = [UIColor redColor]) {
  CGRect frame = CGRectMake(0, 0, 1.0, 1.0);
  UIGraphicsBeginImageContext(frame.size);

  CGContextRef context = UIGraphicsGetCurrentContext();
  CGContextSetFillColorWithColor(context, color.CGColor);
  CGContextFillRect(context, frame);

  UIImage* image = UIGraphicsGetImageFromCurrentImageContext();
  UIGraphicsEndImageContext();

  return image;
}

void SetPasteboardImage(UIImage* image) {
  [[UIPasteboard generalPasteboard] setImage:image];
}

void SetPasteboardContent(const char* data) {
  [[UIPasteboard generalPasteboard]
               setValue:[NSString stringWithUTF8String:data]
      forPasteboardType:@"public.plain-text"];
}
const char kUnrecognizedURL[] = "bad://foo/";
const char kRecognizedURL[] = "good://bar/";
const char kRecognizedURL2[] = "good://bar/2";
const char kAppSpecificURL[] = "test://qux/";
const char kAppSpecificScheme[] = "test";
const char kRecognizedScheme[] = "good";
NSTimeInterval kLongerThanMaxAge = 60 * 60 * 7;
NSTimeInterval kMaxAge = 60 * 60 * 1;
}  // namespace

@interface ClipboardRecentContentImplIOSWithFakeUptime
    : ClipboardRecentContentImplIOS
@property(nonatomic) NSTimeInterval fakeUptime;

- (instancetype)initWithMaxAge:(NSTimeInterval)maxAge
             authorizedSchemes:(NSArray*)authorizedSchemes
                  userDefaults:(NSUserDefaults*)groupUserDefaults
         onlyUseClipboardAsync:(BOOL)onlyUseClipboardAsync
                        uptime:(NSTimeInterval)uptime;

@end

@implementation ClipboardRecentContentImplIOSWithFakeUptime

@synthesize fakeUptime = _fakeUptime;

- (instancetype)initWithMaxAge:(NSTimeInterval)maxAge
             authorizedSchemes:(NSSet*)authorizedSchemes
                  userDefaults:(NSUserDefaults*)groupUserDefaults
         onlyUseClipboardAsync:(BOOL)onlyUseClipboardAsync
                        uptime:(NSTimeInterval)uptime {
  self = [super initWithMaxAge:maxAge
             authorizedSchemes:authorizedSchemes
                  userDefaults:groupUserDefaults
         onlyUseClipboardAsync:onlyUseClipboardAsync
                      delegate:nil];
  if (self) {
    _fakeUptime = uptime;
  }
  return self;
}

- (NSTimeInterval)uptime {
  return self.fakeUptime;
}

@end

class ClipboardRecentContentIOSWithFakeUptime
    : public ClipboardRecentContentIOS {
 public:
  ClipboardRecentContentIOSWithFakeUptime(
      ClipboardRecentContentImplIOS* implementation)
      : ClipboardRecentContentIOS(implementation) {}
};

class ClipboardRecentContentIOSTest : public ::testing::Test {
 protected:
  ClipboardRecentContentIOSTest() {
    // By default, set that the device booted 10 days ago.
    ResetClipboardRecentContent(kAppSpecificScheme, base::Days(10));
  }

  void SimulateDeviceRestart() {
    ResetClipboardRecentContent(kAppSpecificScheme, base::Seconds(0));
  }

  void ResetClipboardRecentContent(const std::string& application_scheme,
                                   base::TimeDelta time_delta) {
    ClipboardRecentContentImplIOSWithFakeUptime*
        clipboard_content_implementation =
            [[ClipboardRecentContentImplIOSWithFakeUptime alloc]
                       initWithMaxAge:kMaxAge
                    authorizedSchemes:@[
                      base::SysUTF8ToNSString(kRecognizedScheme),
                      base::SysUTF8ToNSString(application_scheme)
                    ]
                         userDefaults:[NSUserDefaults standardUserDefaults]
                onlyUseClipboardAsync:NO
                               uptime:time_delta.InSecondsF()];

    clipboard_content_ =
        std::make_unique<ClipboardRecentContentIOSWithFakeUptime>(
            clipboard_content_implementation);

    // Keep a weak pointer to the ClipboardRecentContentImplIOS to allow
    // updating the fake pasteboard change date.
    clipboard_content_implementation_ = clipboard_content_implementation;
  }

  void SetStoredPasteboardChangeDate(NSDate* change_date) {
    clipboard_content_implementation_.lastPasteboardChangeDate = change_date;
    [clipboard_content_implementation_ saveToUserDefaults];
  }

 protected:
  std::unique_ptr<ClipboardRecentContentIOSWithFakeUptime> clipboard_content_;
  __weak ClipboardRecentContentImplIOSWithFakeUptime*
      clipboard_content_implementation_;

  base::test::TaskEnvironment task_environment_;

  void VerifyClipboardTypeExists(ClipboardContentType type, bool exists) {
    __block BOOL callback_called = NO;
    __block BOOL type_exists = NO;
    std::set<ClipboardContentType> types;
    types.insert(type);
    clipboard_content_->HasRecentContentFromClipboard(
        types, base::BindOnce(^(std::set<ClipboardContentType> found_types) {
          callback_called = YES;
          type_exists = found_types.find(type) != found_types.end();
        }));

    EXPECT_TRUE(WaitUntilConditionOrTimeout(kWaitForCookiesTimeout, ^bool {
      base::RunLoop().RunUntilIdle();
      return callback_called;
    }));
    EXPECT_EQ(exists, type_exists);
  }

  void VerifyClipboardURLExists(const char* expected_url) {
    VerifyClipboardTypeExists(ClipboardContentType::URL, true);

    __block BOOL callback_called = NO;
    __block std::optional<GURL> optional_gurl;
    clipboard_content_->GetRecentURLFromClipboard(
        base::BindOnce(^(std::optional<GURL> copied_url) {
          optional_gurl = copied_url;
          callback_called = YES;
        }));
    EXPECT_TRUE(WaitUntilConditionOrTimeout(kWaitForCookiesTimeout, ^bool {
      base::RunLoop().RunUntilIdle();
      return callback_called;
    }));
    ASSERT_TRUE(optional_gurl.has_value());
    EXPECT_STREQ(expected_url, optional_gurl.value().spec().c_str());
  }

  bool VerifyCacheClipboardContentTypeExists(ClipboardContentType type) {
    std::optional<std::set<ClipboardContentType>> cached_content_types =
        clipboard_content_->GetCachedClipboardContentTypes();
    if (cached_content_types.has_value()) {
      return cached_content_types.value().find(type) !=
             cached_content_types.value().end();
    } else {
      return false;
    }
  }

  void VerifiyClipboardURLIsInvalid() {
    VerifyClipboardTypeExists(ClipboardContentType::URL, true);

    __block BOOL callback_called = NO;
    __block std::optional<GURL> optional_gurl;
    clipboard_content_->GetRecentURLFromClipboard(
        base::BindOnce(^(std::optional<GURL> copied_url) {
          optional_gurl = copied_url;
          callback_called = YES;
        }));
    EXPECT_TRUE(WaitUntilConditionOrTimeout(kWaitForCookiesTimeout, ^bool {
      base::RunLoop().RunUntilIdle();
      return callback_called;
    }));
    EXPECT_FALSE(optional_gurl.has_value());
  }

  bool WaitForClipboardContentTypesRefresh() {
    bool success = WaitUntilConditionOrTimeout(kWaitForActionTimeout, ^bool() {
      return clipboard_content_->GetCachedClipboardContentTypes().has_value();
    });

    return success;
  }
};

TEST_F(ClipboardRecentContentIOSTest, SchemeFiltering) {
  // Test unrecognized URL.
  SetPasteboardContent(kUnrecognizedURL);
  VerifiyClipboardURLIsInvalid();

  // Test recognized URL.
  SetPasteboardContent(kRecognizedURL);
  VerifyClipboardURLExists(kRecognizedURL);

  // Test URL with app specific scheme.
  SetPasteboardContent(kAppSpecificURL);
  VerifyClipboardURLExists(kAppSpecificURL);

  // Test URL without app specific scheme.
  ResetClipboardRecentContent(std::string(), base::Days(10));

  SetPasteboardContent(kAppSpecificURL);
  VerifiyClipboardURLIsInvalid();
}

TEST_F(ClipboardRecentContentIOSTest, PasteboardURLObsolescence) {
  SetPasteboardContent(kRecognizedURL);

  // Test that recent pasteboard data is provided.
  VerifyClipboardURLExists(kRecognizedURL);

  // Test that old pasteboard data is not provided.
  SetStoredPasteboardChangeDate(
      [NSDate dateWithTimeIntervalSinceNow:-kLongerThanMaxAge]);

  VerifyClipboardTypeExists(ClipboardContentType::URL, false);
  VerifyClipboardTypeExists(ClipboardContentType::Text, false);

  // Tests that if chrome is relaunched, old pasteboard data is still
  // not provided.
  ResetClipboardRecentContent(kAppSpecificScheme, base::Days(10));
  VerifyClipboardTypeExists(ClipboardContentType::URL, false);
  VerifyClipboardTypeExists(ClipboardContentType::Text, false);

  SimulateDeviceRestart();
  // Tests that if the device is restarted, old pasteboard data is still
  // not provided.
  VerifyClipboardTypeExists(ClipboardContentType::URL, false);
  VerifyClipboardTypeExists(ClipboardContentType::Text, false);
}

TEST_F(ClipboardRecentContentIOSTest,
       CacheClipboardContentTypesUpdatesForCopiedURL) {
  SetPasteboardContent(kRecognizedURL);
  ASSERT_TRUE(WaitForClipboardContentTypesRefresh());

  EXPECT_TRUE(VerifyCacheClipboardContentTypeExists(ClipboardContentType::URL));
  EXPECT_FALSE(
      VerifyCacheClipboardContentTypeExists(ClipboardContentType::Image));
  EXPECT_FALSE(
      VerifyCacheClipboardContentTypeExists(ClipboardContentType::Text));
}

TEST_F(ClipboardRecentContentIOSTest,
       CacheClipboardContentTypesUpdatesForCopiedImage) {
  SetPasteboardImage(TestUIImage());
  ASSERT_TRUE(WaitForClipboardContentTypesRefresh());

  EXPECT_TRUE(
      VerifyCacheClipboardContentTypeExists(ClipboardContentType::Image));
  EXPECT_FALSE(
      VerifyCacheClipboardContentTypeExists(ClipboardContentType::URL));
  EXPECT_FALSE(
      VerifyCacheClipboardContentTypeExists(ClipboardContentType::Text));
}

TEST_F(ClipboardRecentContentIOSTest,
       CacheClipboardContentTypesUpdatesForCopiedText) {
  SetPasteboardContent("foobar");
  ASSERT_TRUE(WaitForClipboardContentTypesRefresh());

  EXPECT_TRUE(
      VerifyCacheClipboardContentTypeExists(ClipboardContentType::Text));
  EXPECT_FALSE(
      VerifyCacheClipboardContentTypeExists(ClipboardContentType::Image));
  EXPECT_FALSE(
      VerifyCacheClipboardContentTypeExists(ClipboardContentType::URL));
}

// Checks that if the pasteboard is marked as having confidential data, it is
// not returned.
TEST_F(ClipboardRecentContentIOSTest, ConfidentialPasteboardText) {
  [[UIPasteboard generalPasteboard]
      setItems:@[ @{
        @"public.plain-text" : @"hunter2",
        @"org.nspasteboard.ConcealedType" : @"hunter2"
      } ]
       options:@{}];

  VerifyClipboardTypeExists(ClipboardContentType::Text, false);
}

// Checks that if the user suppresses content, no text will be returned,
// and if the text changes, the new text will be returned again.
TEST_F(ClipboardRecentContentIOSTest, SuppressedPasteboardContent) {
  SetPasteboardContent(kRecognizedURL);

  // Test that recent pasteboard data is provided.
  VerifyClipboardURLExists(kRecognizedURL);

  // Suppress the content of the pasteboard.
  clipboard_content_->SuppressClipboardContent();

  // Check that the pasteboard content is suppressed.
  VerifyClipboardTypeExists(ClipboardContentType::URL, false);

  // Create a new clipboard content to test persistence.
  ResetClipboardRecentContent(kAppSpecificScheme, base::Days(10));

  // Check that the pasteboard content is still suppressed.
  VerifyClipboardTypeExists(ClipboardContentType::URL, false);

  // Check that even if the device is restarted, pasteboard content is
  // still suppressed.
  SimulateDeviceRestart();
  VerifyClipboardTypeExists(ClipboardContentType::URL, false);

  // Check that if the pasteboard changes, the new content is not
  // suppressed anymore.
  SetPasteboardContent(kRecognizedURL2);
  VerifyClipboardURLExists(kRecognizedURL2);
}

// TODO(crbug.com/40275048): This test is flaky.
// Checks that if the user suppresses content, no image will be returned,
// and if the image changes, the new image will be returned again.
TEST_F(ClipboardRecentContentIOSTest, DISABLED_SuppressedPasteboardImage) {
  SetPasteboardImage(TestUIImage());

  // Test that recent pasteboard data is provided.
  VerifyClipboardTypeExists(ClipboardContentType::Image, true);

  // Suppress the content of the pasteboard.
  clipboard_content_->SuppressClipboardContent();

  // Check that the pasteboard content is suppressed.
  VerifyClipboardTypeExists(ClipboardContentType::Image, false);

  // Create a new clipboard content to test persistence.
  ResetClipboardRecentContent(kAppSpecificScheme, base::Days(10));

  // Check that the pasteboard content is still suppressed.
  VerifyClipboardTypeExists(ClipboardContentType::Image, false);

  // Check that even if the device is restarted, pasteboard content is
  // still suppressed.
  SimulateDeviceRestart();
  VerifyClipboardTypeExists(ClipboardContentType::Image, false);

  // Check that if the pasteboard changes, the new content is not
  // suppressed anymore.
  SetPasteboardImage(TestUIImage([UIColor greenColor]));
  VerifyClipboardTypeExists(ClipboardContentType::Image, true);
}

// TODO(crbug.com/40275048): This test is flaky.
// Checks that if user copies something other than a string we don't cache the
// string in pasteboard.
TEST_F(ClipboardRecentContentIOSTest,
       DISABLED_AddingNonStringRemovesCachedString) {
  SetPasteboardContent(kRecognizedURL);

  // Test that recent pasteboard data is provided as url.
  VerifyClipboardURLExists(kRecognizedURL);
  VerifyClipboardTypeExists(ClipboardContentType::Text, false);
  // Image pasteboard should be empty.
  VerifyClipboardTypeExists(ClipboardContentType::Image, false);

  // Overwrite pasteboard with an image.
  SetPasteboardImage(TestUIImage());

  // Url and text pasteboard should appear empty.
  VerifyClipboardTypeExists(ClipboardContentType::URL, false);
  VerifyClipboardTypeExists(ClipboardContentType::Text, false);
  // Image pasteboard should be full
  VerifyClipboardTypeExists(ClipboardContentType::Image, true);

  // Tests that if URL is added again, pasteboard provides it normally.
  SetPasteboardContent(kRecognizedURL);
  VerifyClipboardURLExists(kRecognizedURL);
  VerifyClipboardTypeExists(ClipboardContentType::Text, false);
  // Image pasteboard should be empty.
  VerifyClipboardTypeExists(ClipboardContentType::Image, false);
}