// 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 let's you manage workspaces
package workspace

import (
	"fmt"
	"io/ioutil"
	"os"
	"os/exec"
	"path/filepath"
	"strings"

	"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"
	"android.googlesource.com/platform/tools/treble.git/hacksaw/git"
)

type Workspace struct {
	composer Composer
	topDir   string
}

func New(bm bind.PathBinder, topDir string) Workspace {
	return Workspace{NewComposer(bm), topDir}
}

// Create workspace
func (w Workspace) Create(workspaceName string, codebaseName string) (string, error) {
	cfg := config.GetConfig()
	_, ok := cfg.Codebases[codebaseName]
	if !ok {
		return "", fmt.Errorf("Codebase %s does not exist", codebaseName)
	}
	if _, ok := cfg.Workspaces[workspaceName]; ok {
		return "", fmt.Errorf("Workspace %s already exists", workspaceName)
	}
	cfg.Workspaces[workspaceName] = codebaseName
	workspaceDir, err := w.GetDir(workspaceName)
	if err != nil {
		return "", err
	}
	if err = os.MkdirAll(workspaceDir, os.ModePerm); err != nil {
		return "", err
	}
	codebaseDir, err := codebase.GetDir(codebaseName)
	if err != nil {
		return "", err
	}
	//TODO: match the order of parameters with Create
	if _, err = w.composer.Compose(codebaseDir, workspaceDir); err != nil {
		return "", err
	}
	return workspaceDir, nil
}

// Recreate workspace
func (w Workspace) Recreate(workspaceName string) (string, error) {
	cfg := config.GetConfig()
	codebaseName, ok := cfg.Workspaces[workspaceName]
	if !ok {
		return "", fmt.Errorf("Workspace %s does not exist", workspaceName)
	}
	workspaceDir, err := w.GetDir(workspaceName)
	if err != nil {
		return "", err
	}
	codebaseDir, err := codebase.GetDir(codebaseName)
	if err != nil {
		return "", err
	}
	if _, err = w.composer.Compose(codebaseDir, workspaceDir); err != nil {
		return "", err
	}
	return workspaceDir, nil
}

// GetDir retrieves the directory of a specific workspace
func (w Workspace) GetDir(workspaceName string) (string, error) {
	cfg := config.GetConfig()
	_, ok := cfg.Workspaces[workspaceName]
	if !ok {
		return "", fmt.Errorf("Workspace %s not found", workspaceName)
	}
	dir := filepath.Join(w.topDir, workspaceName)
	return dir, nil
}

// GetCodebase retrieves the codebase that a workspace belongs to
func (w Workspace) GetCodebase(workspaceName string) (string, error) {
	cfg := config.GetConfig()
	codebase, ok := cfg.Workspaces[workspaceName]
	if !ok {
		return "", fmt.Errorf("Workspace %s not found", workspaceName)
	}
	return codebase, nil
}

//SetTopDir sets the directory that contains all workspaces
func (w *Workspace) SetTopDir(dir string) {
	w.topDir = dir
}

func (w Workspace) List() map[string]string {
	cfg := config.GetConfig()
	list := make(map[string]string)
	for name, codebaseName := range cfg.Workspaces {
		list[name] = codebaseName
	}
	return list
}

func (w Workspace) DetachGitWorktrees(workspaceName string, unbindList []string) error {
	workspaceDir, err := w.GetDir(workspaceName)
	if err != nil {
		return err
	}
	workspaceDir, err = filepath.Abs(workspaceDir)
	if err != nil {
		return err
	}
	//resolve all symlinks so it can be
	//matched to mount paths
	workspaceDir, err = filepath.EvalSymlinks(workspaceDir)
	if err != nil {
		return err
	}
	codebaseName, err := w.GetCodebase(workspaceName)
	if err != nil {
		return err
	}
	codebaseDir, err := codebase.GetDir(codebaseName)
	if err != nil {
		return err
	}
	lister := git.NewRepoLister()
	gitProjects, err := lister.List(codebaseDir)
	if err != nil {
		return err
	}
	gitWorktrees := make(map[string]bool)
	for _, project := range gitProjects {
		gitWorktrees[project] = true
	}
	//projects that were unbound were definitely
	//never git worktrees
	for _, unbindPath := range unbindList {
		project, err := filepath.Rel(workspaceDir, unbindPath)
		if err != nil {
			return err
		}
		if _, ok := gitWorktrees[project]; ok {
			gitWorktrees[project] = false
		}
	}
	for project, isWorktree := range gitWorktrees {
		if !isWorktree {
			continue
		}
		codebaseProject := filepath.Join(codebaseDir, project)
		workspaceProject := filepath.Join(workspaceDir, project)
		_, err = os.Stat(workspaceProject)
		if err == nil {
			//proceed to detach
		} else if os.IsNotExist(err) {
			//just skip if it doesn't exist
			continue
		} else {
			return err
		}
		contents, err := ioutil.ReadDir(workspaceProject)
		if err != nil {
			return err
		}
		if len(contents) == 0 {
			//empty directory, not even a .git
			//not a wortree
			continue
		}
		fmt.Print(".")
		cmd := exec.Command("git",
			"-C", codebaseProject,
			"worktree", "remove", "--force", workspaceProject)
		output, err := cmd.CombinedOutput()
		if err != nil {
			return fmt.Errorf("Command\n%s\nfailed with the following:\n%s\n%s",
				cmd.String(), err.Error(), output)
		}
		cmd = exec.Command("git",
			"-C", codebaseProject,
			"branch", "--delete", "--force", workspaceName)
		output, err = cmd.CombinedOutput()
		if err != nil {
			return fmt.Errorf("Command\n%s\nfailed with the following:\n%s\n%s",
				cmd.String(), err.Error(), output)
		}
	}
	return nil
}

func (w Workspace) Remove(remove string) (*config.Config, error) {
	cfg := config.GetConfig()
	_, ok := cfg.Workspaces[remove]
	if !ok {
		return cfg, fmt.Errorf("Workspace %s not found", remove)
	}
	workspaceDir, err := w.GetDir(remove)
	if err != nil {
		return cfg, err
	}
	unbindList, err := w.composer.Dismantle(workspaceDir)
	if err != nil {
		return cfg, err
	}
	fmt.Print("Detaching worktrees")
	if err = w.DetachGitWorktrees(remove, unbindList); err != nil {
		return cfg, err
	}
	fmt.Print("\n")
	fmt.Println("Removing files")
	if err = os.RemoveAll(workspaceDir); err != nil {
		return cfg, err
	}
	delete(cfg.Workspaces, remove)
	return cfg, err
}

func (w Workspace) Edit(editPath string) (string, string, error) {
	editPath, err := filepath.Abs(editPath)
	if err != nil {
		return "", "", err
	}
	editPath, err = filepath.EvalSymlinks(editPath)
	if err != nil {
		return "", "", err
	}
	relProjectPath, err := w.getReadOnlyProjectFromPath(editPath)
	if err != nil {
		return "", "", err
	}
	workspaceName, err := w.getWorkspaceFromPath(editPath)
	if err != nil {
		return "", "", err
	}
	workspaceDir, err := w.GetDir(workspaceName)
	if err != nil {
		return "", "", err
	}
	codebaseName, err := w.GetCodebase(workspaceName)
	if err != nil {
		return "", "", err
	}
	codebaseDir, err := codebase.GetDir(codebaseName)
	if err != nil {
		return "", "", err
	}
	wsProjectPath := filepath.Join(workspaceDir, relProjectPath)
	if err = w.composer.Unbind(wsProjectPath); err != nil {
		return "", "", err
	}
	//TODO: support editing nested projects
	//the command above unbinds nested child projects but
	//we don't rebind them after checking out an editable project branch
	cbProjectPath := filepath.Join(codebaseDir, relProjectPath)
	branchName := workspaceName
	cmd := exec.Command("git",
		"-C", cbProjectPath,
		"worktree", "add",
		"-b", branchName,
		wsProjectPath)
	output, err := cmd.CombinedOutput()
	if err != nil {
		return "", "", fmt.Errorf("Command\n%s\nfailed with the following:\n%s\n%s",
			cmd.String(), err.Error(), output)
	}
	return branchName, wsProjectPath, err
}

func (w Workspace) getReadOnlyProjectFromPath(inPath string) (string, error) {
	worspaceName, err := w.getWorkspaceFromPath(inPath)
	if err != nil {
		return "", err
	}
	workspacePath, err := w.GetDir(worspaceName)
	if err != nil {
		return "", err
	}
	bindList, err := w.composer.List(workspacePath)
	if err != nil {
		return "", err
	}
	for _, bindPath := range bindList {
		if !strings.HasPrefix(inPath+"/", bindPath+"/") {
			continue
		}
		relProjectPath, err := filepath.Rel(workspacePath, bindPath)
		if err != nil {
			return "", err
		}
		return relProjectPath, nil
	}
	return "", fmt.Errorf("Path %s is already editable", inPath)
}

func (w Workspace) getWorkspaceFromPath(inPath string) (string, error) {
	for workspaceName, _ := range w.List() {
		dir, err := w.GetDir(workspaceName)
		if err != nil {
			return "", err
		}
		if strings.HasPrefix(inPath+"/", dir+"/") {
			return workspaceName, nil
		}
	}
	return "", fmt.Errorf("Path %s is not contained in a workspace", inPath)
}