// Copyright 2015 The Vanadium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package java_profile

import (
	"bufio"
	"bytes"
	"errors"
	"flag"
	"fmt"
	"os"
	"path/filepath"
	"strings"

	"v.io/jiri"
	"v.io/jiri/profiles"
	"v.io/jiri/profiles/profilesmanager"
	"v.io/jiri/profiles/profilesreader"
	"v.io/x/lib/envvar"
)

type versionSpec struct {
	jdkVersion string
}

func Register(installer, profile string) {
	m := &Manager{
		profileInstaller: installer,
		profileName:      profile,
		qualifiedName:    profiles.QualifiedProfileName(installer, profile),
		versionInfo: profiles.NewVersionInfo(profile, map[string]interface{}{
			"1.7+": versionSpec{"1.7+"},
			"1.8+": versionSpec{"1.8+"},
		}, "1.8+"),
	}
	profilesmanager.Register(m)
}

type Manager struct {
	profileInstaller, profileName, qualifiedName string
	root, javaRoot                               jiri.RelPath
	versionInfo                                  *profiles.VersionInfo
	spec                                         versionSpec
}

func (m Manager) Name() string {
	return m.profileName
}

func (m Manager) Installer() string {
	return m.profileInstaller
}

func (m Manager) String() string {
	return fmt.Sprintf("%s[%s]", m.qualifiedName, m.versionInfo.Default())
}

func (m Manager) Info() string {
	return `
The java profile provides support for Java and in particular installs java related
tools such as gradle. It does not install a jre, but rather attempts to locate one
on the current system and prompts the user to install it if not present. It also
installs the android profile since android is the primary use of Java. It only
supports a single target of 'arm-android' and assumes it as the default.`
}

func (m Manager) VersionInfo() *profiles.VersionInfo {
	return m.versionInfo
}

func (m *Manager) AddFlags(flags *flag.FlagSet, action profiles.Action) {
}

func (m *Manager) initForTarget(root jiri.RelPath, target profiles.Target) error {
	m.root = root
	m.javaRoot = root.Join("java")
	if err := m.versionInfo.Lookup(target.Version(), &m.spec); err != nil {
		return err
	}
	return nil
}

func (m *Manager) OSPackages(jirix *jiri.X, pdb *profiles.DB, root jiri.RelPath, target profiles.Target) ([]string, error) {
	switch target.OS() {
	case "darwin", "linux":
		return []string{"gradle"}, nil
	default:
		return nil, fmt.Errorf("OS %q is not supported", target.OS())
	}
}

func (m *Manager) Install(jirix *jiri.X, pdb *profiles.DB, root jiri.RelPath, target profiles.Target) error {
	if err := m.initForTarget(root, target); err != nil {
		return err
	}

	javaHome, err := m.install(jirix, target)
	if err != nil {
		return err
	}
	baseTarget := target
	baseTarget.SetVersion("")
	if err := profilesmanager.EnsureProfileTargetIsInstalled(jirix, pdb, m.profileInstaller, "base", root, baseTarget); err != nil {
		return err
	}
	// NOTE(spetrovic): For now, we install android profile along with Java,
	// as the two are bundled up for ease of development.
	androidArmTarget, err := profiles.NewTarget("arm-android", "")
	if err != nil {
		return err
	}
	if err := profilesmanager.EnsureProfileTargetIsInstalled(jirix, pdb, m.profileInstaller, "android", root, androidArmTarget); err != nil {
		return err
	}
	androidAmd64Target, err := profiles.NewTarget("amd64-android", "")
	if err != nil {
		return err
	}
	if err := profilesmanager.EnsureProfileTargetIsInstalled(jirix, pdb, m.profileInstaller, "android", root, androidAmd64Target); err != nil {
		return err
	}

	// Merge the environments using those in the target as the base
	// with those from the base profile and then the java ones
	// we want to set here.
	env := envvar.VarsFromSlice(target.Env.Vars)
	javaProfileEnv := []string{
		fmt.Sprintf("CGO_CFLAGS=-I%s -I%s", filepath.Join(javaHome, "include"),
			filepath.Join(javaHome, "include", target.OS())),
		"JAVA_HOME=" + javaHome,
	}

	baseProfileEnv := pdb.EnvFromProfile(m.profileInstaller, "base", baseTarget)
	profilesreader.MergeEnv(profilesreader.ProfileMergePolicies(), env, baseProfileEnv, javaProfileEnv)
	target.Env.Vars = env.ToSlice()
	target.InstallationDir = javaHome
	pdb.InstallProfile(m.profileInstaller, m.profileName, string(m.javaRoot))
	return pdb.AddProfileTarget(m.profileInstaller, m.profileName, target)
}

func (m *Manager) Uninstall(jirix *jiri.X, pdb *profiles.DB, root jiri.RelPath, target profiles.Target) error {
	if err := m.initForTarget(root, target); err != nil {
		return err
	}
	if err := jirix.NewSeq().RemoveAll(m.javaRoot.Abs(jirix)).Done(); err != nil {
		return err
	}
	pdb.RemoveProfileTarget(m.profileInstaller, m.profileName, target)
	return nil
}

func (m *Manager) install(jirix *jiri.X, target profiles.Target) (string, error) {
	switch target.OS() {
	case "darwin":
		javaHome, err := getJDKDarwin(jirix, m.spec)
		if err == nil {
			return javaHome, nil
		}
		fmt.Fprintf(os.Stderr, "Couldn't find an existing Java installation: %v", err)

		// Prompt the user to install JDK.
		// (Note that JDK cannot be installed via Homebrew.)
		javaHomeBin := "/usr/libexec/java_home"
		jirix.NewSeq().Last(javaHomeBin, "-t", "CommandLine", "--request")
		return "", fmt.Errorf("Please follow the OS X prompt instructions to install JDK, then set JAVA_HOME and re-run the profile installation command.")
	case "linux":
		javaHome, err := getJDKLinux(jirix, m.spec)
		if err == nil {
			return javaHome, nil
		}
		fmt.Fprintf(os.Stderr, "Couldn't find an existing Java installation: %v", err)

		// Prompt the user to install JDK.
		// (Note that Oracle JDKs cannot be installed via apt-get.)
		dlURL := "http://www.oracle.com/technetwork/java/javase/downloads/index.html"
		jirix.NewSeq().Last("xdg-open", dlURL)
		return "", fmt.Errorf("Please follow the instructions in the browser to install JDK, then set JAVA_HOME and re-run the profile installation command")
	default:
		return "", fmt.Errorf("OS %q is not supported", target.OS())
	}
}

func checkInstall(jirix *jiri.X, home, version string) error {
	s := jirix.NewSeq()
	if _, err := s.Stat(filepath.Join(home, "include", "jni.h")); err != nil {
		return err
	}
	var out bytes.Buffer
	javacPath := filepath.Join(home, "bin", "javac")
	if err := s.Capture(&out, &out).Last(javacPath, "-version"); err != nil {
		return err
	}
	if out.Len() == 0 {
		return errors.New("couldn't find a valid javac at: " + javacPath)
	}
	javacVersion := strings.TrimPrefix(out.String(), "javac ")
	if !strings.HasPrefix(javacVersion, strings.TrimSuffix(version, "+")) {
		return fmt.Errorf("want javac version %v, got %v from output %v.", version, javacVersion, out.String())
	}
	return nil
}

func getJDKLinux(jirix *jiri.X, spec versionSpec) (string, error) {
	if javaHome := os.Getenv("JAVA_HOME"); len(javaHome) > 0 {
		err := checkInstall(jirix, javaHome, spec.jdkVersion)
		if err == nil {
			return javaHome, nil
		}
		fmt.Fprintf(os.Stderr, "JAVA_HOME (%s) is incompatible with required profile version: %v; trying to find a compatible system installation.", javaHome, err)
		defer fmt.Fprint(os.Stderr, "Done looking for system installation.")
	}
	// JAVA_HOME doesn't point to the right version: check the system installation.
	javacBin := "/usr/bin/javac"
	var out bytes.Buffer
	if err := jirix.NewSeq().Capture(&out, &out).Last("readlink", "-f", javacBin); err != nil {
		return "", err
	}
	if out.Len() == 0 {
		return "", errors.New("No Java installed under /usr/bin/javac")
	}
	// Strip "/bin/javac" from the returned path.
	javaHome := strings.TrimSuffix(out.String(), "/bin/javac\n")
	if err := checkInstall(jirix, javaHome, spec.jdkVersion); err != nil {
		return "", errors.New("Java installed in /usr/bin/javac is incompatible with profile version: " + spec.jdkVersion)
	}
	return javaHome, nil
}

func getJDKDarwin(jirix *jiri.X, spec versionSpec) (string, error) {
	if javaHome := os.Getenv("JAVA_HOME"); len(javaHome) > 0 {
		err := checkInstall(jirix, javaHome, spec.jdkVersion)
		if err == nil {
			return javaHome, nil
		}
		fmt.Fprintf(os.Stderr, "JAVA_HOME (%s) is incompatible with required profile version %v; trying to find a compatible system installation", javaHome, err)
		defer fmt.Fprint(os.Stderr, "Done looking for system installation.")
	}
	// JAVA_HOME doesn't point to the right version: check the system installation.
	javaHomeBin := "/usr/libexec/java_home"
	var out bytes.Buffer
	if err := jirix.NewSeq().Capture(&out, &out).Last(javaHomeBin, "-t", "CommandLine", "-v", spec.jdkVersion); err != nil {
		return "", err
	}
	if out.Len() == 0 {
		return "", errors.New("Couldn't find a valid Java system installation.")
	}
	jdkLoc, _, err := bufio.NewReader(strings.NewReader(out.String())).ReadLine()
	if err != nil {
		return "", fmt.Errorf("Couldn't find a valid Java system installation: %v", err)
	}
	if err := checkInstall(jirix, string(jdkLoc), spec.jdkVersion); err != nil {
		return "", fmt.Errorf("Java system installation is incompatible with profile version %s: %v", spec.jdkVersion, err)
	}
	return string(jdkLoc), nil
}