// 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 (
	"fmt"
	"io"
	"io/ioutil"
	"os"
	"path/filepath"
	"strings"
)

type FileCopier struct {
}

func NewFileCopier() *FileCopier {
	var f FileCopier
	return &f
}

func (f FileCopier) GetIsGitProjectFunc(codebaseDir string, gitProjects []string) func(string) (bool, error) {
	//Convert the git project list to a set to speed up lookups
	gitProjectSet := make(map[string]struct{})
	var exists = struct{}{}
	for _, project := range gitProjects {
		gitProjectSet[project] = exists
	}

	return func(pathToCheck string) (bool, error) {
		var err error
		if pathToCheck, err = filepath.Rel(codebaseDir, pathToCheck); err != nil {
			return false, err
		}
		if _, ok := gitProjectSet[pathToCheck]; ok {
			return true, err
		}
		return false, err
	}
}

func (f FileCopier) GetContainsGitProjectFunc(codebaseDir string, gitProjects []string) func(string) (bool, error) {
	//Extract the set of dirs that contain git projects
	containsGitSet := make(map[string]struct{})
	var exists = struct{}{}
	for _, project := range gitProjects {
		for dir := project; dir != "." && dir != "/"; dir = filepath.Dir(dir) {
			containsGitSet[dir] = exists
		}
	}

	return func(pathToCheck string) (bool, error) {
		var err error
		if pathToCheck, err = filepath.Rel(codebaseDir, pathToCheck); err != nil {
			return false, err
		}
		if _, ok := containsGitSet[pathToCheck]; ok {
			return true, err
		}
		return false, err
	}
}

//gitProjects is relative to codebaseDir
func (f FileCopier) Copy(codebaseDir string, gitProjects []string, workspaceDir string) error {
	isGitProject := f.GetIsGitProjectFunc(codebaseDir, gitProjects)
	containsGitProject := f.GetContainsGitProjectFunc(codebaseDir, gitProjects)

	return filepath.Walk(codebaseDir,
		func(path string, info os.FileInfo, err error) error {
			if err != nil {
				return err
			}

			// Copy files
			if !info.IsDir() {
				return f.CopyNode(info, codebaseDir, path, workspaceDir)
			}

			if path == filepath.Clean(codebaseDir) {
				return nil
			}

			// Always skip traversal of root repo directories
			if path == filepath.Join(codebaseDir, ".repo") {
				return filepath.SkipDir
			}

			// Skip all git projects
			var isGitProj bool
			if isGitProj, err = isGitProject(path); err != nil {
				return err
			}
			if isGitProj {
				return filepath.SkipDir
			}

			// Copy over files
			var containsGitProj bool
			if containsGitProj, err = containsGitProject(path); err != nil {
				return err
			}
			if !containsGitProj {
				destPath, err := f.GetDestPath(codebaseDir, path, workspaceDir)
				if err != nil {
					return err
				}
				if err = f.CopyDirRecursive(info, path, destPath); err != nil {
					return err
				}
				return filepath.SkipDir
			}
			return f.CopyNode(info, codebaseDir, path, workspaceDir)
		})
}

func (f FileCopier) GetDestPath(codebaseDir, sourcePath, workspaceDir string) (string, error) {
	if !strings.HasPrefix(sourcePath+"/", codebaseDir+"/") {
		return "", fmt.Errorf("%s is not contained in %s", sourcePath, codebaseDir)
	}
	relPath, err := filepath.Rel(codebaseDir, sourcePath)
	if err != nil {
		return "", err
	}
	destPath := filepath.Join(workspaceDir, relPath)
	return destPath, err
}

// Copy any single file, symlink or dir non-recursively
// sourcePath must be contained in codebaseDir
func (f FileCopier) CopyNode(sourceInfo os.FileInfo, codebaseDir, sourcePath, workspaceDir string) error {
	destPath, err := f.GetDestPath(codebaseDir, sourcePath, workspaceDir)
	if err != nil {
		return err
	}
	switch {
	case sourceInfo.Mode()&os.ModeSymlink == os.ModeSymlink:
		return f.CopySymlink(sourcePath, destPath)
	case sourceInfo.Mode().IsDir():
		return f.CopyDirOnly(sourceInfo, destPath)
	default:
		return f.CopyFile(sourceInfo, sourcePath, destPath)
	}
}

func (f FileCopier) CopySymlink(sourcePath string, destPath string) error {
	// Skip symlink if it already exists at the destination
	_, err := os.Lstat(destPath)
	if err == nil {
		return nil
	}

	target, err := os.Readlink(sourcePath)
	if err != nil {
		return err
	}

	return os.Symlink(target, destPath)
}

// CopyDirOnly copies a directory non-recursively
// sourcePath must be contained in codebaseDir
func (f FileCopier) CopyDirOnly(sourceInfo os.FileInfo, destPath string) error {
	_, err := os.Stat(destPath)
	if err == nil {
		// Dir already exists, nothing to do
		return err
	} else if os.IsNotExist(err) {
		return os.Mkdir(destPath, sourceInfo.Mode())
	}
	return err
}

// CopyFile copies a single file
// sourcePath must be contained in codebaseDir
func (f FileCopier) CopyFile(sourceInfo os.FileInfo, sourcePath, destPath string) error {
	//Skip file if it already exists at the destination
	_, err := os.Lstat(destPath)
	if err == nil {
		return nil
	}

	sourceFile, err := os.Open(sourcePath)
	if err != nil {
		return err
	}
	defer sourceFile.Close()

	destFile, err := os.Create(destPath)
	if err != nil {
		return err
	}
	defer destFile.Close()

	_, err = io.Copy(destFile, sourceFile)
	if err != nil {
		return err
	}
	return os.Chmod(destPath, sourceInfo.Mode())
}

func (f FileCopier) CopyDirRecursive(sourceInfo os.FileInfo, sourcePath, destPath string) error {
	if err := f.CopyDirOnly(sourceInfo, destPath); err != nil {
		return err
	}
	childNodes, err := ioutil.ReadDir(sourcePath)
	if err != nil {
		return err
	}
	for _, childInfo := range childNodes {
		childSourcePath := filepath.Join(sourcePath, childInfo.Name())
		childDestPath := filepath.Join(destPath, childInfo.Name())
		switch {
		case childInfo.Mode()&os.ModeSymlink == os.ModeSymlink:
			if err = f.CopySymlink(childSourcePath, childDestPath); err != nil {
				return err
			}
		case childInfo.Mode().IsDir():
			if err = f.CopyDirRecursive(childInfo, childSourcePath, childDestPath); err != nil {
				return err
			}
		default:
			if err = f.CopyFile(childInfo, childSourcePath, childDestPath); err != nil {
				return err
			}
		}
	}
	return err
}