/*
Copyright 2017 Google Inc. All rights reserved.

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.
*/

package main

import (
	"fmt"
	"io"
	"io/ioutil"
	"os"
	"path/filepath"
	"sort"
	"strconv"
	"strings"

	"github.com/fatih/color"

	"github.com/google/go-jsonnet"
	"github.com/google/go-jsonnet/cmd/internal/cmd"
)

func version(o io.Writer) {
	fmt.Fprintf(o, "Jsonnet commandline interpreter %s\n", jsonnet.Version())
}

func usage(o io.Writer) {
	version(o)
	fmt.Fprintln(o)
	fmt.Fprintln(o, "jsonnet {<option>} <filename>")
	fmt.Fprintln(o)
	fmt.Fprintln(o, "Available options:")
	fmt.Fprintln(o, "  -h / --help             This message")
	fmt.Fprintln(o, "  -e / --exec             Treat filename as code")
	fmt.Fprintln(o, "  -J / --jpath <dir>      Specify an additional library search dir (right-most wins)")
	fmt.Fprintln(o, "  -o / --output-file <file> Write to the output file rather than stdout")
	fmt.Fprintln(o, "  -m / --multi <dir>      Write multiple files to the directory, list files on stdout")
	fmt.Fprintln(o, "  -c / --create-output-dirs  Automatically creates all parent directories for files")
	fmt.Fprintln(o, "  -y / --yaml-stream      Write output as a YAML stream of JSON documents")
	fmt.Fprintln(o, "  -S / --string           Expect a string, manifest as plain text")
	fmt.Fprintln(o, "  -s / --max-stack <n>    Number of allowed stack frames")
	fmt.Fprintln(o, "  -t / --max-trace <n>    Max length of stack trace before cropping")
	fmt.Fprintln(o, "  --version               Print version")
	fmt.Fprintln(o, "Available options for specifying values of 'external' variables:")
	fmt.Fprintln(o, "Provide the value as a string:")
	fmt.Fprintln(o, "  -V / --ext-str <var>[=<val>]     If <val> is omitted, get from environment var <var>")
	fmt.Fprintln(o, "       --ext-str-file <var>=<file> Read the string from the file")
	fmt.Fprintln(o, "Provide a value as Jsonnet code:")
	fmt.Fprintln(o, "  --ext-code <var>[=<code>]    If <code> is omitted, get from environment var <var>")
	fmt.Fprintln(o, "  --ext-code-file <var>=<file> Read the code from the file")
	fmt.Fprintln(o, "Available options for specifying values of 'top-level arguments':")
	fmt.Fprintln(o, "Provide the value as a string:")
	fmt.Fprintln(o, "  -A / --tla-str <var>[=<val>]     If <val> is omitted, get from environment var <var>")
	fmt.Fprintln(o, "       --tla-str-file <var>=<file> Read the string from the file")
	fmt.Fprintln(o, "Provide a value as Jsonnet code:")
	fmt.Fprintln(o, "  --tla-code <var>[=<code>]    If <code> is omitted, get from environment var <var>")
	fmt.Fprintln(o, "  --tla-code-file <var>=<file> Read the code from the file")
	fmt.Fprintln(o, "Environment variables:")
	fmt.Fprintln(o, "JSONNET_PATH is a colon (semicolon on Windows) separated list of directories added")
	fmt.Fprintln(o, "in reverse order before the paths specified by --jpath (i.e. left-most wins)")
	fmt.Fprintln(o, "E.g. JSONNET_PATH=a:b jsonnet -J c -J d is equivalent to:")
	fmt.Fprintln(o, "JSONNET_PATH=d:c:a:b jsonnet")
	fmt.Fprintln(o, "jsonnet -J b -J a -J c -J d")
	fmt.Fprintln(o)
	fmt.Fprintln(o, "In all cases:")
	fmt.Fprintln(o, "<filename> can be - (stdin)")
	fmt.Fprintln(o, "Multichar options are expanded e.g. -abc becomes -a -b -c.")
	fmt.Fprintln(o, "The -- option suppresses option processing for subsequent arguments.")
	fmt.Fprintln(o, "Note that since filenames and jsonnet programs can begin with -, it is advised to")
	fmt.Fprintln(o, "use -- if the argument is unknown, e.g. jsonnet -- \"$FILENAME\".")
}

func safeStrToInt(str string) (i int) {
	i, err := strconv.Atoi(str)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Invalid integer \"%s\"\n", str)
		os.Exit(1)
	}
	return
}

type config struct {
	inputFiles     []string
	outputFile     string
	filenameIsCode bool

	evalMulti            bool
	evalStream           bool
	evalMultiOutputDir   string
	evalCreateOutputDirs bool
	evalJpath            []string
}

func makeConfig() config {
	return config{
		filenameIsCode: false,
		evalMulti:      false,
		evalStream:     false,
		evalJpath:      []string{},
	}
}

func getVarVal(s string) (string, string, error) {
	parts := strings.SplitN(s, "=", 2)
	name := parts[0]
	if len(parts) == 1 {
		content, exists := os.LookupEnv(name)
		if exists {
			return name, content, nil
		}
		return "", "", fmt.Errorf("environment variable %v was undefined", name)
	}
	return name, parts[1], nil
}

func getVarFile(s string, imp string) (string, string, error) {
	parts := strings.SplitN(s, "=", 2)
	name := parts[0]
	if len(parts) == 1 {
		return "", "", fmt.Errorf(`argument not in form <var>=<file> "%s"`, s)
	}
	return name, fmt.Sprintf("%s @'%s'", imp, strings.Replace(parts[1], "'", "''", -1)), nil
}

type processArgsStatus int

const (
	processArgsStatusContinue     = iota
	processArgsStatusSuccessUsage = iota
	processArgsStatusFailureUsage = iota
	processArgsStatusSuccess      = iota
	processArgsStatusFailure      = iota
)

func processArgs(givenArgs []string, config *config, vm *jsonnet.VM) (processArgsStatus, error) {
	args := cmd.SimplifyArgs(givenArgs)
	remainingArgs := make([]string, 0, len(args))
	i := 0

	handleVarVal := func(handle func(key string, val string)) error {
		next := cmd.NextArg(&i, args)
		name, content, err := getVarVal(next)
		if err != nil {
			return err
		}
		handle(name, content)
		return nil
	}

	handleVarFile := func(handle func(key string, val string), imp string) error {
		next := cmd.NextArg(&i, args)
		name, content, err := getVarFile(next, imp)
		if err != nil {
			return err
		}
		handle(name, content)
		return nil
	}

	for ; i < len(args); i++ {
		arg := args[i]
		if arg == "-h" || arg == "--help" {
			return processArgsStatusSuccessUsage, nil
		} else if arg == "-v" || arg == "--version" {
			version(os.Stdout)
			return processArgsStatusSuccess, nil
		} else if arg == "-e" || arg == "--exec" {
			config.filenameIsCode = true
		} else if arg == "-o" || arg == "--output-file" {
			outputFile := cmd.NextArg(&i, args)
			if len(outputFile) == 0 {
				return processArgsStatusFailure, fmt.Errorf("-o argument was empty string")
			}
			config.outputFile = outputFile
		} else if arg == "--" {
			// All subsequent args are not options.
			i++
			for ; i < len(args); i++ {
				remainingArgs = append(remainingArgs, args[i])
			}
			break
		} else if arg == "-s" || arg == "--max-stack" {
			l := safeStrToInt(cmd.NextArg(&i, args))
			if l < 1 {
				return processArgsStatusFailure, fmt.Errorf("invalid --max-stack value: %d", l)
			}
			vm.MaxStack = l
		} else if arg == "-J" || arg == "--jpath" {
			dir := cmd.NextArg(&i, args)
			if len(dir) == 0 {
				return processArgsStatusFailure, fmt.Errorf("-J argument was empty string")
			}
			if dir[len(dir)-1] != '/' {
				dir += "/"
			}
			config.evalJpath = append(config.evalJpath, dir)
		} else if arg == "-V" || arg == "--ext-str" {
			if err := handleVarVal(vm.ExtVar); err != nil {
				return processArgsStatusFailure, err
			}
		} else if arg == "--ext-str-file" {
			if err := handleVarFile(vm.ExtCode, "importstr"); err != nil {
				return processArgsStatusFailure, err
			}
		} else if arg == "--ext-code" {
			if err := handleVarVal(vm.ExtCode); err != nil {
				return processArgsStatusFailure, err
			}
		} else if arg == "--ext-code-file" {
			if err := handleVarFile(vm.ExtCode, "import"); err != nil {
				return processArgsStatusFailure, err
			}
		} else if arg == "-A" || arg == "--tla-str" {
			if err := handleVarVal(vm.TLAVar); err != nil {
				return processArgsStatusFailure, err
			}
		} else if arg == "--tla-str-file" {
			if err := handleVarFile(vm.TLACode, "importstr"); err != nil {
				return processArgsStatusFailure, err
			}
		} else if arg == "--tla-code" {
			if err := handleVarVal(vm.TLACode); err != nil {
				return processArgsStatusFailure, err
			}
		} else if arg == "--tla-code-file" {
			if err := handleVarFile(vm.TLACode, "import"); err != nil {
				return processArgsStatusFailure, err
			}
		} else if arg == "-t" || arg == "--max-trace" {
			l := safeStrToInt(cmd.NextArg(&i, args))
			if l < 0 {
				return processArgsStatusFailure, fmt.Errorf("invalid --max-trace value: %d", l)
			}
			vm.ErrorFormatter.SetMaxStackTraceSize(l)
		} else if arg == "-m" || arg == "--multi" {
			config.evalMulti = true
			outputDir := cmd.NextArg(&i, args)
			if len(outputDir) == 0 {
				return processArgsStatusFailure, fmt.Errorf("-m argument was empty string")
			}
			if outputDir[len(outputDir)-1] != '/' {
				outputDir += "/"
			}
			config.evalMultiOutputDir = outputDir
		} else if arg == "-c" || arg == "--create-output-dirs" {
			config.evalCreateOutputDirs = true
		} else if arg == "-y" || arg == "--yaml-stream" {
			config.evalStream = true
		} else if arg == "-S" || arg == "--string" {
			vm.StringOutput = true
		} else if len(arg) > 1 && arg[0] == '-' {
			return processArgsStatusFailure, fmt.Errorf("unrecognized argument: %s", arg)
		} else {
			remainingArgs = append(remainingArgs, arg)
		}
	}

	want := "filename"
	if config.filenameIsCode {
		want = "code"
	}
	if len(remainingArgs) == 0 {
		return processArgsStatusFailureUsage, fmt.Errorf("must give %s", want)
	}

	// TODO(dcunnin): Formatter allows multiple files in test and in-place mode.
	multipleFilesAllowed := false

	if !multipleFilesAllowed {
		if len(remainingArgs) > 1 {
			return processArgsStatusFailure, fmt.Errorf("only one %s is allowed", want)
		}
	}

	config.inputFiles = remainingArgs
	return processArgsStatusContinue, nil
}

func writeMultiOutputFiles(output map[string]string, outputDir, outputFile string, createDirs bool) (err error) {
	// If multiple file output is used, then iterate over each string from
	// the sequence of strings returned by jsonnet_evaluate_snippet_multi,
	// construct pairs of filename and content, and write each output file.

	var manifest *os.File

	if outputFile == "" {
		manifest = os.Stdout
	} else {
		manifest, err = os.Create(outputFile)
		if err != nil {
			return err
		}
		defer func() {
			if ferr := manifest.Close(); err != nil {
				err = ferr
			}
		}()
	}

	// Iterate through the map in order.
	keys := make([]string, 0, len(output))
	for k := range output {
		keys = append(keys, k)
	}
	sort.Strings(keys)
	for _, key := range keys {
		newContent := output[key]
		filename := outputDir + key

		_, err := manifest.WriteString(filename)
		if err != nil {
			return err
		}

		_, err = manifest.WriteString("\n")
		if err != nil {
			return err
		}

		if _, err := os.Stat(filename); !os.IsNotExist(err) {
			existingContent, err := ioutil.ReadFile(filename)
			if err != nil {
				return err
			}
			if string(existingContent) == newContent {
				// Do not bump the timestamp on the file if its content is
				// the same. This may trigger other tools (e.g. make) to do
				// unnecessary work.
				continue
			}
		}
		if createDirs {
			if err := os.MkdirAll(filepath.Dir(filename), 0755); err != nil {
				return err
			}
		}

		f, err := os.Create(filename)
		if err != nil {
			return err
		}
		defer func() {
			if ferr := f.Close(); err != nil {
				err = ferr
			}
		}()

		_, err = f.WriteString(newContent)
		if err != nil {
			return err
		}
	}

	return nil
}

// writeOutputStream writes the output as a YAML stream.
func writeOutputStream(output []string, outputFile string) (err error) {
	var f *os.File

	if outputFile == "" {
		f = os.Stdout
	} else {
		f, err = os.Create(outputFile)
		if err != nil {
			return err
		}
		defer func() {
			if ferr := f.Close(); err != nil {
				err = ferr
			}
		}()
	}

	for _, doc := range output {
		_, err := f.WriteString("---\n")
		if err != nil {
			return err
		}
		_, err = f.WriteString(doc)
		if err != nil {
			return err
		}
	}

	if len(output) > 0 {
		_, err := f.WriteString("...\n")
		if err != nil {
			return err
		}
	}

	return nil
}

func main() {
	cmd.StartCPUProfile()
	defer cmd.StopCPUProfile()

	vm := jsonnet.MakeVM()
	vm.ErrorFormatter.SetColorFormatter(color.New(color.FgRed).Fprintf)

	config := makeConfig()
	jsonnetPath := filepath.SplitList(os.Getenv("JSONNET_PATH"))
	for i := len(jsonnetPath) - 1; i >= 0; i-- {
		config.evalJpath = append(config.evalJpath, jsonnetPath[i])
	}

	status, err := processArgs(os.Args[1:], &config, vm)
	if err != nil {
		fmt.Fprintln(os.Stderr, "ERROR: "+err.Error())
	}
	switch status {
	case processArgsStatusContinue:
		break
	case processArgsStatusSuccessUsage:
		usage(os.Stdout)
		os.Exit(0)
	case processArgsStatusFailureUsage:
		if err != nil {
			fmt.Fprintln(os.Stderr, "")
		}
		usage(os.Stderr)
		os.Exit(1)
	case processArgsStatusSuccess:
		os.Exit(0)
	case processArgsStatusFailure:
		os.Exit(1)
	}

	vm.Importer(&jsonnet.FileImporter{
		JPaths: config.evalJpath,
	})

	if len(config.inputFiles) != 1 {
		// Should already have been caught by processArgs.
		panic("Internal error: expected a single input file.")
	}
	filename := config.inputFiles[0]
	input := cmd.SafeReadInput(config.filenameIsCode, &filename)
	var output string
	var outputArray []string
	var outputDict map[string]string
	if config.evalMulti {
		outputDict, err = vm.EvaluateSnippetMulti(filename, input)
	} else if config.evalStream {
		outputArray, err = vm.EvaluateSnippetStream(filename, input)
	} else {
		output, err = vm.EvaluateSnippet(filename, input)
	}

	cmd.MemProfile()

	if err != nil {
		fmt.Fprintln(os.Stderr, err.Error())
		os.Exit(1)
	}

	// Write output JSON.
	if config.evalMulti {
		err := writeMultiOutputFiles(outputDict, config.evalMultiOutputDir, config.outputFile, config.evalCreateOutputDirs)
		if err != nil {
			fmt.Fprintln(os.Stderr, err.Error())
			os.Exit(1)
		}
	} else if config.evalStream {
		err := writeOutputStream(outputArray, config.outputFile)
		if err != nil {
			fmt.Fprintln(os.Stderr, err.Error())
			os.Exit(1)
		}
	} else {
		err := cmd.WriteOutputFile(output, config.outputFile, config.evalCreateOutputDirs)
		if err != nil {
			fmt.Fprintln(os.Stderr, err.Error())
			os.Exit(1)
		}
	}

}
