// Copyright 2015 The Vanadium 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 main_test

import (
	"bytes"
	"fmt"
	"io/ioutil"
	"net/http"
	"os"
	"os/exec"
	"path/filepath"
	"regexp"
	"strings"
	"testing"

	"v.io/v23/naming"
	"v.io/x/ref/lib/v23test"
	"v.io/x/ref/test/testutil"
)

func checkFileType(t *testing.T, infoFile, typeString string) {
	var catOut bytes.Buffer
	catCmd := exec.Command("cat", infoFile)
	catCmd.Stdout = &catOut
	catCmd.Stderr = &catOut
	if err := catCmd.Run(); err != nil {
		t.Fatalf("%q failed: %v\n%v", strings.Join(catCmd.Args, " "), err, catOut.String())
	}
	if got, want := strings.TrimSpace(catOut.String()), typeString; got != want {
		t.Fatalf("unexpect file type: got %v, want %v", got, want)
	}
}

func readFileOrDie(t *testing.T, path string) []byte {
	result, err := ioutil.ReadFile(path)
	if err != nil {
		t.Fatalf("ReadFile(%q) failed: %v", path, err)
	}
	return result
}

func compareFiles(t *testing.T, f1, f2 string) {
	if !bytes.Equal(readFileOrDie(t, f1), readFileOrDie(t, f2)) {
		t.Fatalf("the contents of %s and %s differ when they should not", f1, f2)
	}
}

func deleteFile(t *testing.T, sh *v23test.Shell, creds *v23test.Credentials, bin, name, suffix string) {
	args := []string{"delete", naming.Join(name, suffix)}
	sh.Cmd(bin, args...).WithCredentials(creds).Run()
}

func downloadAndInstall(t *testing.T, sh *v23test.Shell, creds *v23test.Credentials, bin, name, path, suffix string) {
	args := []string{"download", naming.Join(name, suffix), path}
	sh.Cmd(bin, args...).WithCredentials(creds).Run()
}

func downloadFile(t *testing.T, sh *v23test.Shell, creds *v23test.Credentials, bin, name, path, suffix string) (string, string) {
	args := []string{"download", "--install=false", naming.Join(name, suffix), path}
	stdout := sh.Cmd(bin, args...).WithCredentials(creds).Stdout()
	match := regexp.MustCompile(`Binary downloaded to (.+) \(media info (.+)\)`).FindStringSubmatch(stdout)
	if len(match) != 3 {
		t.Fatalf("Failed to match download stdout: %s", stdout)
	}
	return match[1], match[2]
}

func downloadFileExpectError(t *testing.T, sh *v23test.Shell, creds *v23test.Credentials, bin, name, path, suffix string) {
	args := []string{"download", naming.Join(name, suffix), path}
	cmd := sh.Cmd(bin, args...).WithCredentials(creds)
	cmd.ExitErrorIsOk = true
	if cmd.Run(); cmd.Err == nil {
		t.Fatalf("%s %v: did not fail when it should", bin, args)
	}
}

func downloadURL(t *testing.T, path, rootURL, suffix string) {
	url := fmt.Sprintf("http://%v/%v", rootURL, suffix)
	resp, err := http.Get(url)
	if err != nil {
		t.Fatalf("Get(%q) failed: %v", url, err)
	}
	output, err := ioutil.ReadAll(resp.Body)
	resp.Body.Close()
	if err != nil {
		t.Fatalf("ReadAll() failed: %v", err)
	}
	if err = ioutil.WriteFile(path, output, 0600); err != nil {
		t.Fatalf("WriteFile() failed: %v", err)
	}
}

func rootURL(t *testing.T, sh *v23test.Shell, creds *v23test.Credentials, bin, name string) string {
	args := []string{"url", name}
	stdout := sh.Cmd(bin, args...).WithCredentials(creds).Stdout()
	return strings.TrimSpace(stdout)
}

func uploadFile(t *testing.T, sh *v23test.Shell, creds *v23test.Credentials, bin, name, path, suffix string) {
	args := []string{"upload", naming.Join(name, suffix), path}
	sh.Cmd(bin, args...).WithCredentials(creds).Run()
}

func TestV23BinaryRepositoryIntegration(t *testing.T) {
	v23test.SkipUnlessRunningIntegrationTests(t)
	sh := v23test.NewShell(t, v23test.Opts{})
	defer sh.Cleanup()
	sh.StartRootMountTable()

	testutil.InitRandGenerator(t.Logf)

	// Build the required binaries.
	// The client must run as a "delegate" of the server in order to pass
	// the default authorization checks on the server.
	var (
		binaryRepoBin   = sh.BuildGoPkg("v.io/x/ref/services/binary/binaryd")
		clientBin       = sh.BuildGoPkg("v.io/x/ref/services/binary/binary")
		binaryRepoCreds = sh.ForkCredentials("binaryd")
		clientCreds     = sh.ForkCredentials("binaryd:client")
	)

	// Start the build server.
	binaryRepoName := "test-binary-repository"
	sh.Cmd(binaryRepoBin,
		"-name="+binaryRepoName,
		"-http=127.0.0.1:0",
		"-v23.tcp.address=127.0.0.1:0").WithCredentials(binaryRepoCreds).Start()

	// Upload a random binary file.
	binFile := sh.MakeTempFile()
	if _, err := binFile.Write(testutil.RandomBytes(16 * 1000 * 1000)); err != nil {
		t.Fatalf("Write() failed: %v", err)
	}
	binSuffix := "test-binary"
	uploadFile(t, sh, clientCreds, clientBin, binaryRepoName, binFile.Name(), binSuffix)

	// Upload a compressed version of the binary file.
	tarFile := binFile.Name() + ".tar.gz"
	var tarOut bytes.Buffer
	tarCmd := exec.Command("tar", "zcvf", tarFile, binFile.Name())
	tarCmd.Stdout = &tarOut
	tarCmd.Stderr = &tarOut
	if err := tarCmd.Run(); err != nil {
		t.Fatalf("%q failed: %v\n%v", strings.Join(tarCmd.Args, " "), err, tarOut.String())
	}
	defer os.Remove(tarFile)
	tarSuffix := "test-compressed-file"
	uploadFile(t, sh, clientCreds, clientBin, binaryRepoName, tarFile, tarSuffix)

	// Download the binary file and check that it matches the
	// original one and that it has the right file type.
	downloadName := binFile.Name() + "-downloaded"
	downloadedFile, infoFile := downloadFile(t, sh, clientCreds, clientBin, binaryRepoName, downloadName, binSuffix)
	defer os.Remove(downloadedFile)
	defer os.Remove(infoFile)
	if downloadedFile != downloadName {
		t.Fatalf("expected %s, got %s", downloadName, downloadedFile)
	}
	compareFiles(t, binFile.Name(), downloadedFile)
	checkFileType(t, infoFile, `{"Type":"application/octet-stream","Encoding":""}`)

	// Download and install and make sure the file is as expected.
	installName := binFile.Name() + "-installed"
	downloadAndInstall(t, sh, clientCreds, clientBin, binaryRepoName, installName, binSuffix)
	defer os.Remove(installName)
	compareFiles(t, binFile.Name(), installName)

	// Download the compressed version of the binary file and
	// check that it matches the original one and that it has the
	// right file type.
	downloadTarName := binFile.Name() + "-compressed-downloaded"
	downloadedTarFile, infoFile := downloadFile(t, sh, clientCreds, clientBin, binaryRepoName, downloadTarName, tarSuffix)
	defer os.Remove(downloadedTarFile)
	defer os.Remove(infoFile)
	if downloadedTarFile != downloadTarName {
		t.Fatalf("expected %s, got %s", downloadTarName, downloadedTarFile)
	}
	compareFiles(t, tarFile, downloadedTarFile)
	checkFileType(t, infoFile, `{"Type":"application/x-tar","Encoding":"gzip"}`)

	// Download and install and make sure the un-archived file is as expected.
	installTarName := binFile.Name() + "-compressed-installed"
	downloadAndInstall(t, sh, clientCreds, clientBin, binaryRepoName, installTarName, tarSuffix)
	defer os.Remove(installTarName)
	compareFiles(t, binFile.Name(), filepath.Join(installTarName, binFile.Name()))

	// Fetch the root URL of the HTTP server used by the binary
	// repository to serve URLs.
	root := rootURL(t, sh, clientCreds, clientBin, binaryRepoName)

	// Download the binary file using the HTTP protocol and check
	// that it matches the original one.
	downloadedBinFileURL := binFile.Name() + "-downloaded-url"
	defer os.Remove(downloadedBinFileURL)
	downloadURL(t, downloadedBinFileURL, root, binSuffix)
	compareFiles(t, downloadName, downloadedBinFileURL)

	// Download the compressed version of the binary file using
	// the HTTP protocol and check that it matches the original
	// one.
	downloadedTarFileURL := binFile.Name() + "-downloaded-url.tar.gz"
	defer os.Remove(downloadedTarFileURL)
	downloadURL(t, downloadedTarFileURL, root, tarSuffix)
	compareFiles(t, downloadedTarFile, downloadedTarFileURL)

	// Delete the files.
	deleteFile(t, sh, clientCreds, clientBin, binaryRepoName, binSuffix)
	deleteFile(t, sh, clientCreds, clientBin, binaryRepoName, tarSuffix)

	// Check the files no longer exist.
	downloadFileExpectError(t, sh, clientCreds, clientBin, binaryRepoName, downloadName, binSuffix)
	downloadFileExpectError(t, sh, clientCreds, clientBin, binaryRepoName, downloadTarName, tarSuffix)
}

func TestMain(m *testing.M) {
	os.Exit(v23test.Run(m.Run))
}