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

#include "chrome/browser/ash/fileapi/diversion_file_manager.h"

#include "base/files/file_util.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/test/browser_task_environment.h"
#include "net/base/io_buffer.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace ash {

using FinishDivertingResult = DiversionFileManager::FinishDivertingResult;
using StartDivertingResult = DiversionFileManager::StartDivertingResult;
using StoppedReason = DiversionFileManager::StoppedReason;

namespace {

DiversionFileManager::Callback IncrementCounterCallback(
    StoppedReason expected_stopped_reason,
    const storage::FileSystemURL& expected_url,
    int* counter,
    int delta) {
  return base::BindOnce(
      [](StoppedReason expected_stopped_reason,
         const storage::FileSystemURL& expected_url, int* counter, int delta,
         StoppedReason stopped_reason, const storage::FileSystemURL& url,
         base::ScopedFD scoped_fd, int64_t file_size, base::File::Error error) {
        EXPECT_EQ(expected_stopped_reason, stopped_reason);
        EXPECT_EQ(expected_url, url);
        *counter += delta;
      },
      expected_stopped_reason, expected_url, counter, delta);
}

}  // namespace

class DiversionFileManagerTest : public testing::Test {
 public:
  DiversionFileManagerTest()
      : task_environment_(base::test::TaskEnvironment::MainThreadType::IO,
                          base::test::TaskEnvironment::TimeSource::MOCK_TIME) {}

 protected:
  void SynchronousWrite(storage::FileStreamWriter& writer, std::string s) {
    scoped_refptr<net::StringIOBuffer> buffer =
        base::MakeRefCounted<net::StringIOBuffer>(s);
    writer.Write(
        buffer.get(), buffer->size(),
        base::BindOnce([](base::RepeatingClosure quit_closure,
                          int byte_count_or_error_code) { quit_closure.Run(); },
                       task_environment_.QuitClosure()));
    task_environment_.RunUntilQuit();
  }

  content::BrowserTaskEnvironment task_environment_;
};

TEST_F(DiversionFileManagerTest, ImplicitExplicitFinish) {
  ASSERT_TRUE(
      ::content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));

  scoped_refptr<DiversionFileManager> dfm =
      base::MakeRefCounted<DiversionFileManager>();
  storage::FileSystemURL bar_url = storage::FileSystemURL::CreateForTest(
      GURL("filesystem:chrome-extension://abc/external/p/q/bar"));
  storage::FileSystemURL foo_url = storage::FileSystemURL::CreateForTest(
      GURL("filesystem:chrome-extension://abc/external/p/q/foo"));
  EXPECT_FALSE(dfm->IsDiverting(bar_url));
  EXPECT_FALSE(dfm->IsDiverting(foo_url));

  int bar_counter = 0;
  int foo_counter = 0;

  ASSERT_EQ(
      StartDivertingResult::kOK,
      dfm->StartDiverting(bar_url, base::Seconds(28),
                          IncrementCounterCallback(StoppedReason::kImplicitIdle,
                                                   bar_url, &bar_counter, 1)));
  ASSERT_EQ(
      StartDivertingResult::kOK,
      dfm->StartDiverting(foo_url, base::Seconds(32),
                          IncrementCounterCallback(StoppedReason::kImplicitIdle,
                                                   foo_url, &foo_counter, 10)));
  EXPECT_TRUE(dfm->IsDiverting(bar_url));
  EXPECT_TRUE(dfm->IsDiverting(foo_url));

  task_environment_.FastForwardBy(base::Seconds(30));
  EXPECT_FALSE(dfm->IsDiverting(bar_url));
  EXPECT_TRUE(dfm->IsDiverting(foo_url));

  ASSERT_EQ(FinishDivertingResult::kWasNotDiverting,
            dfm->FinishDiverting(bar_url, IncrementCounterCallback(
                                              StoppedReason::kExplicitFinish,
                                              bar_url, &bar_counter, 100)));
  ASSERT_EQ(FinishDivertingResult::kOK,
            dfm->FinishDiverting(foo_url, IncrementCounterCallback(
                                              StoppedReason::kExplicitFinish,
                                              foo_url, &foo_counter, 1000)));
  EXPECT_FALSE(dfm->IsDiverting(bar_url));
  EXPECT_FALSE(dfm->IsDiverting(foo_url));

  EXPECT_EQ(bar_counter, 1);
  EXPECT_EQ(foo_counter, 1000);
}

TEST_F(DiversionFileManagerTest, ReaderKeepsDiversionAlive) {
  ASSERT_TRUE(
      ::content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));

  scoped_refptr<DiversionFileManager> dfm =
      base::MakeRefCounted<DiversionFileManager>();
  storage::FileSystemURL foo_url = storage::FileSystemURL::CreateForTest(
      GURL("filesystem:chrome-extension://abc/external/p/q/foo"));

  int foo_counter = 0;

  ASSERT_EQ(
      StartDivertingResult::kOK,
      dfm->StartDiverting(foo_url, base::Seconds(15),
                          IncrementCounterCallback(StoppedReason::kImplicitIdle,
                                                   foo_url, &foo_counter, 1)));

  task_environment_.FastForwardBy(base::Seconds(10));
  EXPECT_TRUE(dfm->IsDiverting(foo_url));

  std::unique_ptr<storage::FileStreamReader> reader =
      dfm->CreateDivertedFileStreamReader(foo_url, 0);

  task_environment_.FastForwardBy(base::Seconds(10));
  EXPECT_TRUE(dfm->IsDiverting(foo_url));
  EXPECT_EQ(foo_counter, 0);

  task_environment_.FastForwardBy(base::Seconds(10));
  EXPECT_TRUE(dfm->IsDiverting(foo_url));
  EXPECT_EQ(foo_counter, 0);

  reader.reset();

  task_environment_.FastForwardBy(base::Seconds(10));
  EXPECT_TRUE(dfm->IsDiverting(foo_url));
  EXPECT_EQ(foo_counter, 0);

  task_environment_.FastForwardBy(base::Seconds(10));
  EXPECT_FALSE(dfm->IsDiverting(foo_url));
  EXPECT_EQ(foo_counter, 1);
}

TEST_F(DiversionFileManagerTest, Writes) {
  ASSERT_TRUE(
      ::content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));

  scoped_refptr<DiversionFileManager> dfm =
      base::MakeRefCounted<DiversionFileManager>();
  storage::FileSystemURL foo_url = storage::FileSystemURL::CreateForTest(
      GURL("filesystem:chrome-extension://abc/external/p/q/foo"));

  base::FilePath temp_dir;
  ASSERT_TRUE(base::GetTempDir(&temp_dir));
  dfm->OverrideTmpfileDirForTesting(temp_dir);

  static constexpr auto on_implicit_idle =
      [](StoppedReason stopped_reason, const storage::FileSystemURL& url,
         base::ScopedFD scoped_fd, int64_t file_size, base::File::Error error) {
        // We shouldn't get here. We should get to on_explicit_finish instead.
        NOTREACHED();
      };
  ASSERT_EQ(StartDivertingResult::kOK,
            dfm->StartDiverting(foo_url, base::Seconds(15),
                                base::BindOnce(on_implicit_idle)));

  dfm->TruncateDivertedFile(foo_url, 0,
                            base::BindOnce([](base::File::Error result) {
                              EXPECT_EQ(base::File::FILE_OK, result);
                            }));

  std::unique_ptr<storage::FileStreamWriter> writer =
      dfm->CreateDivertedFileStreamWriter(foo_url, 0);

  SynchronousWrite(*writer, "hi ");
  dfm->GetDivertedFileInfo(
      foo_url, {storage::FileSystemOperation::GetMetadataField::kSize},
      base::BindOnce(
          [](base::File::Error result, const base::File::Info& file_info) {
            EXPECT_EQ(base::File::FILE_OK, result);
            EXPECT_EQ(3, file_info.size);
          }));

  task_environment_.FastForwardBy(base::Seconds(20));
  EXPECT_TRUE(dfm->IsDiverting(foo_url));

  SynchronousWrite(*writer, "there.");
  dfm->GetDivertedFileInfo(
      foo_url, {storage::FileSystemOperation::GetMetadataField::kSize},
      base::BindOnce(
          [](base::File::Error result, const base::File::Info& file_info) {
            EXPECT_EQ(base::File::FILE_OK, result);
            EXPECT_EQ(9, file_info.size);
          }));

  task_environment_.FastForwardBy(base::Seconds(20));
  EXPECT_TRUE(dfm->IsDiverting(foo_url));

  bool on_explicit_finish_called = false;
  static constexpr auto on_explicit_finish =
      [](bool* called, StoppedReason stopped_reason,
         const storage::FileSystemURL& url, base::ScopedFD scoped_fd,
         int64_t file_size, base::File::Error error) {
        ASSERT_TRUE(scoped_fd.is_valid());
        EXPECT_EQ(file_size, 9u);
        EXPECT_EQ(base::File::FILE_OK, error);
        char buf[9] = {0};
        EXPECT_TRUE(base::ReadFromFD(scoped_fd.get(), buf));
        EXPECT_EQ(buf, base::span_from_cstring("hi there."));
        *called = true;
      };
  ASSERT_EQ(FinishDivertingResult::kOK,
            dfm->FinishDiverting(foo_url,
                                 base::BindOnce(on_explicit_finish,
                                                &on_explicit_finish_called)));

  task_environment_.FastForwardBy(base::Seconds(20));
  EXPECT_FALSE(dfm->IsDiverting(foo_url));
  EXPECT_FALSE(on_explicit_finish_called);

  writer.reset();
  EXPECT_FALSE(dfm->IsDiverting(foo_url));
  EXPECT_TRUE(on_explicit_finish_called);
}

}  // namespace ash