// Copyright 2018 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 main

import (
	"bufio"
	"bytes"
	"encoding/hex"
	"fmt"
	"io/ioutil"
	"os"
	"path"
	"path/filepath"
	"strings"
	"testing"

	"go.fuchsia.dev/jiri/project"
)

func TestPrefixTree(t *testing.T) {
	_, fakeroot, cleanup := setupUniverse(t)
	defer cleanup()

	projects := []project.Project{
		{Name: "root", Path: "."},
		{Name: "a", Path: "a"},
		{Name: "b", Path: "b"},
		{Name: "c/d/e", Path: "c/d/e"},
		{Name: "c/d/f", Path: "c/d/f"},
		{Name: "c/d", Path: "c/d"},
		{Name: "c", Path: "c"},
	}
	expectedDropped := []project.Project{
		projects[0],
		projects[3],
		projects[4],
		projects[5],
	}

	// Fill projects into prefix tree
	root := projectTree{nil, make(map[string]*projectTree)}
	dropped := make(project.Projects)
	treeRoot := projectTreeRoot{&root, dropped}
	for _, v := range projects {
		if err := treeRoot.add(fakeroot.X, v); err != nil {
			t.Errorf("adding project to prefixTree failed due to error: %v", err)
			break
		}
	}

	// generate logs when test failed
	failedDropped := func() {
		t.Logf("wrong nested projects list")
		t.Logf("expecting: ")
		for _, v := range expectedDropped {
			t.Logf("\tproject:%q", v.Path)
		}
		t.Logf("got:")
		for _, v := range treeRoot.dropped {
			t.Logf("\tproject:%q", v.Path)
		}
		t.Fail()
	}

	// Verify nested projects
	if len(treeRoot.dropped) != len(expectedDropped) {
		failedDropped()
	}
	for _, v := range expectedDropped {
		if _, ok := treeRoot.dropped[v.Key()]; !ok {
			failedDropped()
			break
		}
	}

	// Verify the shape of prefix tree
	if len(root.children) == 3 {
		prefixes := []string{"a", "b", "c"}
		for _, v := range prefixes {
			if _, ok := root.children[v]; !ok {
				t.Errorf("root node does not contain project %q", v)
			}
		}
		for _, v := range root.children {
			if len(v.children) != 0 {
				t.Errorf("more than 1 level of nodes found in prefix tree")
			}
		}
	} else {
		t.Errorf("expecting %v first level nodes, but got %v", 3, len(root.children))
	}
}

func TestGitModules(t *testing.T) {
	goldenScript := []byte(`#!/bin/sh
git update-index --add --cacheinfo 160000 87326c54332e5be21eda2173bb001aaee73a9ab7 "manifest"
git update-index --add --cacheinfo 160000 87f863bcbc7cd2177bac17c61e31093de6eeed28 "path-0"
git update-index --add --cacheinfo 160000 87f863bcbc7cd2177bac17c61e31093de6eeed28 "path-1"
git update-index --add --cacheinfo 160000 87f863bcbc7cd2177bac17c61e31093de6eeed28 "path-2"`)

	goldenModule := []byte(`[submodule "manifest-31b42b3e96"]
	path = manifest
	url = /tmp/115893653/manifest
[submodule "project-0-50299b644d"]
	path = path-0
	url = /tmp/115893653/project-0
[submodule "project-1-743aa3e46a"]
	path = path-1
	url = /tmp/115893653/project-1
[submodule "project-2-1615f49046"]
	path = path-2
	url = /tmp/115893653/project-2`)

	goldenAttributes := []byte(`manifest manifest public
path-0 manifest public
path-1 manifest public
path-2 manifest public
`)

	// Setup fake workspace and update $JIRI_ROOT
	_, fakeroot, cleanup := setupUniverse(t)
	defer cleanup()
	if err := fakeroot.UpdateUniverse(false); err != nil {
		t.Errorf("%v", err)
	}

	localProjects, err := project.LocalProjects(fakeroot.X, project.FullScan)
	if err != nil {
		t.Errorf("scanning local fake project failed due to error %v", err)
	}

	pathMap := make(map[string]project.Project)
	for _, v := range localProjects {
		v.Path, err = makePathRel(fakeroot.X.Root, v.Path)
		if err != nil {
			t.Errorf("path relativation failed due to error %v", err)
		}
		pathMap[v.Path] = v
	}

	tempDir, err := ioutil.TempDir("", "gitmodules")
	if err != nil {
		t.Errorf(".gitmodules generation failed due to error %v", err)
	}
	defer os.RemoveAll(tempDir)

	genGitModuleFlags.genScript = path.Join(tempDir, "setup.sh")
	err = runGenGitModule(fakeroot.X, []string{
		path.Join(tempDir, ".gitmodules"),
		path.Join(tempDir, ".gitattributes"),
	})
	if err != nil {
		t.Errorf(".gitmodules generation failed due to error %v", err)
	}

	// Read and verify content of generated script
	data, err := ioutil.ReadFile(genGitModuleFlags.genScript)
	if err != nil {
		t.Errorf("reading generated script file failed due to error: %v", err)
	}
	t.Logf("generated script content \n%s\n", string(data))

	if err := verifyScript(goldenScript, data); err != nil {
		t.Errorf("verifying generated script failed due to error: %v", err)
	}

	// Read and verify content of generated .gitmodules file
	data, err = ioutil.ReadFile(path.Join(tempDir, ".gitmodules"))
	if err != nil {
		t.Errorf("reading generated .gitmodules file failed due to error: %v", err)
	}
	t.Logf("generated gitmodule content \n%s\n", string(data))

	if err := verifyModules(goldenModule, data); err != nil {
		t.Errorf("verifying generated .gitmodules failed due to error: %v", err)
	}

	// Read and verify content of generated .gitattributes file
	data, err = ioutil.ReadFile(path.Join(tempDir, ".gitattributes"))
	if err != nil {
		t.Errorf("reading generated .gitattributes file failed due to error: %v", err)
	}
	t.Logf("generated gitattributes content \n%s\n", string(data))
	if bytes.Compare(data, goldenAttributes) != 0 {
		t.Errorf("verfying generated .gitattributes failed. Expecting: %q, got %q", string(goldenAttributes), string(data))
	}
}

func readlines(data []byte) ([]string, error) {
	var buffer bytes.Buffer
	retLines := make([]string, 0)
	if _, err := buffer.Write(data); err != nil {
		return nil, err
	}
	scanner := bufio.NewScanner(&buffer)
	for scanner.Scan() {
		line := strings.TrimSpace(scanner.Text())
		if len(line) == 0 || line[0] == '#' {
			continue
		}
		retLines = append(retLines, line)
	}
	return retLines, nil
}

func verifyModules(golden, tests []byte) error {
	goldenLines, err := readlines(golden)
	if err != nil {
		return err
	}
	testLines, err := readlines(tests)
	if err != nil {
		return err
	}
	if len(goldenLines) != len(testLines) {
		return fmt.Errorf("expecting %q non-empty/non-comment lines from generated .gitmodules, got %q lines", len(goldenLines), len(testLines))
	}
	for i := 0; i < len(goldenLines); i++ {
		goldenLine := goldenLines[i]
		testLine := testLines[i]
		if strings.HasPrefix(testLine, "branch = ") {
			revision := testLine[len("branch = "):]
			// revision should be 20 bytes in hex format
			if len(revision) != 40 {
				return fmt.Errorf("illegal revision hash in line %q", testLine)
			}
			if _, err := hex.DecodeString(revision); err != nil {
				return fmt.Errorf("illegal revision hash in line %q", testLine)
			}
			continue
		}
		if strings.HasPrefix(testLine, "url = ") {
			testPath := testLine[len("url = "):]
			goldenPath := goldenLine[len("url = "):]
			testPathFields := strings.Split(testPath, string(filepath.Separator))
			goldenPathFields := strings.Split(goldenPath, string(filepath.Separator))
			testPath = testPathFields[len(testPathFields)-1]
			goldenPath = goldenPathFields[len(goldenPathFields)-1]
			if testPath != goldenPath {
				return fmt.Errorf("path mismatch, expecting %q, got %q", goldenPath, testPath)
			}
			continue
		}
		if strings.HasPrefix(testLine, "[submodule ") {
			testProjectName := testLine[:strings.LastIndex(testLine, "-")]
			goldenProjectName := goldenLine[:strings.LastIndex(testLine, "-")]
			if testProjectName != goldenProjectName {
				return fmt.Errorf("project name mismatch, expection %q, got %q", goldenProjectName, testProjectName)
			}
			continue
		}
		if goldenLine != testLine {
			return fmt.Errorf("in generated .gitmodules file, expecting %q, got %q", goldenLine, testLine)
		}
	}
	return nil
}

func verifyScript(golden, tests []byte) error {
	goldenLines, err := readlines(golden)
	if err != nil {
		return err
	}
	testLines, err := readlines(tests)
	if err != nil {
		return err
	}
	if len(goldenLines) != len(testLines) {
		return fmt.Errorf("expecting %q non-empty/non-comment lines from generated script, got %q lines", len(goldenLines), len(testLines))
	}
	for i := 0; i < len(goldenLines); i++ {
		goldenLine := goldenLines[i]
		testLine := testLines[i]
		goldenFields := strings.Fields(goldenLine)
		testFields := strings.Fields(testLine)
		if len(goldenFields) != len(testFields) {
			return fmt.Errorf("format error at line %q in generated script, expecting something like %q", testLine, goldenLine)
		}
		// Any field except the revision hash should be exact match.
		for j := 0; j < 5; j++ {
			if goldenFields[j] != testFields[j] {
				return fmt.Errorf("command missmatch at line %q in generated script, expecting something like %q", testLine, goldenLine)
			}
		}
		if goldenFields[6] != testFields[6] {
			return fmt.Errorf("command missmatch at line %q in generated script, expecting something like %q", testLine, goldenLine)
		}
		// revision should be 20 bytes in hex format
		if len(testFields[5]) != 40 {
			return fmt.Errorf("illegal revision hash in line %q", testLine)
		}
		if _, err := hex.DecodeString(testFields[5]); err != nil {
			return fmt.Errorf("illegal revision hash in git command %q", testLine)
		}
	}
	return nil
}