// 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 (
 "archive/zip"
 "bufio"
 "bytes"
 "encoding/xml"
 "flag"
 "fmt"
 "io/ioutil"
 "os"
 "os/exec"
 "path"
 "path/filepath"
 "regexp"
 "sort"
 "strings"
 "text/template"

 "github.com/google/blueprint/proptools"

 "android/soong/bpfix/bpfix"
)

type RewriteNames []RewriteName
type RewriteName struct {
 regexp *regexp.Regexp
 repl   string
}

func (r *RewriteNames) String() string {
 return ""
}

func (r *RewriteNames) Set(v string) error {
 split := strings.SplitN(v, "=", 2)
 if len(split) != 2 {
  return fmt.Errorf("Must be in the form of <regex>=<replace>")
 }
 regex, err := regexp.Compile(split[0])
 if err != nil {
  return nil
 }
 *r = append(*r, RewriteName{
  regexp: regex,
  repl:   split[1],
 })
 return nil
}

func (r *RewriteNames) MavenToBp(groupId string, artifactId string) string {
 for _, r := range *r {
  if r.regexp.MatchString(groupId + ":" + artifactId) {
   return r.regexp.ReplaceAllString(groupId+":"+artifactId, r.repl)
  } else if r.regexp.MatchString(artifactId) {
   return r.regexp.ReplaceAllString(artifactId, r.repl)
  }
 }
 return artifactId
}

var rewriteNames = RewriteNames{}

type ExtraDeps map[string][]string

func (d ExtraDeps) String() string {
 return ""
}

func (d ExtraDeps) Set(v string) error {
 split := strings.SplitN(v, "=", 2)
 if len(split) != 2 {
  return fmt.Errorf("Must be in the form of <module>=<module>[,<module>]")
 }
 d[split[0]] = strings.Split(split[1], ",")
 return nil
}

var extraStaticLibs = make(ExtraDeps)

var extraLibs = make(ExtraDeps)

var optionalUsesLibs = make(ExtraDeps)

type Exclude map[string]bool

func (e Exclude) String() string {
 return ""
}

func (e Exclude) Set(v string) error {
 e[v] = true
 return nil
}

var excludes = make(Exclude)

type HostModuleNames map[string]bool

func (n HostModuleNames) IsHostModule(groupId string, artifactId string) bool {
 _, found := n[groupId+":"+artifactId]
 return found
}

func (n HostModuleNames) String() string {
 return ""
}

func (n HostModuleNames) Set(v string) error {
 n[v] = true
 return nil
}

var hostModuleNames = HostModuleNames{}

type HostAndDeviceModuleNames map[string]bool

func (n HostAndDeviceModuleNames) IsHostAndDeviceModule(groupId string, artifactId string) bool {
 _, found := n[groupId+":"+artifactId]

 return found
}

func (n HostAndDeviceModuleNames) String() string {
 return ""
}

func (n HostAndDeviceModuleNames) Set(v string) error {
 n[v] = true
 return nil
}

var hostAndDeviceModuleNames = HostAndDeviceModuleNames{}

var sdkVersion string
var defaultMinSdkVersion string
var useVersion string
var staticDeps bool
var writeCmd bool
var jetifier bool

func InList(s string, list []string) bool {
 for _, l := range list {
  if l == s {
   return true
  }
 }

 return false
}

type Dependency struct {
 XMLName xml.Name `xml:"dependency"`

 BpTarget    string `xml:"-"`
 BazelTarget string `xml:"-"`

 GroupId    string `xml:"groupId"`
 ArtifactId string `xml:"artifactId"`
 Version    string `xml:"version"`
 Type       string `xml:"type"`
 Scope      string `xml:"scope"`
}

func (d Dependency) BpName() string {
 if d.BpTarget == "" {
  d.BpTarget = rewriteNames.MavenToBp(d.GroupId, d.ArtifactId)
 }
 return d.BpTarget
}

type Pom struct {
 XMLName xml.Name `xml:"http://maven.apache.org/POM/4.0.0 project"`

 PomFile       string `xml:"-"`
 ArtifactFile  string `xml:"-"`
 BpTarget      string `xml:"-"`
 MinSdkVersion string `xml:"-"`

 GroupId    string `xml:"groupId"`
 ArtifactId string `xml:"artifactId"`
 Version    string `xml:"version"`
 Packaging  string `xml:"packaging"`

 Dependencies []*Dependency `xml:"dependencies>dependency"`
}

func (p Pom) IsAar() bool {
 return p.Packaging == "aar"
}

func (p Pom) IsJar() bool {
 return p.Packaging == "jar"
}

func (p Pom) IsApk() bool {
 return p.Packaging == "apk"
}

func (p Pom) IsHostModule() bool {
 return hostModuleNames.IsHostModule(p.GroupId, p.ArtifactId)
}

func (p Pom) IsDeviceModule() bool {
 return !p.IsHostModule()
}

func (p Pom) IsHostAndDeviceModule() bool {
 return hostAndDeviceModuleNames.IsHostAndDeviceModule(p.GroupId, p.ArtifactId)
}

func (p Pom) IsHostOnly() bool {
 return p.IsHostModule() && !p.IsHostAndDeviceModule()
}

func (p Pom) ModuleType() string {
 if p.IsAar() {
  return "android_library"
 } else if p.IsHostOnly() {
  return "java_library_host"
 } else {
  return "java_library_static"
 }
}

func (p Pom) BazelTargetType() string {
 if p.IsAar() {
  return "android_library"
 } else {
  return "java_library"
 }
}

func (p Pom) ImportModuleType() string {
 if p.IsAar() {
  return "android_library_import"
 } else if p.IsApk() {
  return "android_app_import"
 } else if p.IsHostOnly() {
  return "java_import_host"
 } else {
  return "java_import"
 }
}

func (p Pom) BazelImportTargetType() string {
 if p.IsAar() {
  return "aar_import"
 } else if p.IsApk() {
  return "apk_import"
 } else {
  return "java_import"
 }
}

func (p Pom) ImportProperty() string {
 if p.IsAar() {
  return "aars"
 } else if p.IsApk() {
  return "apk"
 } else {
  return "jars"
 }
}

func (p Pom) BazelImportProperty() string {
 if p.IsAar() {
  return "aar"
 } else if p.IsApk() {
  return "apk"
 } else {
  return "jars"
 }
}

func (p Pom) BpName() string {
 if p.BpTarget == "" {
  p.BpTarget = rewriteNames.MavenToBp(p.GroupId, p.ArtifactId)
 }
 return p.BpTarget
}

func (p Pom) BpJarDeps() []string {
 return p.BpDeps("jar", []string{"compile", "runtime"})
}

func (p Pom) BpAarDeps() []string {
 return p.BpDeps("aar", []string{"compile", "runtime"})
}

func (p Pom) BazelJarDeps() []string {
 return p.BazelDeps("jar", []string{"compile", "runtime"})
}

func (p Pom) BazelAarDeps() []string {
 return p.BazelDeps("aar", []string{"compile", "runtime"})
}

func (p Pom) BpExtraStaticLibs() []string {
 return extraStaticLibs[p.BpName()]
}

func (p Pom) BpExtraLibs() []string {
 return extraLibs[p.BpName()]
}

func (p Pom) BpOptionalUsesLibs() []string {
 return optionalUsesLibs[p.BpName()]
}

// BpDeps obtains dependencies filtered by type and scope. The results of this
// method are formatted as Android.bp targets, e.g. run through MavenToBp rules.
func (p Pom) BpDeps(typeExt string, scopes []string) []string {
 var ret []string
 for _, d := range p.Dependencies {
  if d.Type != typeExt || !InList(d.Scope, scopes) {
   continue
  }
  name := rewriteNames.MavenToBp(d.GroupId, d.ArtifactId)
  ret = append(ret, name)
 }
 return ret
}

// BazelDeps obtains dependencies filtered by type and scope. The results of this
// method are formatted as Bazel BUILD targets.
func (p Pom) BazelDeps(typeExt string, scopes []string) []string {
 var ret []string
 for _, d := range p.Dependencies {
  if d.Type != typeExt || !InList(d.Scope, scopes) {
   continue
  }
  ret = append(ret, d.BazelTarget)
 }
 return ret
}

func PathModVars() (string, string, string) {
 cmd := "/bin/bash"
 androidTop := os.Getenv("ANDROID_BUILD_TOP")
 envSetupSh := path.Join(androidTop, "build/envsetup.sh")
 return cmd, androidTop, envSetupSh
}

func InitRefreshMod(poms []*Pom) error {
 cmd, _, envSetupSh := PathModVars()
 // refreshmod is expensive, so if pathmod is already working we can skip it.
 _, err := exec.Command(cmd, "-c", ". "+envSetupSh+" && pathmod "+poms[0].BpName()).Output()
 if exitErr, _ := err.(*exec.ExitError); exitErr != nil || err != nil {
  _, err := exec.Command(cmd, "-c", ". "+envSetupSh+" && refreshmod").Output()
  if exitErr, _ := err.(*exec.ExitError); exitErr != nil {
   return fmt.Errorf("failed to run %s\n%s\ntry running lunch.", cmd, string(exitErr.Stderr))
  } else if err != nil {
   return err
  }
 }
 return nil
}

func BazelifyExtraDeps(extraDeps ExtraDeps, modules map[string]*Pom) error {
 for _, deps := range extraDeps {
  for _, dep := range deps {
   bazelName, err := BpNameToBazelTarget(dep, modules)
   if err != nil {
    return err
   }
   dep = bazelName
  }

 }
 return nil
}

func (p *Pom) GetBazelDepNames(modules map[string]*Pom) error {
 for _, d := range p.Dependencies {
  bazelName, err := BpNameToBazelTarget(d.BpName(), modules)
  if err != nil {
   return err
  }
  d.BazelTarget = bazelName
 }
 return nil
}

func BpNameToBazelTarget(bpName string, modules map[string]*Pom) (string, error) {
 cmd, androidTop, envSetupSh := PathModVars()

 if _, ok := modules[bpName]; ok {
  // We've seen the POM for this dependency, it will be local to the output BUILD file
  return ":" + bpName, nil
 } else {
  // we don't have the POM for this artifact, find and use the fully qualified target name.
  output, err := exec.Command(cmd, "-c", ". "+envSetupSh+" && pathmod "+bpName).Output()
  if exitErr, _ := err.(*exec.ExitError); exitErr != nil {
   return "", fmt.Errorf("failed to run %s %s\n%s", cmd, bpName, string(exitErr.Stderr))
  } else if err != nil {
   return "", err
  }
  relPath := ""
  for _, line := range strings.Fields(string(output)) {
   if strings.Contains(line, androidTop) {
    relPath = strings.TrimPrefix(line, androidTop)
    relPath = strings.TrimLeft(relPath, "/")
   }
  }
  return "//" + relPath + ":" + bpName, nil
 }
}

func (p Pom) SdkVersion() string {
 return sdkVersion
}

func (p Pom) DefaultMinSdkVersion() string {
 return defaultMinSdkVersion
}

func (p Pom) Jetifier() bool {
 return jetifier
}

func (p *Pom) FixDeps(modules map[string]*Pom) {
 for _, d := range p.Dependencies {
  if d.Type == "" {
   if depPom, ok := modules[d.BpName()]; ok {
    // We've seen the POM for this dependency, use its packaging
    // as the dependency type rather than Maven spec default.
    d.Type = depPom.Packaging
   } else {
    // Dependency type was not specified and we don't have the POM
    // for this artifact, use the default from Maven spec.
    d.Type = "jar"
   }
  }
  if d.Scope == "" {
   // Scope was not specified, use the default from Maven spec.
   d.Scope = "compile"
  }
 }
}

// ExtractMinSdkVersion extracts the minSdkVersion from the AndroidManifest.xml file inside an aar file, or sets it
// to "current" if it is not present.
func (p *Pom) ExtractMinSdkVersion() error {
 aar, err := zip.OpenReader(p.ArtifactFile)
 if err != nil {
  return err
 }
 defer aar.Close()

 var manifest *zip.File
 for _, f := range aar.File {
  if f.Name == "AndroidManifest.xml" {
   manifest = f
   break
  }
 }

 if manifest == nil {
  return fmt.Errorf("failed to find AndroidManifest.xml in %s", p.ArtifactFile)
 }

 r, err := manifest.Open()
 if err != nil {
  return err
 }
 defer r.Close()

 decoder := xml.NewDecoder(r)

 manifestData := struct {
  XMLName  xml.Name `xml:"manifest"`
  Uses_sdk struct {
   MinSdkVersion string `xml:"http://schemas.android.com/apk/res/android minSdkVersion,attr"`
  } `xml:"uses-sdk"`
 }{}

 err = decoder.Decode(&manifestData)
 if err != nil {
  return err
 }

 p.MinSdkVersion = manifestData.Uses_sdk.MinSdkVersion
 if p.MinSdkVersion == "" {
  p.MinSdkVersion = "current"
 }

 return nil
}

var bpTemplate = template.Must(template.New("bp").Parse(`
{{.ImportModuleType}} {
    name: "{{.BpName}}",
    {{- if .IsApk}}
    {{.ImportProperty}}: "{{.ArtifactFile}}",
    {{- else}}
    {{.ImportProperty}}: ["{{.ArtifactFile}}"],
    sdk_version: "{{.SdkVersion}}",
    {{- end}}
    {{- if .Jetifier}}
    jetifier: true,
    {{- end}}
    {{- if .IsHostAndDeviceModule}}
    host_supported: true,
    {{- end}}
    {{- if not .IsHostOnly}}
    apex_available: [
        "//apex_available:platform",
        "//apex_available:anyapex",
    ],
    {{- end}}
    {{- if .IsAar}}
    min_sdk_version: "{{.MinSdkVersion}}",
    static_libs: [
        {{- range .BpJarDeps}}
        "{{.}}",
        {{- end}}
        {{- range .BpAarDeps}}
        "{{.}}",
        {{- end}}
        {{- range .BpExtraStaticLibs}}
        "{{.}}",
        {{- end}}
    ],
    {{- if .BpExtraLibs}}
    libs: [
        {{- range .BpExtraLibs}}
        "{{.}}",
        {{- end}}
    ],
    {{- end}}
    {{- if .BpOptionalUsesLibs}}
    optional_uses_libs: [
        {{- range .BpOptionalUsesLibs}}
        "{{.}}",
        {{- end}}
    ],
    {{- end}}
    {{- else if not .IsHostOnly}}
    {{- if not .IsApk}}
    min_sdk_version: "{{.DefaultMinSdkVersion}}",
    {{- end}}
    {{- end}}
    {{- if .IsApk}}
    preprocessed: true,
    presigned: true,
    {{- end}}

}
`))

var bpDepsTemplate = template.Must(template.New("bp").Parse(`
{{.ImportModuleType}} {
    name: "{{.BpName}}-nodeps",
    {{.ImportProperty}}: ["{{.ArtifactFile}}"],
    sdk_version: "{{.SdkVersion}}",
    {{- if .Jetifier}}
    jetifier: true,
    {{- end}}
    {{- if .IsHostAndDeviceModule}}
    host_supported: true,
    {{- end}}
    {{- if not .IsHostOnly}}
    apex_available: [
        "//apex_available:platform",
        "//apex_available:anyapex",
    ],
    {{- end}}
    {{- if .IsAar}}
    min_sdk_version: "{{.MinSdkVersion}}",
    static_libs: [
        {{- range .BpJarDeps}}
        "{{.}}",
        {{- end}}
        {{- range .BpAarDeps}}
        "{{.}}",
        {{- end}}
        {{- range .BpExtraStaticLibs}}
        "{{.}}",
        {{- end}}
    ],
    {{- if .BpExtraLibs}}
    libs: [
        {{- range .BpExtraLibs}}
        "{{.}}",
        {{- end}}
    ],
    {{- end}}
    {{- else if not .IsHostOnly}}
    min_sdk_version: "{{.DefaultMinSdkVersion}}",
    {{- end}}
}

{{.ModuleType}} {
    name: "{{.BpName}}",
    {{- if .IsDeviceModule}}
    sdk_version: "{{.SdkVersion}}",
    {{- if .IsHostAndDeviceModule}}
    host_supported: true,
    {{- end}}
    {{- if not .IsHostOnly}}
    apex_available: [
        "//apex_available:platform",
        "//apex_available:anyapex",
    ],
    {{- end}}
    {{- if .IsAar}}
    min_sdk_version: "{{.MinSdkVersion}}",
    manifest: "manifests/{{.BpName}}/AndroidManifest.xml",
    {{- else if not .IsHostOnly}}
    min_sdk_version: "{{.DefaultMinSdkVersion}}",
    {{- end}}
    {{- end}}
    static_libs: [
        "{{.BpName}}-nodeps",
        {{- range .BpJarDeps}}
        "{{.}}",
        {{- end}}
        {{- range .BpAarDeps}}
        "{{.}}",
        {{- end}}
        {{- range .BpExtraStaticLibs}}
        "{{.}}",
        {{- end}}
    ],
    {{- if .BpExtraLibs}}
    libs: [
        {{- range .BpExtraLibs}}
        "{{.}}",
        {{- end}}
    ],
    {{- end}}
    {{- if .BpOptionalUsesLibs}}
    optional_uses_libs: [
        {{- range .BpOptionalUsesLibs}}
        "{{.}}",
        {{- end}}
    ],
    {{- end}}
    java_version: "1.8",
}
`))

var bazelTemplate = template.Must(template.New("bp").Parse(`
{{.BazelImportTargetType}} (
    name = "{{.BpName}}",
    {{.BazelImportProperty}}: {{- if not .IsAar}}[{{- end}}"{{.ArtifactFile}}"{{- if not .IsAar}}]{{- end}},
    visibility = ["//visibility:public"],
    {{- if .IsAar}}
    deps = [
        {{- range .BazelJarDeps}}
        "{{.}}",
        {{- end}}
        {{- range .BazelAarDeps}}
        "{{.}}",
        {{- end}}
        {{- range .BpExtraStaticLibs}}
        "{{.}}",
        {{- end}}
        {{- range .BpExtraLibs}}
        "{{.}}",
        {{- end}}
        {{- range .BpOptionalUsesLibs}}
        "{{.}}",
        {{- end}}
    ],
    {{- end}}
)
`))

var bazelDepsTemplate = template.Must(template.New("bp").Parse(`
{{.BazelImportTargetType}} (
    name = "{{.BpName}}",
    {{.BazelImportProperty}} = {{- if not .IsAar}}[{{- end}}"{{.ArtifactFile}}"{{- if not .IsAar}}]{{- end}},
    visibility = ["//visibility:public"],
    exports = [
        {{- range .BazelJarDeps}}
        "{{.}}",
        {{- end}}
        {{- range .BazelAarDeps}}
        "{{.}}",
        {{- end}}
        {{- range .BpExtraStaticLibs}}
        "{{.}}",
        {{- end}}
        {{- range .BpExtraLibs}}
        "{{.}}",
        {{- end}}
        {{- range .BpOptionalUsesLibs}}
        "{{.}}",
        {{- end}}
    ],
)
`))

func parse(filename string) (*Pom, error) {
 data, err := ioutil.ReadFile(filename)
 if err != nil {
  return nil, err
 }

 var pom Pom
 err = xml.Unmarshal(data, &pom)
 if err != nil {
  return nil, err
 }

 if useVersion != "" && pom.Version != useVersion {
  return nil, nil
 }

 if pom.Packaging == "" {
  pom.Packaging = "jar"
 }

 pom.PomFile = filename
 pom.ArtifactFile = strings.TrimSuffix(filename, ".pom") + "." + pom.Packaging

 return &pom, nil
}

func rerunForRegen(filename string) error {
 buf, err := ioutil.ReadFile(filename)
 if err != nil {
  return err
 }

 scanner := bufio.NewScanner(bytes.NewBuffer(buf))

 // Skip the first line in the file
 for i := 0; i < 2; i++ {
  if !scanner.Scan() {
   if scanner.Err() != nil {
    return scanner.Err()
   } else {
    return fmt.Errorf("unexpected EOF")
   }
  }
 }

 // Extract the old args from the file
 line := scanner.Text()
 if strings.HasPrefix(line, "// pom2bp ") { // .bp file
  line = strings.TrimPrefix(line, "// pom2bp ")
 } else if strings.HasPrefix(line, "// pom2mk ") { // .bp file converted from .mk file
  line = strings.TrimPrefix(line, "// pom2mk ")
 } else if strings.HasPrefix(line, "# pom2mk ") { // .mk file
  line = strings.TrimPrefix(line, "# pom2mk ")
 } else if strings.HasPrefix(line, "# pom2bp ") { // Bazel BUILD file
  line = strings.TrimPrefix(line, "# pom2bp ")
 } else {
  return fmt.Errorf("unexpected second line: %q", line)
 }
 args := strings.Split(line, " ")
 lastArg := args[len(args)-1]
 args = args[:len(args)-1]

 // Append all current command line args except -regen <file> to the ones from the file
 for i := 1; i < len(os.Args); i++ {
  if os.Args[i] == "-regen" || os.Args[i] == "--regen" {
   i++
  } else {
   args = append(args, os.Args[i])
  }
 }
 args = append(args, lastArg)

 cmd := os.Args[0] + " " + strings.Join(args, " ")
 // Re-exec pom2bp with the new arguments
 output, err := exec.Command("/bin/sh", "-c", cmd).Output()
 if exitErr, _ := err.(*exec.ExitError); exitErr != nil {
  return fmt.Errorf("failed to run %s\n%s", cmd, string(exitErr.Stderr))
 } else if err != nil {
  return err
 }

 // If the old file was a .mk file, replace it with a .bp file
 if filepath.Ext(filename) == ".mk" {
  os.Remove(filename)
  filename = strings.TrimSuffix(filename, ".mk") + ".bp"
 }

 return ioutil.WriteFile(filename, output, 0666)
}

func main() {
 flag.Usage = func() {
  fmt.Fprintf(os.Stderr, `pom2bp, a tool to create Android.bp files from maven repos

The tool will extract the necessary information from *.pom files to create an Android.bp whose
aar libraries can be linked against when using AAPT2.

Usage: %s [--rewrite <regex>=<replace>] [--exclude <module>] [--extra-static-libs <module>=<module>[,<module>]] [--extra-libs <module>=<module>[,<module>]] [--optional-uses-libs <module>=<module>[,<module>]] [<dir>] [-regen <file>]

  -rewrite <regex>=<replace>
     rewrite can be used to specify mappings between Maven projects and Android.bp modules. The -rewrite
     option can be specified multiple times. When determining the Android.bp module for a given Maven
     project, mappings are searched in the order they were specified. The first <regex> matching
     either the Maven project's <groupId>:<artifactId> or <artifactId> will be used to generate
     the Android.bp module name using <replace>. If no matches are found, <artifactId> is used.
  -exclude <module>
     Don't put the specified module in the Android.bp file.
  -extra-static-libs <module>=<module>[,<module>]
     Some Android.bp modules have transitive static dependencies that must be specified when they
     are depended upon (like android-support-v7-mediarouter requires android-support-v7-appcompat).
     This may be specified multiple times to declare these dependencies.
  -extra-libs <module>=<module>[,<module>]
     Some Android.bp modules have transitive runtime dependencies that must be specified when they
     are depended upon (like androidx.test.rules requires android.test.base).
     This may be specified multiple times to declare these dependencies.
  -optional-uses-libs <module>=<module>[,<module>]
     Some Android.bp modules have optional dependencies (typically specified with <uses-library> in
     the module's AndroidManifest.xml) that must be specified when they are depended upon (like
     androidx.window:window optionally requires androidx.window:window-extensions).
     This may be specified multiple times to declare these dependencies.
  -sdk-version <version>
     Sets sdk_version: "<version>" for all modules.
  -default-min-sdk-version
     The default min_sdk_version to use for a module if one cannot be mined from AndroidManifest.xml
  -use-version <version>
     If the maven directory contains multiple versions of artifacts and their pom files,
     -use-version can be used to only write Android.bp files for a specific version of those artifacts.
  -write-cmd
     Whether to write the command line arguments used to generate the build file as a comment at
     the top of the build file itself.
  -jetifier
     Sets jetifier: true for all modules.
  <dir>
     The directory to search for *.pom files under.
     The contents are written to stdout, to be put in the current directory (often as Android.bp)
  -regen <file>
     Read arguments from <file> and overwrite it (if it ends with .bp) or move it to .bp (if it
     ends with .mk).

`, os.Args[0])
 }

 var regen string
 var pom2build bool
 var prepend string

 flag.Var(&excludes, "exclude", "Exclude module")
 flag.Var(&extraStaticLibs, "extra-static-libs", "Extra static dependencies needed when depending on a module")
 flag.Var(&extraLibs, "extra-libs", "Extra runtime dependencies needed when depending on a module")
 flag.Var(&optionalUsesLibs, "optional-uses-libs", "Extra optional dependencies needed when depending on a module")
 flag.Var(&rewriteNames, "rewrite", "Regex(es) to rewrite artifact names")
 flag.Var(&hostModuleNames, "host", "Specifies that the corresponding module (specified in the form 'module.group:module.artifact') is a host module")
 flag.Var(&hostAndDeviceModuleNames, "host-and-device", "Specifies that the corresponding module (specified in the form 'module.group:module.artifact') is both a host and device module.")
 flag.StringVar(&sdkVersion, "sdk-version", "", "What to write to sdk_version")
 flag.StringVar(&defaultMinSdkVersion, "default-min-sdk-version", "24", "Default min_sdk_version to use, if one is not available from AndroidManifest.xml. Default: 24")
 flag.StringVar(&useVersion, "use-version", "", "Only read artifacts of a specific version")
 flag.BoolVar(&staticDeps, "static-deps", false, "Statically include direct dependencies")
 flag.BoolVar(&writeCmd, "write-cmd", true, "Write command line arguments as a comment")
 flag.BoolVar(&jetifier, "jetifier", false, "Sets jetifier: true on all modules")
 flag.StringVar(®en, "regen", "", "Rewrite specified file")
 flag.BoolVar(&pom2build, "pom2build", false, "If true, will generate a Bazel BUILD file *instead* of a .bp file")
 flag.StringVar(&prepend, "prepend", "", "Path to a file containing text to insert at the beginning of the generated build file")
 flag.Parse()

 if regen != "" {
  err := rerunForRegen(regen)
  if err != nil {
   fmt.Fprintln(os.Stderr, err)
   os.Exit(1)
  }
  os.Exit(0)
 }

 if flag.NArg() == 0 {
  fmt.Fprintln(os.Stderr, "Directory argument is required")
  os.Exit(1)
 } else if flag.NArg() > 1 {
  fmt.Fprintln(os.Stderr, "Multiple directories provided:", strings.Join(flag.Args(), " "))
  os.Exit(1)
 }

 dir := flag.Arg(0)
 absDir, err := filepath.Abs(dir)
 if err != nil {
  fmt.Fprintln(os.Stderr, "Failed to get absolute directory:", err)
  os.Exit(1)
 }

 var filenames []string
 err = filepath.Walk(absDir, func(path string, info os.FileInfo, err error) error {
  if err != nil {
   return err
  }

  name := info.Name()
  if info.IsDir() {
   if strings.HasPrefix(name, ".") {
    return filepath.SkipDir
   }
   return nil
  }

  if strings.HasPrefix(name, ".") {
   return nil
  }

  if strings.HasSuffix(name, ".pom") {
   path, err = filepath.Rel(absDir, path)
   if err != nil {
    return err
   }
   filenames = append(filenames, filepath.Join(dir, path))
  }
  return nil
 })
 if err != nil {
  fmt.Fprintln(os.Stderr, "Error walking files:", err)
  os.Exit(1)
 }

 if len(filenames) == 0 {
  fmt.Fprintln(os.Stderr, "Error: no *.pom files found under", dir)
  os.Exit(1)
 }

 sort.Strings(filenames)

 poms := []*Pom{}
 modules := make(map[string]*Pom)
 duplicate := false
 for _, filename := range filenames {
  pom, err := parse(filename)
  if err != nil {
   fmt.Fprintln(os.Stderr, "Error converting", filename, err)
   os.Exit(1)
  }

  if pom != nil {
   key := pom.BpName()
   if excludes[key] {
    continue
   }

   if old, ok := modules[key]; ok {
    fmt.Fprintln(os.Stderr, "Module", key, "defined twice:", old.PomFile, pom.PomFile)
    duplicate = true
   }

   poms = append(poms, pom)
   modules[key] = pom
  }
 }
 if duplicate {
  os.Exit(1)
 }

 if pom2build {
  if err := InitRefreshMod(poms); err != nil {
   fmt.Fprintf(os.Stderr, "Error in refreshmod: %s", err)
   os.Exit(1)
  }
  BazelifyExtraDeps(extraStaticLibs, modules)
  BazelifyExtraDeps(extraLibs, modules)
  BazelifyExtraDeps(optionalUsesLibs, modules)
 }

 for _, pom := range poms {
  if pom.IsAar() {
   err := pom.ExtractMinSdkVersion()
   if err != nil {
    fmt.Fprintf(os.Stderr, "Error reading manifest for %s: %s", pom.ArtifactFile, err)
    os.Exit(1)
   }
  }
  pom.FixDeps(modules)
  if pom2build {
   pom.GetBazelDepNames(modules)
  }
 }

 buf := &bytes.Buffer{}
 commentString := "//"
 if pom2build {
  commentString = "#"
 }

 fmt.Fprintln(buf, commentString, "This is a generated file. Do not modify directly.")

 if writeCmd {
  fmt.Fprintln(buf, commentString, "Automatically generated with:")
  fmt.Fprintln(buf, commentString, "pom2bp", strings.Join(proptools.ShellEscapeList(os.Args[1:]), " "))
 }

 if prepend != "" {
  contents, err := ioutil.ReadFile(prepend)
  if err != nil {
   fmt.Fprintln(os.Stderr, "Error reading", prepend, err)
   os.Exit(1)
  }
  fmt.Fprintln(buf, string(contents))
 }

 depsTemplate := bpDepsTemplate
 template := bpTemplate
 if pom2build {
  depsTemplate = bazelDepsTemplate
  template = bazelTemplate
 }

 for _, pom := range poms {
  var err error
  if staticDeps && !pom.IsApk() {
   err = depsTemplate.Execute(buf, pom)
  } else {
   err = template.Execute(buf, pom)
  }
  if err != nil {
   fmt.Fprintln(os.Stderr, "Error writing", pom.PomFile, pom.BpName(), err)
   os.Exit(1)
  }
 }

 if pom2build {
  os.Stdout.WriteString(buf.String())
 } else {
  out, err := bpfix.Reformat(buf.String())
  if err != nil {
   fmt.Fprintln(os.Stderr, "Error formatting output", err)
   os.Exit(1)
  }
  os.Stdout.WriteString(out)
 }

}