// Copyright 2021 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
//
//      http://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.

// +build linux darwin

package main

import (
	"encoding/json"
	"flag"
	"fmt"
	"io/ioutil"
	"log"
	"os"
	osexec "os/exec"
	"path"
	"strings"
)

// TODO(noahdietz): remove this once the fix in golang.org/x/tools is released.
// https://github.com/golang/go/issues/44796
const ignored = "- MaxPublishRequestBytes: value changed from 0.000582077 to 10000000"
const rootMod = "cloud.google.com/go"

var repoMetadataPath string
var verbose bool
var gapic string

func init() {
	flag.StringVar(&repoMetadataPath, "repo-metadata", "", "path to a repo-metadata-full JSON file [required]")
	flag.StringVar(&gapic, "gapic", "", "import path of a specific GAPIC to diff")
	flag.BoolVar(&verbose, "verbose", false, "enable verbose command logging")
}

func main() {
	flag.Parse()
	if repoMetadataPath == "" {
		log.Fatalln("Missing required flag: -repo-metadata")
	}

	head, err := exec("git", "log", "-2")
	if err != nil {
		log.Fatalln(err)
	}
	if checkAllowBreakingChange(head) {
		return
	}

	root, err := os.Getwd()
	if err != nil {
		log.Fatalln(err)
	}

	f, err := os.Open(repoMetadataPath)
	if err != nil {
		log.Fatalln(err)
	}
	defer f.Close()

	var m manifest
	if err := json.NewDecoder(f).Decode(&m); err != nil {
		log.Fatalln(err)
	}

	_, err = exec("go", "install", "golang.org/x/exp/cmd/apidiff@latest")
	if err != nil {
		log.Fatalln(err)
	}

	temp, err := ioutil.TempDir("/tmp", "google-cloud-go-*")
	if err != nil {
		log.Fatalln(err)
	}
	defer os.RemoveAll(temp)

	_, err = exec("git", "clone", "https://github.com/googleapis/google-cloud-go", temp)
	if err != nil {
		log.Fatalln(err)
	}

	diffs, diffingErrs, err := diffModules(root, temp, m)
	if err != nil {
		log.Fatalln(err)
	}

	if len(diffingErrs) > 0 {
		fmt.Fprintln(os.Stderr, "The following packages encountered errors:")
		for imp, err := range diffingErrs {
			fmt.Fprintf(os.Stderr, "%s: %s\n", imp, err)
		}
	}

	if len(diffs) > 0 {
		fmt.Fprintln(os.Stderr, "The following breaking changes were found:")
		for imp, d := range diffs {
			fmt.Fprintf(os.Stderr, "%s:\n%s\n", imp, d)
		}
		os.Exit(1)
	}
}

// manifestEntry is used for JSON marshaling in manifest.
// Copied from internal/gapicgen/generator/gapics.go.
type manifestEntry struct {
	DistributionName  string `json:"distribution_name"`
	Description       string `json:"description"`
	Language          string `json:"language"`
	ClientLibraryType string `json:"client_library_type"`
	DocsURL           string `json:"docs_url"`
	ReleaseLevel      string `json:"release_level"`
}

type manifest map[string]manifestEntry

func diffModules(root, baseDir string, m manifest) (map[string]string, map[string]error, error) {
	diffs := map[string]string{}
	issues := map[string]error{}

	for imp, entry := range m {
		if gapic != "" && imp != gapic {
			continue
		}

		// Prepare module directory paths relative to the repo root.
		pkg := strings.TrimPrefix(imp, rootMod+"/")
		baseModDir := baseDir
		modDir := root

		// Manual clients are also submodules, so we need to run apidiff in the
		// submodule.
		if entry.ClientLibraryType == "manual" {
			baseModDir = path.Join(baseModDir, pkg)
			modDir = path.Join(modDir, pkg)
		}

		// Create apidiff base from repo remote HEAD.
		base, err := writeBase(m, baseModDir, imp, pkg)
		if err != nil {
			issues[imp] = err
			continue
		}

		// Diff the current checked out change against remote HEAD base.
		out, err := diff(m, modDir, imp, pkg, base)
		if err != nil {
			issues[imp] = err
			continue
		}

		if out != "" && out != ignored {
			diffs[imp] = out
		}
	}

	return diffs, issues, nil
}

func writeBase(m manifest, baseModDir, imp, pkg string) (string, error) {
	if err := cd(baseModDir); err != nil {
		return "", err
	}

	base := path.Join(baseModDir, "pkg.master")
	out, err := exec("apidiff", "-w", base, imp)
	if err != nil && !isSubModErr(out) {
		return "", err
	}

	// If there was an issue with loading a submodule, change into that
	// submodule directory and try again.
	if isSubModErr(out) {
		parent := manualParent(m, imp)
		if parent == pkg {
			return "", fmt.Errorf("unable to find parent module for %q", imp)
		}
		if err := cd(parent); err != nil {
			return "", err
		}
		out, err := exec("apidiff", "-w", base, imp)
		if err != nil {
			return "", fmt.Errorf("%s: %s", err, out)
		}
	}
	return base, nil
}

func diff(m manifest, modDir, imp, pkg, base string) (string, error) {
	if err := cd(modDir); err != nil {
		return "", err
	}
	out, err := exec("apidiff", "-incompatible", base, imp)
	if err != nil && !isSubModErr(out) {
		return "", err
	}
	if isSubModErr(out) {
		parent := manualParent(m, imp)
		if parent == pkg {
			return "", fmt.Errorf("unable to find parent module for %q", imp)
		}
		if err := cd(parent); err != nil {
			return "", err
		}
		out, err = exec("apidiff", "-incompatible", base, imp)
		if err != nil {
			return "", fmt.Errorf("%s: %s", err, out)
		}
	}

	return out, err
}

func checkAllowBreakingChange(commit string) bool {
	if strings.Contains(commit, "BREAKING CHANGE:") {
		log.Println("Not running apidiff because description contained tag BREAKING_CHANGE.")
		return true
	}

	split := strings.Split(commit, "\n")
	for _, s := range split {
		if strings.Contains(s, "!:") || strings.Contains(s, "!(") {
			log.Println("Not running apidiff because description contained breaking change indicator '!'.")
			return true
		}
	}

	return false
}

func manualParent(m manifest, imp string) string {
	pkg := strings.TrimPrefix(imp, rootMod)
	split := strings.Split(pkg, "/")

	mod := rootMod
	for _, seg := range split {
		mod = path.Join(mod, seg)
		if parent, ok := m[mod]; ok && parent.ClientLibraryType == "manual" {
			return strings.TrimPrefix(mod, rootMod+"/")
		}
	}

	return pkg
}

func isSubModErr(msg string) bool {
	return strings.Contains(msg, "missing") || strings.Contains(msg, "required")
}

func cd(dir string) error {
	if verbose {
		log.Printf("+ cd %s\n", dir)
	}
	return os.Chdir(dir)
}

func exec(cmd string, args ...string) (string, error) {
	if verbose {
		log.Printf("+ %s %s\n", cmd, strings.Join(args, " "))
	}
	out, err := osexec.Command(cmd, args...).CombinedOutput()
	return strings.TrimSpace(string(out)), err
}