// Copyright 2020 Google LLC
//
// 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
//
//     https://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.

package workspace

import (
 "io/ioutil"
 "os"
 "os/exec"
 "path"
 "testing"

 "android.googlesource.com/platform/tools/treble.git/hacksaw/bind"
 "android.googlesource.com/platform/tools/treble.git/hacksaw/codebase"
 "android.googlesource.com/platform/tools/treble.git/hacksaw/config"
)

func TestBasicCreate(t *testing.T) {
 defer config.GetConfig().Reset()
 codebaseDir, err := ioutil.TempDir("", "codebase")
 if err != nil {
  t.Error(err)
 }
 defer os.RemoveAll(codebaseDir)
 gitDir := path.Join(codebaseDir, "project", ".git")
 if err = os.MkdirAll(gitDir, os.ModePerm); err != nil {
  t.Error(err)
 }
 repoDir := path.Join(codebaseDir, ".repo")
 if err = os.Mkdir(repoDir, os.ModePerm); err != nil {
  t.Error(err)
 }
 listContents := []byte("project")
 listPath := path.Join(repoDir, "project.list")
 if err = ioutil.WriteFile(listPath, listContents, os.ModePerm); err != nil {
  t.Error(err)
 }
 _, err = codebase.Add("test-codebase", codebaseDir)
 if err != nil {
  t.Error(err)
 }
 // The top dir must be named "hacksaw"
 // otherwise the mounters will reject any
 // mount requests
 wsTempDir, err := ioutil.TempDir("", "workspace")
 if err != nil {
  t.Error(err)
 }
 defer os.RemoveAll(wsTempDir)
 wsTopDir := path.Join(wsTempDir, "hacksaw")
 if err = os.Mkdir(wsTopDir, os.ModePerm); err != nil {
  t.Error(err)
 }
 ws := New(bind.NewFakePathBinder(), wsTopDir)
 if _, err = ws.Create("test-workspace", "test-codebase"); err != nil {
  t.Error(err)
 }
 workspaceDir, err := ws.GetDir("test-workspace")
 if err != nil {
  t.Error(err)
 }
 _, err = os.Stat(workspaceDir)
 if err != nil {
  t.Error(err)
 }
}

func TestWorkspaceDuplicate(t *testing.T) {
 defer config.GetConfig().Reset()
 codebaseDir, err := ioutil.TempDir("", "codebase")
 if err != nil {
  t.Error(err)
 }
 defer os.RemoveAll(codebaseDir)
 gitDir := path.Join(codebaseDir, "project", ".git")
 if err = os.MkdirAll(gitDir, os.ModePerm); err != nil {
  t.Error(err)
 }
 repoDir := path.Join(codebaseDir, ".repo")
 if err = os.Mkdir(repoDir, os.ModePerm); err != nil {
  t.Error(err)
 }
 listContents := []byte("project")
 listPath := path.Join(repoDir, "project.list")
 if err = ioutil.WriteFile(listPath, listContents, os.ModePerm); err != nil {
  t.Error(err)
 }
 _, err = codebase.Add("test-codebase", codebaseDir)
 if err != nil {
  t.Error(err)
 }
 // The top dir must be named "hacksaw"
 // otherwise the mounters will reject any
 // mount requests
 wsTempDir, err := ioutil.TempDir("", "workspace")
 if err != nil {
  t.Error(err)
 }
 defer os.RemoveAll(wsTempDir)
 wsTopDir := path.Join(wsTempDir, "hacksaw")
 if err = os.Mkdir(wsTopDir, os.ModePerm); err != nil {
  t.Error(err)
 }
 ws := New(bind.NewFakePathBinder(), wsTopDir)
 _, err = ws.Create("test-workspace", "test-codebase")
 if err != nil {
  t.Error(err)
 }
 _, err = ws.Create("test-workspace", "test-codebase")
 if err == nil {
  t.Error("Allowed workspace duplicate")
 }
}

func TestCreateWorkspaceFromBadCodebase(t *testing.T) {
 defer config.GetConfig().Reset()
 codebaseDir, err := ioutil.TempDir("", "test")
 if err != nil {
  t.Error(err)
 }
 defer os.RemoveAll(codebaseDir)
 _, err = codebase.Add("test-codebase", codebaseDir)
 if err != nil {
  t.Error(err)
 }
 wsTempDir, err := ioutil.TempDir("", "workspace")
 if err != nil {
  t.Error(err)
 }
 defer os.RemoveAll(wsTempDir)
 wsTopDir := path.Join(wsTempDir, "hacksaw")
 if err = os.Mkdir(wsTopDir, os.ModePerm); err != nil {
  t.Error(err)
 }
 ws := New(bind.NewFakePathBinder(), wsTopDir)
 if _, err = ws.Create("test-workspace", "does-not-exist"); err == nil {
  t.Error("Allowed bad codebase")
 }
}

func TestList(t *testing.T) {
 defer config.GetConfig().Reset()
 codebaseDir, err := ioutil.TempDir("", "test")
 if err != nil {
  t.Error(err)
 }
 defer os.RemoveAll(codebaseDir)
 gitDir := path.Join(codebaseDir, "project", ".git")
 if err = os.MkdirAll(gitDir, os.ModePerm); err != nil {
  t.Error(err)
 }
 repoDir := path.Join(codebaseDir, ".repo")
 if err = os.Mkdir(repoDir, os.ModePerm); err != nil {
  t.Error(err)
 }
 listContents := []byte("project")
 listPath := path.Join(repoDir, "project.list")
 if err = ioutil.WriteFile(listPath, listContents, os.ModePerm); err != nil {
  t.Error(err)
 }
 _, err = codebase.Add("test-codebase", codebaseDir)
 if err != nil {
  t.Error(err)
 }
 wsTempDir, err := ioutil.TempDir("", "workspace")
 if err != nil {
  t.Error(err)
 }
 defer os.RemoveAll(wsTempDir)
 wsTopDir := path.Join(wsTempDir, "hacksaw")
 if err = os.Mkdir(wsTopDir, os.ModePerm); err != nil {
  t.Error(err)
 }
 ws := New(bind.NewFakePathBinder(), wsTopDir)
 if _, err = ws.Create("test-workspace", "test-codebase"); err != nil {
  t.Error(err)
 }
 list := ws.List()
 cb, ok := list["test-workspace"]
 if !ok || cb != "test-codebase" {
  t.Error("Added workspace not listed")
 }
}

func TestRemove(t *testing.T) {
 defer config.GetConfig().Reset()
 codebaseDir, err := ioutil.TempDir("", "test")
 if err != nil {
  t.Error(err)
 }
 defer os.RemoveAll(codebaseDir)
 gitDir := path.Join(codebaseDir, "project", ".git")
 if err = os.MkdirAll(gitDir, os.ModePerm); err != nil {
  t.Error(err)
 }
 repoDir := path.Join(codebaseDir, ".repo")
 if err = os.Mkdir(repoDir, os.ModePerm); err != nil {
  t.Error(err)
 }
 listContents := []byte("project")
 listPath := path.Join(repoDir, "project.list")
 if err = ioutil.WriteFile(listPath, listContents, os.ModePerm); err != nil {
  t.Error(err)
 }
 _, err = codebase.Add("test-codebase", codebaseDir)
 if err != nil {
  t.Error(err)
 }
 wsTempDir, err := ioutil.TempDir("", "workspace")
 if err != nil {
  t.Error(err)
 }
 defer os.RemoveAll(wsTempDir)
 wsTopDir := path.Join(wsTempDir, "hacksaw")
 if err = os.Mkdir(wsTopDir, os.ModePerm); err != nil {
  t.Error(err)
 }
 ws := New(bind.NewFakePathBinder(), wsTopDir)
 if _, err = ws.Create("test-workspace", "test-codebase"); err != nil {
  t.Error(err)
 }
 workspaceDir, err := ws.GetDir("test-workspace")
 if err != nil {
  t.Error(err)
 }
 _, err = os.Stat(workspaceDir)
 if err != nil {
  t.Error(err)
 }
 cfg, err := ws.Remove("test-workspace")
 if err != nil {
  t.Error(err)
 }
 _, ok := cfg.Workspaces["test-codebase"]
 if ok {
  t.Error("Removed workspace test-codebase is still in the configuration")
 }
 _, err = os.Stat(workspaceDir)
 if err == nil {
  t.Error("Workspace test-workspace was removed but its directory remains")
 } else if os.IsNotExist(err) {
  // This is the expected error
 } else {
  t.Error(err)
 }
}

func TestEdit(t *testing.T) {
 defer config.GetConfig().Reset()
 codebaseDir, err := ioutil.TempDir("", "codebase")
 if err != nil {
  t.Error(err)
 }
 defer os.RemoveAll(codebaseDir)
 projectDir := path.Join(codebaseDir, "project")
 if err = os.MkdirAll(projectDir, os.ModePerm); err != nil {
  t.Error(err)
 }
 cmd := exec.Command("git", "-C", projectDir, "init")
 output, err := cmd.CombinedOutput()
 if err != nil {
  t.Errorf("Command\n%s\nfailed with the following:\n%s\n%s",
   cmd.String(), err.Error(), output)
 }
 cmd = exec.Command("git", "-C", projectDir, "commit", `--message="Initial commit"`, "--allow-empty")
 output, err = cmd.CombinedOutput()
 if err != nil {
  t.Errorf("Command\n%s\nfailed with the following:\n%s\n%s",
   cmd.String(), err.Error(), output)
 }
 repoDir := path.Join(codebaseDir, ".repo")
 if err = os.Mkdir(repoDir, os.ModePerm); err != nil {
  t.Error(err)
 }
 listContents := []byte("project")
 listPath := path.Join(repoDir, "project.list")
 if err = ioutil.WriteFile(listPath, listContents, os.ModePerm); err != nil {
  t.Error(err)
 }
 _, err = codebase.Add("test-codebase", codebaseDir)
 if err != nil {
  t.Error(err)
 }
 wsTempDir, err := ioutil.TempDir("", "workspace")
 if err != nil {
  t.Error(err)
 }
 defer os.RemoveAll(wsTempDir)
 wsTopDir := path.Join(wsTempDir, "hacksaw")
 if err = os.Mkdir(wsTopDir, os.ModePerm); err != nil {
  t.Error(err)
 }
 ws := New(bind.NewFakePathBinder(), wsTopDir)
 if _, err = ws.Create("test-workspace", "test-codebase"); err != nil {
  t.Error(err)
 }
 workspaceDir, err := ws.GetDir("test-workspace")
 if err != nil {
  t.Error(err)
 }
 _, err = os.Stat(workspaceDir)
 if err != nil {
  t.Error(err)
 }
 editPath := path.Join(workspaceDir, "project")
 branchName, wsProjectDir, err := ws.Edit(editPath)
 if err != nil {
  t.Error(err)
 }
 if branchName == "" {
  t.Error("Editing returned an empty branch")
 }
 if wsProjectDir == "" {
  t.Error("Editing returned an empty project path")
 }
 cmd = exec.Command("git", "-C", wsProjectDir, "show", branchName)
 output, err = cmd.CombinedOutput()
 if err != nil {
  t.Errorf("Command\n%s\nfailed with the following:\n%s\n%s",
   cmd.String(), err.Error(), output)
 }
 //Recreate workspace and try editing again
 _, err = ws.Remove("test-workspace")
 if err != nil {
  t.Error(err)
 }
 _, err = ws.Create("test-workspace", "test-codebase")
 if err != nil {
  t.Error(err)
 }
 _, _, err = ws.Edit(editPath)
 if err != nil {
  t.Error(err)
 }
}

const projectList = `read-only-project
editable-project`

func TestRecreate(t *testing.T) {
 defer config.GetConfig().Reset()
 codebaseDir, err := ioutil.TempDir("", "codebase")
 if err != nil {
  t.Error(err)
 }
 defer os.RemoveAll(codebaseDir)
 roProjectDir := path.Join(codebaseDir, "read-only-project")
 if err = os.MkdirAll(roProjectDir, os.ModePerm); err != nil {
  t.Error(err)
 }
 cmd := exec.Command("git", "-C", roProjectDir, "init")
 output, err := cmd.CombinedOutput()
 if err != nil {
  t.Errorf("Command\n%s\nfailed with the following:\n%s\n%s",
   cmd.String(), err.Error(), output)
 }
 cmd = exec.Command("git", "-C", roProjectDir, "commit", `--message="Initial commit"`, "--allow-empty")
 output, err = cmd.CombinedOutput()
 if err != nil {
  t.Errorf("Command\n%s\nfailed with the following:\n%s\n%s",
   cmd.String(), err.Error(), output)
 }
 linkPath := path.Join(codebaseDir, "symlink")
 if err = os.Symlink(roProjectDir, linkPath); err != nil {
  t.Error(err)
 }
 rwProjectDir := path.Join(codebaseDir, "editable-project")
 if err = os.MkdirAll(rwProjectDir, os.ModePerm); err != nil {
  t.Error(err)
 }
 cmd = exec.Command("git", "-C", rwProjectDir, "init")
 output, err = cmd.CombinedOutput()
 if err != nil {
  t.Errorf("Command\n%s\nfailed with the following:\n%s\n%s",
   cmd.String(), err.Error(), output)
 }
 cmd = exec.Command("git", "-C", rwProjectDir, "commit", `--message="Initial commit"`, "--allow-empty")
 output, err = cmd.CombinedOutput()
 if err != nil {
  t.Errorf("Command\n%s\nfailed with the following:\n%s\n%s",
   cmd.String(), err.Error(), output)
 }
 repoDir := path.Join(codebaseDir, ".repo")
 if err = os.Mkdir(repoDir, os.ModePerm); err != nil {
  t.Error(err)
 }
 listContents := []byte(projectList)
 listPath := path.Join(repoDir, "project.list")
 if err = ioutil.WriteFile(listPath, listContents, os.ModePerm); err != nil {
  t.Error(err)
 }
 _, err = codebase.Add("test-codebase", codebaseDir)
 if err != nil {
  t.Error(err)
 }
 wsTempDir, err := ioutil.TempDir("", "workspace")
 if err != nil {
  t.Error(err)
 }
 defer os.RemoveAll(wsTempDir)
 wsTopDir := path.Join(wsTempDir, "hacksaw")
 if err = os.Mkdir(wsTopDir, os.ModePerm); err != nil {
  t.Error(err)
 }
 pathBinder := bind.NewFakePathBinder()
 ws := New(pathBinder, wsTopDir)
 if _, err = ws.Create("test-workspace", "test-codebase"); err != nil {
  t.Error(err)
 }
 workspaceDir, err := ws.GetDir("test-workspace")
 if err != nil {
  t.Error(err)
 }
 editPath := path.Join(workspaceDir, "editable-project")
 _, _, err = ws.Edit(editPath)
 if err != nil {
  t.Error(err)
 }
 emptyFilePath := path.Join(editPath, "empty-edit")
 emptyFile, err := os.Create(emptyFilePath)
 if err != nil {
  t.Error(err)
 }
 emptyFile.Close()
 if _, err = ws.Recreate("test-workspace"); err != nil {
  t.Error(err)
 }
 _, err = os.Stat(emptyFilePath)
 if err != nil {
  t.Error(err)
 }
 wsRoProjectDir := path.Join(workspaceDir, "read-only-project")
 isRoPathBound := false
 pathList, err := pathBinder.List()
 if err != nil {
  t.Error(err)
 }
 for _, path := range pathList {
  if path == wsRoProjectDir {
   isRoPathBound = true
  }
 }
 if !isRoPathBound {
  t.Error("Read only project was not mounted to the workspace")
 }
}