// Copyright 2022 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.

package main

import (
	"bufio"
	"context"
	"encoding/json"
	"errors"
	"flag"
	"fmt"
	"io"
	"log"
	"os"
	"runtime"
	"strings"
	"time"

	"tools/treble/build/report/app"
	"tools/treble/build/report/local"
	"tools/treble/build/report/report"
)

type Build interface {
	Build(ctx context.Context, target string) *app.BuildCmdResult
}

type tool interface {
	Run(ctx context.Context, rtx *report.Context, rsp *response) error
	PrintText(w io.Writer, rsp *response, verbose bool)
}
type repoFlags []app.ProjectCommit

func (r *repoFlags) Set(value string) error {
	commit := app.ProjectCommit{}
	items := strings.Split(value, ":")
	if len(items) > 2 {
		return (errors.New("Invalid repo value expected (proj:sha) format"))
	}
	commit.Project = items[0]
	if len(items) > 1 {
		commit.Revision = items[1]
	}
	*r = append(*r, commit)
	return nil
}
func (r *repoFlags) String() string {
	items := []string{}
	for _, fl := range *r {
		items = append(items, fmt.Sprintf("%s:%s", fl.Project, fl.Revision))
	}
	return strings.Join(items, " ")
}

var (
	// Common flags
	ninjaDbPtr          = flag.String("ninja", local.DefNinjaDb(), "Set the .ninja file to use when building metrics")
	ninjaExcPtr         = flag.String("ninja_cmd", local.DefNinjaExc(), "Set the ninja executable")
	ninjaTimeoutStr     = flag.String("ninja_timeout", local.DefaultNinjaTimeout, "Default ninja timeout")
	buildTimeoutStr     = flag.String("build_timeout", local.DefaultNinjaBuildTimeout, "Default build timeout")
	manifestPtr         = flag.String("manifest", local.DefManifest(), "Set the location of the manifest file")
	upstreamPtr         = flag.String("upstream", "", "Upstream branch to compare files against")
	repoBasePtr         = flag.String("repo_base", local.DefRepoBase(), "Set the repo base directory")
	workerCountPtr      = flag.Int("worker_count", runtime.NumCPU(), "Number of worker routines")
	buildWorkerCountPtr = flag.Int("build_worker_count", local.MaxNinjaCliWorkers, "Number of build worker routines")
	clientServerPtr     = flag.Bool("client_server", false, "Run client server mode")
	buildPtr            = flag.Bool("build", false, "Build targets")
	jsonPtr             = flag.Bool("json", false, "Print json data")
	verbosePtr          = flag.Bool("v", false, "Print verbose text data")
	outputPtr           = flag.String("o", "", "Output to file")
	projsPtr            = flag.Bool("projects", false, "Include project repo data")

	hostFlags  = flag.NewFlagSet("host", flag.ExitOnError)
	queryFlags = flag.NewFlagSet("query", flag.ExitOnError)
	pathsFlags = flag.NewFlagSet("paths", flag.ExitOnError)
)

// Add profiling data
type profTime struct {
	Description  string  `json:"description"`
	DurationSecs float64 `json:"duration"`
}

type commit struct {
	Project app.ProjectCommit `json:"project"`
	Commit  *app.GitCommit    `json:"commit"`
}

// Use one structure for output for now
type response struct {
	Commits    []commit              `json:"commits,omitempty"`
	Inputs     []string              `json:"files,omitempty"`
	BuildFiles []*app.BuildCmdResult `json:"build_files,omitempty"`
	Targets    []string              `json:"targets,omitempty"`
	Report     *app.Report           `json:"report,omitempty"`

	// Subcommand data
	Query    *app.QueryResponse         `json:"query,omitempty"`
	Paths    []*app.BuildPath           `json:"build_paths,omitempty"`
	Host     *app.HostReport            `json:"host,omitempty"`
	Projects map[string]*app.GitProject `json:"projects,omitempty"`
	// Profile data
	Profile []*profTime `json:"profile"`
}

func main() {
	startTime := time.Now()
	ctx := context.Background()
	rsp := &response{}

	var addProfileData = func(desc string) {
		rsp.Profile = append(rsp.Profile, &profTime{Description: desc, DurationSecs: time.Since(startTime).Seconds()})
		startTime = time.Now()
	}
	flag.Parse()

	ninjaTimeout, err := time.ParseDuration(*ninjaTimeoutStr)
	if err != nil {
		log.Fatalf("Invalid ninja timeout %s", *ninjaTimeoutStr)
	}

	buildTimeout, err := time.ParseDuration(*buildTimeoutStr)
	if err != nil {
		log.Fatalf("Invalid build timeout %s", *buildTimeoutStr)
	}

	subArgs := flag.Args()
	defBuildTarget := "droid"
	log.SetFlags(log.LstdFlags | log.Llongfile)

	ninja := local.NewNinjaCli(*ninjaExcPtr, *ninjaDbPtr, ninjaTimeout, buildTimeout, *clientServerPtr)

	if *clientServerPtr {
		ninjaServ := local.NewNinjaServer(*ninjaExcPtr, *ninjaDbPtr)
		defer ninjaServ.Kill()
		go func() {

			ninjaServ.Start(ctx)
		}()
		if err := ninja.WaitForServer(ctx, int(ninjaTimeout.Seconds())); err != nil {
			log.Fatalf("Failed to connect to server")
		}
	}
	rtx := &report.Context{
		RepoBase:         *repoBasePtr,
		Repo:             &report.RepoMan{},
		Build:            ninja,
		Project:          local.NewGitCli(),
		WorkerCount:      *workerCountPtr,
		BuildWorkerCount: *buildWorkerCountPtr,
	}

	var subcommand tool
	var commits repoFlags
	if len(subArgs) > 0 {
		switch subArgs[0] {
		case "host":
			hostToolPathPtr := hostFlags.String("hostbin", local.DefHostBinPath(), "Set the output directory for host tools")
			hostFlags.Parse(subArgs[1:])

			subcommand = &hostReport{toolPath: *hostToolPathPtr}
			rsp.Targets = hostFlags.Args()

		case "query":
			queryFlags.Var(&commits, "repo", "Repo:SHA to query")
			queryFlags.Parse(subArgs[1:])
			subcommand = &queryReport{}
			rsp.Targets = queryFlags.Args()

		case "paths":
			pathsFlags.Var(&commits, "repo", "Repo:SHA to build")
			singlePathPtr := pathsFlags.Bool("1", false, "Get single path to output target")
			pathsFlags.Parse(subArgs[1:])

			subcommand = &pathsReport{build_target: defBuildTarget, single: *singlePathPtr}

			rsp.Inputs = pathsFlags.Args()

		default:
			rsp.Targets = subArgs
		}
	}
	addProfileData("Init")
	rtx.ResolveProjectMap(ctx, *manifestPtr, *upstreamPtr)
	addProfileData("Project Map")

	// Add project to output if requested
	if *projsPtr == true {
		rsp.Projects = make(map[string]*app.GitProject)
		for k, p := range rtx.Info.ProjMap {
			rsp.Projects[k] = p.GitProj
		}
	}

	// Resolve any commits
	if len(commits) > 0 {
		log.Printf("Resolving %s", commits.String())
		for _, c := range commits {
			commit := commit{Project: c}
			info, files, err := report.ResolveCommit(ctx, rtx, &c)
			if err != nil {
				log.Fatalf("Failed to resolve commit %s:%s", c.Project, c.Revision)
			}
			commit.Commit = info
			rsp.Commits = append(rsp.Commits, commit)

			// Add files to list of inputs
			rsp.Inputs = append(rsp.Inputs, files...)
		}
		addProfileData("Commit Resolution")
	}

	// Run any sub tools
	if subcommand != nil {
		if err := subcommand.Run(ctx, rtx, rsp); err != nil {
			log.Fatal(err)
		}
		addProfileData(subArgs[0])
	}

	buildErrors := 0
	if *buildPtr {
		// Only support default builder (non server-client)
		builder := local.NewNinjaCli(local.DefNinjaExc(), *ninjaDbPtr, ninjaTimeout, buildTimeout, false /*clientMode*/)
		for _, t := range rsp.Targets {
			log.Printf("Building %s\n", t)
			res := builder.Build(ctx, t)
			addProfileData(fmt.Sprintf("Build %s", t))
			log.Printf("%s\n", res.Output)
			if res.Success != true {
				buildErrors++
			}
			rsp.BuildFiles = append(rsp.BuildFiles, res)
		}
	}

	// Generate report
	log.Printf("Generating report for targets %s", rsp.Targets)
	req := &app.ReportRequest{Targets: rsp.Targets}
	rsp.Report, err = report.RunReport(ctx, rtx, req)
	addProfileData("Report")
	if err != nil {
		log.Fatal(fmt.Sprintf("Report failure <%s>", err))
	}

	if *jsonPtr {
		b, _ := json.MarshalIndent(rsp, "", "\t")
		if *outputPtr == "" {
			os.Stdout.Write(b)
		} else {
			os.WriteFile(*outputPtr, b, 0644)
		}
	} else {
		if *outputPtr == "" {
			printTextReport(os.Stdout, subcommand, rsp, *verbosePtr)
		} else {
			file, err := os.Create(*outputPtr)
			if err != nil {
				log.Fatalf("Failed to create output file %s (%s)", *outputPtr, err)
			}
			w := bufio.NewWriter(file)
			printTextReport(w, subcommand, rsp, *verbosePtr)
			w.Flush()
		}

	}

	if buildErrors > 0 {
		log.Fatal(fmt.Sprintf("Failed to build %d targets", buildErrors))
	}
}

func printTextReport(w io.Writer, subcommand tool, rsp *response, verbose bool) {
	fmt.Fprintln(w, "Metric Report")
	if subcommand != nil {
		subcommand.PrintText(w, rsp, verbose)
	}

	if len(rsp.Commits) > 0 {
		fmt.Fprintln(w, "")
		fmt.Fprintln(w, "  Commit Results")
		for _, c := range rsp.Commits {
			fmt.Fprintf(w, "   %-120s : %s\n", c.Project.Project, c.Project.Revision)
			fmt.Fprintf(w, "       SHA   : %s\n", c.Commit.Sha)
			fmt.Fprintf(w, "       Files : \n")
			for _, f := range c.Commit.Files {
				fmt.Fprintf(w, "         %s  %s\n", f.Type.String(), f.Filename)
			}
		}
	}
	if len(rsp.BuildFiles) > 0 {
		fmt.Fprintln(w, "")
		fmt.Fprintln(w, "  Build Files")
		for _, b := range rsp.BuildFiles {
			fmt.Fprintf(w, "            %-120s : %t \n", b.Name, b.Success)
		}
	}

	targetPrint := func(target *app.BuildTarget) {
		fmt.Fprintf(w, "      %-20s       : %s\n", "Name", target.Name)
		fmt.Fprintf(w, "         %-20s    : %d\n", "Build Steps", target.Steps)
		fmt.Fprintf(w, "         %-20s        \n", "Inputs")
		fmt.Fprintf(w, "            %-20s : %d\n", "Files", target.FileCount)
		fmt.Fprintf(w, "            %-20s : %d\n", "Projects", len(target.Projects))
		fmt.Fprintln(w)
		for name, proj := range target.Projects {
			forkCount := 0
			for _, file := range proj.Files {
				if file.BranchDiff != nil {
					forkCount++
				}
			}
			fmt.Fprintf(w, "            %-120s : %d ", name, len(proj.Files))
			if forkCount != 0 {
				fmt.Fprintf(w, " (%d)\n", forkCount)
			} else {
				fmt.Fprintf(w, " \n")
			}

			if verbose {
				for _, file := range proj.Files {
					var fork string
					if file.BranchDiff != nil {
						fork = fmt.Sprintf("(%d+ %d-)", file.BranchDiff.AddedLines, file.BranchDiff.DeletedLines)
					}
					fmt.Fprintf(w, "               %-20s %s\n", fork, file.Filename)
				}

			}
		}

	}
	fmt.Fprintln(w, "  Targets")
	for _, t := range rsp.Report.Targets {
		targetPrint(t)
	}

	fmt.Fprintln(w, "  Run Times")
	for _, p := range rsp.Profile {
		fmt.Fprintf(w, "     %-30s : %f secs\n", p.Description, p.DurationSecs)
	}

}