// Copyright (C) 2015 The Android Open Source Project
//
// 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.

// The fab command is used to build the gpu project.
package main

import (
	"flag"
	"fmt"
	"os"
	"strings"

	"android.googlesource.com/platform/tools/gpu/build"
	. "android.googlesource.com/platform/tools/gpu/maker"
)

var noapic = flag.Bool("noapic", false, "Disable apic code generation")

func main() { Run() }

const (
	GPURoot = "android.googlesource.com/platform/tools/gpu"
)

var (
	glespath     = Path(gpusrc, "gfxapi/gles")
	gapirpath    = Path(gpusrc, "cc/gapir")
	gapiipath    = Path(gpusrc, "cc/gapii")
	gapiiwinpath = Path(gpusrc, "cc/gapii/windows")
	gapiiosxpath = Path(gpusrc, "cc/gapii/osx")
	cppcoder     = Path(gpusrc, "cc/gapic/coder")
	testpath     = Path(gpusrc, "gfxapi/test")
	glesapi      = Path(gpusrc, "gfxapi/gles/gles.api")
	testapi      = Path(gpusrc, "gfxapi/test/gfxapi_test.api")
	javabase     = Path(Paths.Root, "../")
	javarpc      = Path(javabase, "adt/idea/android/src/com/android/tools/idea/editors/gfxtrace/rpc")
	gpusrc       = GoSrcPath(GPURoot)

	Tools struct {
		Embed    Entity
		Rpcapi   Entity
		Apic     Entity
		Codergen Entity
	}

	Apps struct {
		Gapis Entity
		Gapir Entity
		Gapid Entity
	}
)

func init() {
	Register(func() {
		// Install rules for the build tools
		Tools.Embed = GoInstall(GPURoot + "/tools/embed")
		Tools.Rpcapi = GoInstall(GPURoot + "/rpc/rpcapi")
		Tools.Apic = GoInstall(GPURoot + "/api/apic")
		Tools.Codergen = GoInstall(GPURoot + "/binary/codergen")
		List("tools").DependsStruct(Tools)
		// All the embed rules
		embedRPC := Embed(Path(gpusrc, "rpc/generate"))
		embedCopyright := Embed(Path(gpusrc, "tools/copyright"))
		embedBinary := Embed(Path(gpusrc, "binary/generate"))
		Creator(Tools.Rpcapi).DependsOn(embedCopyright, embedRPC)
		Creator(Tools.Apic).DependsOn(embedCopyright)
		Creator(Tools.Codergen).DependsOn(embedCopyright, embedBinary)
		// All the rpc rules
		servicerpc := File(gpusrc, "service/service.api")
		RpcApiGo(File(gpusrc, "rpc/test/rpc_test.api"))
		RpcApiGo(servicerpc)
		// All the apic rules
		Apic(glespath, glesapi, Path(gpusrc, "gfxapi/templates/api.go.tmpl"))
		Apic(glespath, glesapi, Path(gpusrc, "gfxapi/templates/replay_writer.go.tmpl"))
		Apic(glespath, glesapi, Path(gpusrc, "gfxapi/templates/schema.go.tmpl"))
		Apic(glespath, glesapi, Path(gpusrc, "gfxapi/templates/state_mutator.go.tmpl"))
		Apic(gapirpath, glesapi, Path(gpusrc, "gfxapi/templates/gfx_api.cpp.tmpl"))
		Apic(gapirpath, glesapi, Path(gpusrc, "gfxapi/templates/gfx_api.h.tmpl"))
		Apic(gapiipath, glesapi, Path(gpusrc, "gfxapi/templates/api_exports.cpp.tmpl"))
		Apic(gapiipath, glesapi, Path(gpusrc, "gfxapi/templates/api_imports.cpp.tmpl"))
		Apic(gapiipath, glesapi, Path(gpusrc, "gfxapi/templates/api_imports.h.tmpl"))
		Apic(gapiipath, glesapi, Path(gpusrc, "gfxapi/templates/api_spy.h.tmpl"))
		Apic(gapiipath, glesapi, Path(gpusrc, "gfxapi/templates/api_types.h.tmpl"))
		Apic(gapiiwinpath, glesapi, Path(gpusrc, "gfxapi/templates/opengl32_exports.def.tmpl"))
		Apic(gapiiwinpath, glesapi, Path(gpusrc, "gfxapi/templates/opengl32_resolve.cpp.tmpl"))
		Apic(gapiiwinpath, glesapi, Path(gpusrc, "gfxapi/templates/opengl32_x64.asm.tmpl"))
		Apic(gapiiosxpath, glesapi, Path(gpusrc, "gfxapi/templates/opengl_framework_exports.cpp.tmpl"))
		Apic(testpath, testapi, Path(gpusrc, "gfxapi/templates/api.go.tmpl"))
		Apic(testpath, testapi, Path(gpusrc, "gfxapi/templates/replay_writer.go.tmpl"))
		Apic(testpath, testapi, Path(gpusrc, "gfxapi/templates/schema.go.tmpl"))
		Apic(testpath, testapi, Path(gpusrc, "gfxapi/templates/state_mutator.go.tmpl"))
		// The codergen rule
		Codergen("codergen", "--go", "--java", javabase, "-cpp", cppcoder, GPURoot+"/...")
		// The java code generation rules
		RpcApi("--java", javarpc, servicerpc).Creates(Virtual("javarpc"))
		List("java").DependsOn("codergen", "javarpc")
		//
		List("code").DependsOn("embed", "rpcapi", "apic", "codergen")
		// The native code rules
		Apps.Gapir = Virtual("gapir")
		cctargets := build.HostOS
		if os.Getenv("ANDROID_NDK_ROOT") != "" {
			cctargets += ",android-arm,android-arm64"
		}
		GoRun(Path(gpusrc, "cc/build.go"),
			"--runtests",
			"--targets="+cctargets,
		).Creates(Apps.Gapir).DependsOn("code")
		// The testing rules
		gotest := GoTest(GPURoot + "/...")
		Creator(gotest).DependsOn("code", Apps.Gapir)
		List("test").DependsOn(gotest)
		// The main binary rules
		Apps.Gapis = GoInstall(GPURoot + "/server/gapis")
		Creator(Apps.Gapis).DependsOn("code")
		Apps.Gapid = GoInstall(GPURoot + "/_experimental/client/gapid")
		Creator(Apps.Gapid).DependsOn("codergen")
		List("apps").DependsStruct(Apps)
		// Application launchers
		Command(Apps.Gapis).Creates(Virtual("gapis")).DependsOn(Apps.Gapir)
		Command(Apps.Gapid, "--gxuidebug").Creates(Virtual("gapid")).DependsOn(Apps.Gapis, Apps.Gapir)
		// Utilties
		GoRun(Path(gpusrc, "tools/clean_generated/main.go"), gpusrc).Creates(Virtual("clean_gpu"))
		GoRun(Path(gpusrc, "tools/copyright/copyright/main.go"), "-o", gpusrc).Creates(Virtual("copyright")).DependsOn(embedCopyright)
		// The default rules
		List(Default).DependsOn("apps", "test")
	})
}

func Embed(path string) Entity {
	out := File(path, "embed.go")
	args := []string{"--out", out.Name()}
	files := FilesOf(path, func(i os.FileInfo) bool {
		return !i.IsDir() && !strings.HasSuffix(i.Name(), ".go") && !strings.HasSuffix(i.Name(), ".md")
	})
	for _, f := range files {
		args = append(args, f.Name())
	}
	s := Command(Tools.Embed, args...).Creates(out)
	for _, f := range files {
		s.DependsOn(f)
	}
	List("embed").DependsOn(out)
	return out
}

func RpcApiGo(api Entity) {
	out := File(strings.TrimSuffix(api.Name(), ".api") + "_rpc.go")
	RpcApi("--go", DirOf(api).Name(), api).Creates(out)
	List("rpcapi").DependsOn(out)
}

func RpcApi(language string, path string, api Entity) *Step {
	return Command(Tools.Rpcapi, "--dir", path, language, api.Name()).DependsOn(api)
}

func Apic(path string, api string, template string) {
	if *noapic {
		List("apic").DependsOn(Tools.Apic)
		return
	}
	dst := Dir(path)
	a := File(api)
	t := File(template)
	_, apiname := PathSplit(api)
	_, templatename := PathSplit(template)
	deps := File(Paths.Deps, fmt.Sprintf("%v_%v.deps", apiname, templatename))
	s := Command(Tools.Apic,
		"template",
		"--dir", dst.Name(),
		"--deps", deps.Name(),
		a.Name(), t.Name()).DependsOn(a, t, dst)
	s.UseDepsFile(deps)
	List("apic").DependsOn(deps)
}

func Codergen(name string, args ...string) {
	Command(Tools.Codergen, args...).Creates(Virtual(name)).DependsOn("rpcapi", "apic").Access(GoPkgResources)
}