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

package build

import (
	"bytes"
	"crypto/rand"
	"encoding/binary"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"os"
	"path/filepath"
	"sort"
	"strings"
	"testing"

	"github.com/google/go-cmp/cmp"

	far "go.fuchsia.dev/fuchsia/src/sys/pkg/lib/far/go"
	"go.fuchsia.dev/fuchsia/src/sys/pkg/lib/merkle"
	"go.fuchsia.dev/fuchsia/src/testing/host-target-testing/pkg"
)

// Verifies package manifests can be properly loaded.
func TestLoadPackageManifest(t *testing.T) {
	testCases := []struct {
		name               string
		buildDirContents   map[string]string
		manifestPathToLoad string
		expectedManifest   PackageManifest
		wantError          bool
	}{
		{
			name: "success valid path, blobs, and subpackages",
			buildDirContents: map[string]string{
				"package_manifest.json": `{
					"version": "1",
					"blobs": [
						{ "merkle": "0000000000000000000000000000000000000000000000000000000000000000" }
					],
					"subpackages": [
						{
							"name": "some_subpackage",
							"merkle": "1111111111111111111111111111111111111111111111111111111111111111",
							"manifest_path": "subpackage_manifest.json"
						}
					]
				}`,
			},
			manifestPathToLoad: "package_manifest.json",
			expectedManifest: PackageManifest{
				Version: "1",
				Blobs: []PackageBlobInfo{
					{Merkle: MustDecodeMerkleRoot("0000000000000000000000000000000000000000000000000000000000000000")},
				},
				Subpackages: []PackageSubpackageInfo{
					{
						Name:         "some_subpackage",
						Merkle:       MustDecodeMerkleRoot("1111111111111111111111111111111111111111111111111111111111111111"),
						ManifestPath: "subpackage_manifest.json",
					},
				},
			},
		},
		{
			name: "failure incompatible version",
			buildDirContents: map[string]string{
				"package_manifest.json": `{
					"version": "2",
				}`,
			},
			manifestPathToLoad: "package_manifest.json",
			wantError:          true,
		},
		{
			name: "failure json improperly formatted",
			buildDirContents: map[string]string{
				"package_manifest.json": `{
					Oops. This is not valid json.
				}`,
			},
			manifestPathToLoad: "package_manifest.json",
			wantError:          true,
		}, {
			name:               "failure package manifest does not exist",
			manifestPathToLoad: "non_existent_manifest.json",
			wantError:          true,
		},
	}
	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			// Generate test env based on input.
			tempDirPath := createBuildDir(t, tc.buildDirContents)

			// Now that we're set up, we can actually load the package manifest.
			actualManifest, err := LoadPackageManifest(filepath.Join(tempDirPath, tc.manifestPathToLoad))

			// Ensure the results match the expectations.
			if (err == nil) == tc.wantError {
				t.Fatalf("got error [%v], want error? %t", err, tc.wantError)
			}
			if diff := cmp.Diff(actualManifest, &tc.expectedManifest); err == nil && diff != "" {
				t.Fatalf("got manifest %#v, expected %#v", actualManifest, tc.expectedManifest)
			}
		})
	}
}

func createBuildDir(t *testing.T, files map[string]string) string {
	dir := t.TempDir()
	for filename, data := range files {
		if err := os.MkdirAll(filepath.Join(dir, filepath.Dir(filename)), 0o700); err != nil {
			t.Fatal(err)
		}
		if err := os.WriteFile(filepath.Join(dir, filename), []byte(data), 0o600); err != nil {
			t.Fatal(err)
		}
	}
	return dir
}

func TestInit(t *testing.T) {
	cfg := TestConfig()
	defer os.RemoveAll(filepath.Dir(cfg.TempDir))

	if err := Init(cfg); err != nil {
		t.Fatal(err)
	}

	f, err := os.Open(filepath.Join(cfg.OutputDir, "meta", "package"))
	if err != nil {
		t.Fatal(err)
	}
	var p pkg.Package
	if err := json.NewDecoder(f).Decode(&p); err != nil {
		t.Fatal(err)
	}
	f.Close()

	if want := cfg.PkgName; p.Name != want {
		t.Errorf("got %q, want %q", p.Name, want)
	}

	if want := "0"; p.Version != want {
		t.Errorf("got %q, want %q", p.Version, want)
	}
	os.RemoveAll(filepath.Dir(cfg.TempDir))

	// test condition where package name is empty, name should match the
	// name of the output directory
	cfg.PkgName = ""
	if err = Init(cfg); err != nil {
		t.Fatal(err)
	}

	f, err = os.Open(filepath.Join(cfg.OutputDir, "meta", "package"))
	if err != nil {
		t.Fatal(err)
	}

	if err = json.NewDecoder(f).Decode(&p); err != nil {
		t.Fatal(err)
	}
	f.Close()

	if want := filepath.Base(cfg.OutputDir); p.Name != want {
		t.Errorf("got %q, want %q", p.Name, want)
	}
}

func TestUpdate(t *testing.T) {
	cfg := TestConfig()
	defer os.RemoveAll(filepath.Dir(cfg.TempDir))

	cfg.PkgABIRevision = TestABIRevision

	TestPackage(cfg)

	manifest, err := cfg.Manifest()
	if err != nil {
		t.Fatal(err)
	}

	for _, f := range manifest.Content() {
		fd, err := os.Create(f)
		if err != nil {
			t.Fatal(err)
		}
		if _, err := io.CopyN(fd, rand.Reader, 1024); err != nil {
			t.Fatal(err)
		}
		fd.Close()
	}

	if _, ok := manifest.Meta()["meta/contents"]; ok {
		t.Fatalf("unexpected pre-existing meta/contents in manifest")
	}

	if err := Update(cfg); err != nil {
		t.Fatal(err)
	}

	if _, ok := manifest.Meta()[abiRevisionKey]; !ok {
		t.Fatalf("%s was not found in manifest after update", abiRevisionKey)
	}

	contentsPath, ok := manifest.Meta()["meta/contents"]
	if !ok {
		t.Fatalf("meta/contents was not found in manifest after update")
	}

	f, err := os.Open(contentsPath)
	if err != nil {
		t.Fatal(err)
	}
	buf, err := io.ReadAll(f)
	f.Close()
	if err != nil {
		t.Fatal(err)
	}

	lines := strings.Split(string(buf), "\n")
	sort.Strings(lines)
	if lines[0] == "" {
		lines = lines[1:]
	}

	contentFiles := []string{}
	for _, s := range TestFiles {
		if strings.HasPrefix(s, "meta/") {
			continue
		}
		contentFiles = append(contentFiles, s)
	}
	if len(lines) != len(contentFiles) {
		t.Fatalf("content lines mismatch: %v\n%v", lines, contentFiles)
	}

	files := []string{}
	files = append(files, contentFiles...)
	sort.Strings(files)
	for i, pf := range files {
		var tree merkle.Tree
		f, err := os.Open(manifest.Paths[pf])
		if err != nil {
			t.Fatal(err)
		}
		if _, err := tree.ReadFrom(f); err != nil {
			t.Fatal(err)
		}
		f.Close()
		want := fmt.Sprintf("%s=%x", pf, tree.Root())
		if lines[i] != want {
			t.Errorf("contents mismatch: got %q, want %q", lines[i], want)
			break
		}
	}
}

func TestUpdateTakesABIRevisionAndWritesABIRevision(t *testing.T) {
	cfg := TestConfig()
	defer os.RemoveAll(filepath.Dir(cfg.TempDir))

	TestPackage(cfg)

	manifest, err := cfg.Manifest()
	if err != nil {
		t.Fatal(err)
	}

	if err := Update(cfg); err != nil {
		t.Fatal(err)
	}

	// FIXME(https://fxbug.dev/42168416): In order to ease migration, initially the
	// abi-revision is not required.
	abiRevisionPath, ok := manifest.Meta()[abiRevisionKey]
	if !ok {
		t.Fatalf("%s was not found in manifest after update", abiRevisionKey)
	}

	f, err := os.Open(abiRevisionPath)
	if err != nil {
		t.Fatal(err)
	}
	defer f.Close()

	var abiRevision uint64
	if err := binary.Read(f, binary.LittleEndian, &abiRevision); err != nil {
		t.Fatal(err)
	}
	if abiRevision != TestABIRevision {
		t.Fatalf("expected ABI revision to be %x, not %x", TestABIRevision, abiRevision)
	}
}

func TestUpdateDoesNotRequireABIRevision(t *testing.T) {
	cfg := TestConfig()
	defer os.RemoveAll(filepath.Dir(cfg.TempDir))

	cfg.PkgABIRevision = 0

	TestPackage(cfg)

	if err := Update(cfg); err != nil {
		t.Fatalf("expected update to not fail because ABI revision was not specified")
	}
}

func TestUpdateReadsABIRevisionFromDirectory(t *testing.T) {
	cfg := TestConfig()
	defer os.RemoveAll(filepath.Dir(cfg.TempDir))

	cfg.PkgABIRevision = 0

	TestPackage(cfg)
	addTestABIRevisionToManifest(cfg, TestABIRevision)

	if err := Update(cfg); err != nil {
		t.Fatalf("expected update to read ABI revision from file: %v", err)
	}

	abiOutputPath := filepath.Join(cfg.OutputDir, "meta", "fuchsia.pkg", "abi-revision")
	if _, err := os.Stat(abiOutputPath); err == nil {
		t.Fatalf("should not have created abi revision file: %s", abiOutputPath)
	}

}

func TestUpdateRequiresManifestABIRevisionToMatchCliABIRevision(t *testing.T) {
	cfg := TestConfig()
	defer os.RemoveAll(filepath.Dir(cfg.TempDir))

	TestPackage(cfg)
	addTestABIRevisionToManifest(cfg, TestABIRevision2)

	if err := Update(cfg); err == nil {
		t.Fatalf("expected update to fail because manifest ABI revision conflicted with CLI ABI revision")
	}

	cfg.PkgABIRevision = TestABIRevision2

	if err := Update(cfg); err != nil {
		t.Fatalf("expected update to read ABI revision from file: %v", err)
	}

	abiOutputPath := filepath.Join(cfg.OutputDir, "meta", "fuchsia.pkg", "abi-revision")
	if _, err := os.Stat(abiOutputPath); err == nil {
		t.Fatalf("should not have created abi revision file: %s", abiOutputPath)
	}
}

func TestValidate(t *testing.T) {
	cfg := TestConfig()
	defer os.RemoveAll(filepath.Dir(cfg.TempDir))

	TestPackage(cfg)

	if err := Update(cfg); err != nil {
		t.Fatal(err)
	}

	err := Validate(cfg)
	if err != nil {
		t.Fatalf("Unexpected validation error")
	}

	manifest, err := cfg.Manifest()
	if err != nil {
		t.Fatal(err)
	}

	for _, f := range RequiredFiles {
		manifest.Paths[f+"a"] = manifest.Paths[f]
		delete(manifest.Paths, f)
		if err := Validate(cfg); err == nil {
			t.Errorf("expected a validation error when %q is missing", f)
		}
		manifest.Paths[f] = manifest.Paths[f+"a"]
		delete(manifest.Paths, f+"a")
	}
}

func TestSeal(t *testing.T) {
	cfg := TestConfig()
	defer os.RemoveAll(filepath.Dir(cfg.TempDir))

	TestPackage(cfg)

	if err := Update(cfg); err != nil {
		t.Fatal(err)
	}

	if _, err := Seal(cfg); err != nil {
		t.Fatal(err)
	}

	// TODO(raggi): until we have far reader support this test only verifies that
	// the package meta data was correctly updated, it doesn't actually verify
	// that the contents of the far are correct.
	metafar := filepath.Join(cfg.OutputDir, "meta.far")
	f, err := os.Open(metafar)
	if err != nil {
		t.Fatal(err)
	}

	r, err := far.NewReader(f)
	if err != nil {
		t.Fatal(err)
	}

	abiBytes, err := r.ReadFile(abiRevisionKey)
	if err != nil {
		t.Fatal(err)
	}

	var abiRevision uint64
	if err := binary.Read(bytes.NewReader(abiBytes), binary.LittleEndian, &abiRevision); err != nil {
		t.Fatal(err)
	}
	if abiRevision != TestABIRevision {
		t.Fatalf("expected ABI revision to be %x, not %x", TestABIRevision, abiRevision)
	}
}

func TestSealDoesNotRequireABIRevision(t *testing.T) {
	cfg := TestConfig()
	defer os.RemoveAll(filepath.Dir(cfg.TempDir))

	TestPackage(cfg)

	if err := Update(cfg); err != nil {
		t.Fatal(err)
	}

	cfg.PkgABIRevision = 0

	if _, err := Seal(cfg); err != nil {
		t.Fatal(err)
	}

	// This test only verifies that the package meta data was correctly
	// updated, it doesn't actually verify that the contents of the far are
	// correct.
	metafar := filepath.Join(cfg.OutputDir, "meta.far")
	f, err := os.Open(metafar)
	if err != nil {
		t.Fatal(err)
	}

	r, err := far.NewReader(f)
	if err != nil {
		t.Fatal(err)
	}

	// FIXME(https://fxbug.dev/42168416): In order to ease migration, initially the
	// abi-revision is not required.
	_, err = r.Open("meta/fuchsia.pkg/abi-revision")
	if err == nil {
		t.Fatalf("expected meta/fuchsia.pkg/abi-revision to not be present in meta.far")
	}
	if !errors.Is(err, os.ErrNotExist) {
		t.Fatalf("expected error to be does not exist, not %s", err)
	}
}

func TestSealReadsABIRevisionFromDirectory(t *testing.T) {
	cfg := TestConfig()
	defer os.RemoveAll(filepath.Dir(cfg.TempDir))

	cfg.PkgABIRevision = 0

	TestPackage(cfg)
	addTestABIRevisionToManifest(cfg, TestABIRevision)

	if err := Update(cfg); err != nil {
		t.Fatalf("expected update to read ABI revision from file: %v", err)
	}

	if _, err := Seal(cfg); err != nil {
		t.Fatal(err)
	}

	// This test only verifies that the package meta data was correctly
	// updated, it doesn't actually verify that the contents of the far are
	// correct.
	metafar := filepath.Join(cfg.OutputDir, "meta.far")
	f, err := os.Open(metafar)
	if err != nil {
		t.Fatal(err)
	}

	r, err := far.NewReader(f)
	if err != nil {
		t.Fatal(err)
	}

	abiBytes, err := r.ReadFile(abiRevisionKey)
	if err != nil {
		t.Fatal(err)
	}

	var abiRevision uint64
	if err := binary.Read(bytes.NewReader(abiBytes), binary.LittleEndian, &abiRevision); err != nil {
		t.Fatal(err)
	}
	if abiRevision != TestABIRevision {
		t.Fatalf("expected ABI revision to be %x, not %x", TestABIRevision, abiRevision)
	}
}

func TestSealValidatesInvalidPackageRepository(t *testing.T) {
	defer func() {
		if r := recover(); r == nil {
			t.Fatalf("Expected to fail on invalid repository")
		}
	}()

	cfg := TestConfig()
	defer os.RemoveAll(filepath.Dir(cfg.TempDir))
	cfg.PkgRepository = "x,y"
	BuildTestPackage(cfg)

	if _, err := Seal(cfg); err == nil {
		t.Fatalf("Expected invalid package repository to generate error.")
	}
}