/*
 * Copyright (C) 2016 The Android Open Source Project
 *
 * 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.
 */

#include "androidfw/LoadedArsc.h"

#include "android-base/file.h"
#include "androidfw/ResourceUtils.h"

#include "TestHelpers.h"
#include "data/basic/R.h"
#include "data/libclient/R.h"
#include "data/overlayable/R.h"
#include "data/sparse/R.h"
#include "data/styles/R.h"
#include "data/system/R.h"

namespace app = com::android::app;
namespace basic = com::android::basic;
namespace libclient = com::android::libclient;
namespace overlayable = com::android::overlayable;
namespace sparse = com::android::sparse;

using ::android::base::ReadFileToString;
using ::testing::Eq;
using ::testing::Ge;
using ::testing::IsNull;
using ::testing::NotNull;
using ::testing::SizeIs;
using ::testing::StrEq;

using PolicyFlags = android::ResTable_overlayable_policy_header::PolicyFlags;

namespace android {

TEST(LoadedArscTest, LoadSinglePackageArsc) {
  std::string contents;
  ASSERT_TRUE(ReadFileFromZipToString(GetTestDataPath() + "/styles/styles.apk", "resources.arsc",
                                      &contents));

  auto loaded_arsc = LoadedArsc::Load(reinterpret_cast<const void*>(contents.data()),
                                                                    contents.length());
  ASSERT_THAT(loaded_arsc, NotNull());

  const LoadedPackage* package =
      loaded_arsc->GetPackageById(get_package_id(app::R::string::string_one));
  ASSERT_THAT(package, NotNull());
  EXPECT_THAT(package->GetPackageName(), StrEq("com.android.app"));
  EXPECT_THAT(package->GetPackageId(), Eq(0x7f));

  const uint8_t type_index = get_type_id(app::R::string::string_one) - 1;
  const uint16_t entry_index = get_entry_id(app::R::string::string_one);

  const TypeSpec* type_spec = package->GetTypeSpecByTypeIndex(type_index);
  ASSERT_THAT(type_spec, NotNull());
  ASSERT_THAT(type_spec->type_entries.size(), Ge(1u));

  auto type = type_spec->type_entries[0];
  ASSERT_TRUE(LoadedPackage::GetEntry(type.type, entry_index).has_value());
}

TEST(LoadedArscTest, LoadSharedLibrary) {
  std::string contents;
  ASSERT_TRUE(ReadFileFromZipToString(GetTestDataPath() + "/lib_one/lib_one.apk", "resources.arsc",
                                      &contents));

  std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(contents.data(),
                                                                   contents.length());
  ASSERT_THAT(loaded_arsc, NotNull());

  const auto& packages = loaded_arsc->GetPackages();
  ASSERT_THAT(packages, SizeIs(1u));
  EXPECT_TRUE(packages[0]->IsDynamic());
  EXPECT_THAT(packages[0]->GetPackageName(), StrEq("com.android.lib_one"));
  EXPECT_THAT(packages[0]->GetPackageId(), Eq(0));

  const auto& dynamic_pkg_map = packages[0]->GetDynamicPackageMap();

  // The library has no dependencies.
  ASSERT_TRUE(dynamic_pkg_map.empty());
}

TEST(LoadedArscTest, LoadAppLinkedAgainstSharedLibrary) {
  std::string contents;
  ASSERT_TRUE(ReadFileFromZipToString(GetTestDataPath() + "/libclient/libclient.apk",
                                      "resources.arsc", &contents));

  std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(contents.data(),
                                                                   contents.length());
  ASSERT_THAT(loaded_arsc, NotNull());

  const auto& packages = loaded_arsc->GetPackages();
  ASSERT_THAT(packages, SizeIs(1u));
  EXPECT_FALSE(packages[0]->IsDynamic());
  EXPECT_THAT(packages[0]->GetPackageName(), StrEq("com.android.libclient"));
  EXPECT_THAT(packages[0]->GetPackageId(), Eq(0x7f));

  const auto& dynamic_pkg_map = packages[0]->GetDynamicPackageMap();

  // The library has two dependencies.
  ASSERT_THAT(dynamic_pkg_map, SizeIs(2u));
  EXPECT_THAT(dynamic_pkg_map[0].package_name, StrEq("com.android.lib_one"));
  EXPECT_THAT(dynamic_pkg_map[0].package_id, Eq(0x02));

  EXPECT_THAT(dynamic_pkg_map[1].package_name, StrEq("com.android.lib_two"));
  EXPECT_THAT(dynamic_pkg_map[1].package_id, Eq(0x03));
}

TEST(LoadedArscTest, LoadAppAsSharedLibrary) {
  std::string contents;
  ASSERT_TRUE(ReadFileFromZipToString(GetTestDataPath() + "/appaslib/appaslib.apk",
                                      "resources.arsc", &contents));

  std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(contents.data(),
                                                                   contents.length(),
                                                                   nullptr /* loaded_idmap */,
                                                                   PROPERTY_DYNAMIC);
  ASSERT_THAT(loaded_arsc, NotNull());

  const auto& packages = loaded_arsc->GetPackages();
  ASSERT_THAT(packages, SizeIs(1u));
  EXPECT_TRUE(packages[0]->IsDynamic());
  EXPECT_THAT(packages[0]->GetPackageId(), Eq(0x7f));
}

TEST(LoadedArscTest, LoadFeatureSplit) {
  std::string contents;
  ASSERT_TRUE(ReadFileFromZipToString(GetTestDataPath() + "/feature/feature.apk", "resources.arsc",
                                      &contents));
  std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(contents.data(),
                                                                   contents.length());
  ASSERT_THAT(loaded_arsc, NotNull());

  const LoadedPackage* package =
      loaded_arsc->GetPackageById(get_package_id(basic::R::string::test3));
  ASSERT_THAT(package, NotNull());

  uint8_t type_index = get_type_id(basic::R::string::test3) - 1;
  uint8_t entry_index = get_entry_id(basic::R::string::test3);

  const TypeSpec* type_spec = package->GetTypeSpecByTypeIndex(type_index);
  ASSERT_THAT(type_spec, NotNull());
  ASSERT_THAT(type_spec->type_entries.size(), Ge(1u));

  auto type_name16 = package->GetTypeStringPool()->stringAt(type_spec->type_spec->id - 1);
  ASSERT_TRUE(type_name16.has_value());
  EXPECT_THAT(util::Utf16ToUtf8(*type_name16), StrEq("string"));

  ASSERT_TRUE(LoadedPackage::GetEntry(type_spec->type_entries[0].type, entry_index).has_value());
}

// AAPT(2) generates resource tables with chunks in a certain order. The rule is that
// a RES_TABLE_TYPE_TYPE with id `i` must always be preceded by a RES_TABLE_TYPE_SPEC_TYPE with
// id `i`. The RES_TABLE_TYPE_SPEC_TYPE does not need to be directly preceding, however.
//
// AAPT(2) generates something like:
//   RES_TABLE_TYPE_SPEC_TYPE id=1
//   RES_TABLE_TYPE_TYPE id=1
//   RES_TABLE_TYPE_SPEC_TYPE id=2
//   RES_TABLE_TYPE_TYPE id=2
//
// But the following is valid too:
//   RES_TABLE_TYPE_SPEC_TYPE id=1
//   RES_TABLE_TYPE_SPEC_TYPE id=2
//   RES_TABLE_TYPE_TYPE id=1
//   RES_TABLE_TYPE_TYPE id=2
//
TEST(LoadedArscTest, LoadOutOfOrderTypeSpecs) {
  std::string contents;
  ASSERT_TRUE(
      ReadFileFromZipToString(GetTestDataPath() + "/out_of_order_types/out_of_order_types.apk",
                              "resources.arsc", &contents));

  std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(contents.data(),
                                                                   contents.length());
  ASSERT_THAT(loaded_arsc, NotNull());

  ASSERT_THAT(loaded_arsc->GetPackages(), SizeIs(1u));
  const auto& package = loaded_arsc->GetPackages()[0];
  ASSERT_THAT(package, NotNull());

  const TypeSpec* type_spec = package->GetTypeSpecByTypeIndex(0);
  ASSERT_THAT(type_spec, NotNull());
  ASSERT_THAT(type_spec->type_entries.size(), Ge(1u));

  type_spec = package->GetTypeSpecByTypeIndex(1);
  ASSERT_THAT(type_spec, NotNull());
  ASSERT_THAT(type_spec->type_entries.size(), Ge(1u));
}

TEST(LoadedArscTest, LoadOverlayable) {
  std::string contents;
  ASSERT_TRUE(ReadFileFromZipToString(GetTestDataPath() + "/overlayable/overlayable.apk",
                                      "resources.arsc", &contents));

  std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(contents.data(),
                                                                   contents.length());

  ASSERT_THAT(loaded_arsc, NotNull());
  const LoadedPackage* package = loaded_arsc->GetPackageById(
      get_package_id(overlayable::R::string::not_overlayable));

  const OverlayableInfo* info = package->GetOverlayableInfo(
      overlayable::R::string::not_overlayable);
  ASSERT_THAT(info, IsNull());

  info = package->GetOverlayableInfo(overlayable::R::string::overlayable1);
  ASSERT_THAT(info, NotNull());
  EXPECT_THAT(info->name, Eq("OverlayableResources1"));
  EXPECT_THAT(info->actor, Eq("overlay://theme"));
  EXPECT_THAT(info->policy_flags, Eq(PolicyFlags::PUBLIC));

  info = package->GetOverlayableInfo(overlayable::R::string::overlayable2);
  ASSERT_THAT(info, NotNull());
  EXPECT_THAT(info->name, Eq("OverlayableResources1"));
  EXPECT_THAT(info->actor, Eq("overlay://theme"));
  EXPECT_THAT(info->policy_flags,
              Eq(PolicyFlags::SYSTEM_PARTITION
                 | PolicyFlags::PRODUCT_PARTITION));

  info = package->GetOverlayableInfo(overlayable::R::string::overlayable3);
  ASSERT_THAT(info, NotNull());
  EXPECT_THAT(info->name, Eq("OverlayableResources2"));
  EXPECT_THAT(info->actor, Eq("overlay://com.android.overlayable"));
  EXPECT_THAT(info->policy_flags,
              Eq(PolicyFlags::VENDOR_PARTITION
                 | PolicyFlags::PRODUCT_PARTITION));

  info = package->GetOverlayableInfo(overlayable::R::string::overlayable4);
  EXPECT_THAT(info->name, Eq("OverlayableResources1"));
  EXPECT_THAT(info->actor, Eq("overlay://theme"));
  ASSERT_THAT(info, NotNull());
  EXPECT_THAT(info->policy_flags, Eq(PolicyFlags::PUBLIC));
}

TEST(LoadedArscTest, ResourceIdentifierIterator) {
  std::string contents;
  ASSERT_TRUE(
      ReadFileFromZipToString(GetTestDataPath() + "/basic/basic.apk", "resources.arsc", &contents));

  std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(contents.data(),
                                                                   contents.length());
  ASSERT_NE(nullptr, loaded_arsc);

  const std::vector<std::unique_ptr<const LoadedPackage>>& packages = loaded_arsc->GetPackages();
  ASSERT_EQ(1u, packages.size());
  ASSERT_EQ(std::string("com.android.basic"), packages[0]->GetPackageName());

  const auto& loaded_package = packages[0];
  auto iter = loaded_package->begin();
  auto end = loaded_package->end();

  ASSERT_NE(end, iter);
  ASSERT_EQ(0x7f010000u, *iter++);
  ASSERT_EQ(0x7f010001u, *iter++);
  ASSERT_EQ(0x7f020000u, *iter++);
  ASSERT_EQ(0x7f020001u, *iter++);
  ASSERT_EQ(0x7f030000u, *iter++);
  ASSERT_EQ(0x7f030001u, *iter++);
  ASSERT_EQ(0x7f030002u, *iter++);  // note: string without default, excluded by aapt2 dump
  ASSERT_EQ(0x7f040000u, *iter++);
  ASSERT_EQ(0x7f040001u, *iter++);
  ASSERT_EQ(0x7f040002u, *iter++);
  ASSERT_EQ(0x7f040003u, *iter++);
  ASSERT_EQ(0x7f040004u, *iter++);
  ASSERT_EQ(0x7f040005u, *iter++);
  ASSERT_EQ(0x7f040006u, *iter++);
  ASSERT_EQ(0x7f040007u, *iter++);
  ASSERT_EQ(0x7f040008u, *iter++);
  ASSERT_EQ(0x7f040009u, *iter++);
  ASSERT_EQ(0x7f04000au, *iter++);
  ASSERT_EQ(0x7f04000bu, *iter++);
  ASSERT_EQ(0x7f04000cu, *iter++);
  ASSERT_EQ(0x7f04000du, *iter++);
  ASSERT_EQ(0x7f050000u, *iter++);
  ASSERT_EQ(0x7f050001u, *iter++);
  ASSERT_EQ(0x7f060000u, *iter++);
  ASSERT_EQ(0x7f070000u, *iter++);
  ASSERT_EQ(0x7f070001u, *iter++);
  ASSERT_EQ(0x7f070002u, *iter++);
  ASSERT_EQ(0x7f070003u, *iter++);
  ASSERT_EQ(end, iter);
}

TEST(LoadedArscTest, GetOverlayableMap) {
  std::string contents;
  ASSERT_TRUE(ReadFileFromZipToString(GetTestDataPath() + "/overlayable/overlayable.apk",
                                      "resources.arsc", &contents));

  std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(contents.data(),
                                                                   contents.length());
  ASSERT_NE(nullptr, loaded_arsc);

  const std::vector<std::unique_ptr<const LoadedPackage>>& packages = loaded_arsc->GetPackages();
  ASSERT_EQ(1u, packages.size());
  ASSERT_EQ(std::string("com.android.overlayable"), packages[0]->GetPackageName());

  const auto map = packages[0]->GetOverlayableMap();
  ASSERT_EQ(3, map.size());
  ASSERT_EQ(map.at("OverlayableResources1"), "overlay://theme");
  ASSERT_EQ(map.at("OverlayableResources2"), "overlay://com.android.overlayable");
  ASSERT_EQ(map.at("OverlayableResources3"), "");
}

TEST(LoadedArscTest, LoadCustomLoader) {
  auto asset = AssetsProvider::CreateAssetFromFile(GetTestDataPath() + "/loader/resources.arsc");
  ASSERT_THAT(asset, NotNull());

  const StringPiece data(
      reinterpret_cast<const char*>(asset->getBuffer(true /*wordAligned*/)),
      asset->getLength());

  std::unique_ptr<const LoadedArsc> loaded_arsc =
      LoadedArsc::Load(data.data(), data.length(), nullptr, PROPERTY_LOADER);
  ASSERT_THAT(loaded_arsc, NotNull());

  const LoadedPackage* package =
      loaded_arsc->GetPackageById(get_package_id(overlayable::R::string::overlayable11));
  ASSERT_THAT(package, NotNull());
  EXPECT_THAT(package->GetPackageName(), StrEq("com.android.loader"));
  EXPECT_THAT(package->GetPackageId(), Eq(0x7f));

  const uint8_t type_index = get_type_id(overlayable::R::string::overlayable11) - 1;
  const uint16_t entry_index = get_entry_id(overlayable::R::string::overlayable11);

  const TypeSpec* type_spec = package->GetTypeSpecByTypeIndex(type_index);
  ASSERT_THAT(type_spec, NotNull());
  ASSERT_THAT(type_spec->type_entries.size(), Ge(1u));

  auto type = type_spec->type_entries[0];
  ASSERT_TRUE(LoadedPackage::GetEntry(type.type, entry_index).has_value());
}

// structs with size fields (like Res_value, ResTable_entry) should be
// backwards and forwards compatible (aka checking the size field against
// sizeof(Res_value) might not be backwards compatible.
// TEST(LoadedArscTest, LoadingShouldBeForwardsAndBackwardsCompatible) { ASSERT_TRUE(false); }

class LoadedArscParameterizedTest :
    public testing::TestWithParam<std::string> {
};

TEST_P(LoadedArscParameterizedTest, LoadSparseEntryApp) {
  std::string contents;
  ASSERT_TRUE(ReadFileFromZipToString(GetParam(), "resources.arsc", &contents));

  std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(contents.data(),
                                                                   contents.length());
  ASSERT_THAT(loaded_arsc, NotNull());

  const LoadedPackage* package =
      loaded_arsc->GetPackageById(get_package_id(sparse::R::integer::foo_9));
  ASSERT_THAT(package, NotNull());

  const uint8_t type_index = get_type_id(sparse::R::integer::foo_9) - 1;
  const uint16_t entry_index = get_entry_id(sparse::R::integer::foo_9);

  const TypeSpec* type_spec = package->GetTypeSpecByTypeIndex(type_index);
  ASSERT_THAT(type_spec, NotNull());
  ASSERT_THAT(type_spec->type_entries.size(), Ge(1u));

  auto type = type_spec->type_entries[0];
  ASSERT_TRUE(LoadedPackage::GetEntry(type.type, entry_index).has_value());
}

TEST_P(LoadedArscParameterizedTest, FindSparseEntryApp) {
  std::string contents;
  ASSERT_TRUE(ReadFileFromZipToString(GetParam(), "resources.arsc", &contents));

  std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(contents.data(),
                                                                   contents.length());
  ASSERT_THAT(loaded_arsc, NotNull());

  const LoadedPackage* package =
      loaded_arsc->GetPackageById(get_package_id(sparse::R::string::only_land));
  ASSERT_THAT(package, NotNull());

  const uint8_t type_index = get_type_id(sparse::R::string::only_land) - 1;

  const TypeSpec* type_spec = package->GetTypeSpecByTypeIndex(type_index);
  ASSERT_THAT(type_spec, NotNull());
  ASSERT_THAT(type_spec->type_entries.size(), Ge(1u));

  // Type Entry with default orientation is not sparse encoded because the ratio of
  // populated entries to total entries is above threshold.
  // Only find out default locale because Soong build system will introduce pseudo
  // locales for the apk generated at runtime.
  auto type_entry_default = std::find_if(
    type_spec->type_entries.begin(), type_spec->type_entries.end(),
    [] (const TypeSpec::TypeEntry& x) { return x.config.orientation == 0 &&
                                               x.config.locale == 0; });
  ASSERT_NE(type_entry_default, type_spec->type_entries.end());
  ASSERT_EQ(type_entry_default->type->flags & ResTable_type::FLAG_SPARSE, 0);

  // Type Entry with land orientation is sparse encoded as expected.
  // Only find out default locale because Soong build system will introduce pseudo
  // locales for the apk generated at runtime.
  auto type_entry_land = std::find_if(
    type_spec->type_entries.begin(), type_spec->type_entries.end(),
    [](const TypeSpec::TypeEntry& x) { return x.config.orientation ==
                                              ResTable_config::ORIENTATION_LAND &&
                                              x.config.locale == 0; });
  ASSERT_NE(type_entry_land, type_spec->type_entries.end());
  ASSERT_NE(type_entry_land->type->flags & ResTable_type::FLAG_SPARSE, 0);

  // Test fetching a resource with only sparsely encoded configs by name.
  auto id = package->FindEntryByName(u"string", u"only_land");
  ASSERT_EQ(id.value(), fix_package_id(sparse::R::string::only_land, 0));
}

INSTANTIATE_TEST_SUITE_P(
        FrameWorkResourcesLoadedArscTests,
        LoadedArscParameterizedTest,
        ::testing::Values(
          base::GetExecutableDirectory() + "/tests/data/sparse/sparse.apk",
          base::GetExecutableDirectory() + "/FrameworkResourcesSparseTestApp.apk"
        ));

}  // namespace android