// 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 main

import (
	"bytes"
	"fmt"
	"os"
	"path"
	"path/filepath"
	"strings"
	"text/template"

	"v.io/jiri"
	"v.io/jiri/profiles"
)

const singleHeaderTmpl = `/* Created by jiri-swift - DO NOT EDIT. */

/* Start of preamble from import "C" comments.  */

{{.Includes}}
#import "go_types.h"

// These sizes (including C struct memory alignment/padding) isn't available from Go, so we make that available via CGo.
{{.Typedefs}}

/* End of preamble from import "C" comments.  */

/* Start of boilerplate cgo prologue.  */

{{.Prologue}}

/* End of boilerplate cgo prologue.  */

#ifdef __cplusplus
extern "C"
#endif

{{.Exports}}

#ifdef __cplusplus
}
#endif
`

func runBuildCgo(jirix *jiri.X) error {
	// Copy over dependent libraries.
	if flagBuildDirCgo == "" {
		flagBuildDirCgo = sh.MakeTempDir()
	}
	sh.Pushd(flagBuildDirCgo)

	for _, targetArch := range targetArchs {
		cleanOldCompiledFiles(jirix, targetArch)
		compileCgo(jirix, targetArch)
		installCgoBinary(jirix, targetArch)
		if err := copyLinkedLibraries(jirix, targetArch); err != nil {
			return err
		}
	}

	copyCommonHeaders(jirix)

	// Grab either the main arch we're building for or just the first -- we just need to make sure
	// it's one that will have headers generated for it.
	return generateSingleHeader(jirix, targetArchs[0])
}

func cleanOldCompiledFiles(jirix *jiri.X, targetArch string) {
	d := filepath.Join(jirix.Root, "release/go/pkg", "darwin_"+targetArch, "v.io")
	if !pathExists(d) {
		verbose(jirix, "Previously built go binaries & headers directory doesn't exist, nothing to remove: %v\n", d)
		return
	}
	sanityCheckDir(d)
	verbose(jirix, "Removing compiled go files and headers in path %v\n", d)
	if err := os.RemoveAll(d); err != nil {
		panic(fmt.Sprint("Unable to remove old compiled files:", err))
	}
}

func compileCgo(jirix *jiri.X, targetArch string) {
	targetFlag := targetArch + "-ios"
	verbose(jirix, "Building for project %v target %v with build mode %v in dir %v\n", selectedProject.name, targetFlag, flagBuildMode, flagBuildDirCgo)
	// Create the binary
	bp := buildBinaryPath(targetArch)
	verbose(jirix, "Running jiri go -target %v build -buildmode=%v -tags ios -o %v %v\n", targetFlag, flagBuildMode, bp, selectedProject.mainPackage)
	sh.Cmd("jiri", "go", "-target", targetFlag, "build", "-buildmode="+flagBuildMode, "-tags", "ios", "-o", bp, selectedProject.mainPackage).Run()
	// If the package is simple enough it'll also generate a header -- we'll use the installed
	// headers instead (as its more universal), so we can delete this generated header now if
	// it exists.
	b := strings.TrimSuffix(bp, filepath.Ext(bp))
	os.RemoveAll(b + ".h")
	// Now make sure the headers are created/generated in our go/pkg directory for a later step.
	verbose(jirix, "Running jiri go -target %v install -buildmode=%v -tags ios %v\n", targetFlag, flagBuildMode, selectedProject.mainPackage)
	sh.Cmd("jiri", "go", "-target", targetFlag, "install", "-buildmode="+flagBuildMode, "-tags", "ios", selectedProject.mainPackage).Run()
}

func buildBinaryPath(targetArch string) string {
	bn := path.Join(flagBuildDirCgo, selectedProject.libraryBinaryName+"_"+targetArch)
	switch flagBuildMode {
	case buildModeArchive:
		return bn + ".a"
	case buildModeShared:
		return bn + ".dylib"
	default:
		panic("Unknown build mode")
	}
}

func installCgoBinary(jirix *jiri.X, targetArch string) {
	// Install it to the Swift target directory
	swiftTargetDir := getSwiftTargetDir(jirix)
	sh.Cmd("mkdir", "-p", swiftTargetDir).Run()

	var destLibPath string
	switch flagBuildMode {
	case buildModeArchive:
		a := fmt.Sprintf("%v_%v.a", selectedProject.libraryBinaryName, targetArch)
		destLibPath = path.Join(swiftTargetDir, a)
		sh.Cmd("mv", buildBinaryPath(targetArch), destLibPath).Run()
	case buildModeShared:
		dylib := fmt.Sprintf("%v_%v.dylib", selectedProject.libraryBinaryName, targetArch)
		destLibPath = path.Join(swiftTargetDir, dylib)
		sh.Cmd("mv", buildBinaryPath(targetArch), destLibPath).Run()
		sh.Cmd("install_name_tool", "-id", "@loader_path/"+dylib, destLibPath).Run()
	}
	verbose(jirix, "Installed binary at %v\n", destLibPath)
	verifyCgoBinaryArchOrPanic(destLibPath, targetArch)
}

// copyLinkedLibraries will look at the project-specific profile requirements (like v23:syncbase) to find
// any static libraries in the profile that Go might have linked to via CGO_LDFLAGS, and then copy these
// static archives to the target directory. This allows Xcode to be able to directly link to a local copy
// of these files as CGO doesn't statically link the libraries. While it might seem like a bug, it's
// actually a feature: it allows us to distribute a version of a framework without potentially-conflicting
// dependencies like LevelDB should the end-user wish to provide their own copy (or already has another
// library that has statically-linked it).
func copyLinkedLibraries(jirix *jiri.X, targetArch string) error {
	if len(selectedProject.jiriProfiles) == 0 {
		// No files to copy over
		verbose(jirix, "No jiri profiles associated with project; not copying any linked static libs\n")
		return nil
	}
	// Load jiri profiles database
	db := profiles.NewDB()
	if err := db.Read(jirix, jirix.ProfilesDBDir()); err != nil {
		return fmt.Errorf("failed to read profiles db at path %v: %v", jirix.ProfilesDBDir(), err)
	}
	// Copy any profile's static libraries over
	for _, pn := range selectedProject.jiriProfiles {
		// Get profile
		splitPn := strings.Split(pn, ":")
		if len(splitPn) != 2 {
			return fmt.Errorf("did not understand jiri profile %v -- expected format is <installer>:<name>", pn)
		}
		p := db.LookupProfile(splitPn[0], splitPn[1])
		if p == nil {
			return fmt.Errorf("unable to find profile %v", pn)
		}
		// Find target for this architecture & os
		var target *profiles.Target
		for _, t := range p.Targets() {
			if t.Arch() != targetArch {
				continue
			}
			if t.OS() != "ios" {
				continue
			}
			target = t
		}
		if target == nil {
			return fmt.Errorf("couldn't find target arch %v in targets %v for profile %v", targetArch, p.Targets(), pn)
		}
		copyLinkedLibrariesForTarget(jirix, target)
	}
	return nil
}

// copyLinkedLibrariesForTarget copies any static libraries included on the
// CGO_LDFLAGS to our target directory to make it easy to link to (or
// distribute as its own library) in Xcode.
func copyLinkedLibrariesForTarget(jirix *jiri.X, target *profiles.Target) {
	libs := findStaticLibsInDirs(findLibDirsInTargetEnv(jirix, target))
	for _, l := range libs {
		// Convert path to dst/libname_arch.a
		bn := filepath.Base(l)
		bn = strings.Trim(bn, filepath.Ext(bn))
		dst := filepath.Join(getSwiftTargetDir(jirix), fmt.Sprintf("%v_%v.a", bn, target.Arch()))
		verbose(jirix, "Copying %v to %v\n", l, dst)
		sh.Cmd("cp", l, dst).Run()
	}
}

// findLibDirsInTargetEnv parses a profile target's CGO_LDFLAGS for any included
// library dirs, intersects them with the target's installation dir (to make sure
// we only get our own locally-built and not system-wide libraries), and returns
// these absolute paths. For example it will return the directories associated
// with target architecture's compiled static archives of LevelDB and Snappy
// when searching the v23:syncbase profile target.
func findLibDirsInTargetEnv(jirix *jiri.X, t *profiles.Target) []string {
	var dirs []string
	for _, v := range t.Env.Vars {
		if !strings.HasPrefix(v, "CGO_LDFLAGS") {
			continue
		}
		dirs = strings.Split(v, "-L")
		break
	}
	if len(dirs) == 0 {
		return dirs
	}
	var paths []string
	for _, d := range dirs {
		i := strings.Index(d, t.InstallationDir)
		if i == -1 {
			continue
		}
		d = filepath.Join(jirix.Root, strings.TrimSpace(d[i:]))
		paths = append(paths, d)
	}
	return paths
}

// findStaticLibsInDirs walks a slice of directories searching for static archives
// (files that end with .a), and returns those as a string slice.
func findStaticLibsInDirs(dirs []string) []string {
	var libs []string
	for _, d := range dirs {
		filepath.Walk(d, func(path string, f os.FileInfo, err error) error {
			if strings.HasSuffix(path, ".a") {
				libs = append(libs, path)
			}
			return nil
		})
	}
	return libs
}

func copyCommonHeaders(jirix *jiri.X) {
	verbose(jirix, "Copying common shared headers between Swift and Go\n")
	// Take types.h and make it into go_types.h
	sh.Cmd("cp", path.Join(jirix.Root, selectedProject.commonHeaderPath), path.Join(getSwiftTargetDir(jirix), "go_types.h")).Run()
}

func generateSingleHeader(jirix *jiri.X, targetArch string) error {
	verbose(jirix, "Generating header for Swift\n")
	// Load and parse all the headers
	generatedHeadersDir := fmt.Sprintf("%v/release/go/pkg/darwin_%v/%v", jirix.Root, targetArch, selectedProject.exportedHeadersPackageRoot)
	generatedHeadersPaths := findHeadersUnderPath(generatedHeadersDir)
	hdrs := cgoHeaders{}
	for _, file := range generatedHeadersPaths {
		hdr, err := newCgoHeader(jirix, file)
		if err != nil {
			return err
		}
		hdrs = append(hdrs, hdr)
	}
	// Generate the header
	data := struct {
		Includes string
		Typedefs string
		Prologue string
		Exports  string
	}{
		Includes: strings.Join(hdrs.includes(), "\n"),
		Typedefs: strings.Join(hdrs.typedefs(), "\n"),
		Prologue: strings.Join(hdrs[0].prologue, "\n"), // Grab the first -- it is sufficient and complete.
		Exports:  strings.Join(hdrs.exports(), "\n"),
	}
	tmpl := template.Must(template.New("singleCgoHeader").Parse(singleHeaderTmpl))
	var buf bytes.Buffer
	if err := tmpl.Execute(&buf, data); err != nil {
		return err
	}
	// Write it to disk
	combinedHdrPath := path.Join(getSwiftTargetDir(jirix), "cgo_exports.h")
	verbose(jirix, "Writing generated merged header to %v\n", combinedHdrPath)
	// Remove the old file if it exists
	if err := os.RemoveAll(combinedHdrPath); err != nil {
		return err
	}
	f, err := os.Create(combinedHdrPath)
	if err != nil {
		return err
	}
	if _, err := buf.WriteTo(f); err != nil {
		return err
	}
	return nil
}