func main()

in mmv1/main.go [53:190]
107 lines of code
26 McCabe index (conditional complexity)

func main() {

	flag.Parse()

	if *openapiGenerate {
		parser := openapi_generate.NewOpenapiParser("openapi_generate/openapi", "products")
		parser.Run()
		return
	}

	if outputPath == nil || *outputPath == "" {
		log.Printf("No output path specified, exiting")
		return
	}

	if version == nil || *version == "" {
		log.Printf("No version specified, assuming ga")
		*version = "ga"
	}

	var generateCode = !*doNotGenerateCode
	var generateDocs = !*doNotGenerateDocs
	var productsToGenerate []string
	var allProducts = false
	if product == nil || *product == "" {
		allProducts = true
	} else {
		var productToGenerate = fmt.Sprintf("products/%s", *product)
		productsToGenerate = []string{productToGenerate}
	}

	var allProductFiles []string = make([]string, 0)

	files, err := filepath.Glob("products/**/product.yaml")
	if err != nil {
		panic(err)
	}
	for _, filePath := range files {
		dir := filepath.Dir(filePath)
		allProductFiles = append(allProductFiles, fmt.Sprintf("products/%s", filepath.Base(dir)))
	}

	if *overrideDirectory != "" {
		log.Printf("Using override directory %s", *overrideDirectory)

		// Normalize override dir to a path that is relative to the magic-modules directory
		// This is needed for templates that concatenate pwd + override dir + path
		if filepath.IsAbs(*overrideDirectory) {
			wd, err := os.Getwd()
			if err != nil {
				panic(err)
			}
			*overrideDirectory, err = filepath.Rel(wd, *overrideDirectory)
			log.Printf("Override directory normalized to relative path %s", *overrideDirectory)
		}

		overrideFiles, err := filepath.Glob(fmt.Sprintf("%s/products/**/product.yaml", *overrideDirectory))
		if err != nil {
			panic(err)
		}
		for _, filePath := range overrideFiles {
			product, err := filepath.Rel(*overrideDirectory, filePath)
			if err != nil {
				panic(err)
			}
			dir := filepath.Dir(product)
			productFile := fmt.Sprintf("products/%s", filepath.Base(dir))
			if !slices.Contains(allProductFiles, productFile) {
				allProductFiles = append(allProductFiles, productFile)
			}
		}
	}

	if allProducts {
		productsToGenerate = allProductFiles
	}

	if productsToGenerate == nil || len(productsToGenerate) == 0 {
		log.Fatalf("No product.yaml file found.")
	}

	startTime := time.Now()
	providerName := "default (terraform)"
	if *forceProvider != "" {
		providerName = *forceProvider
	}
	log.Printf("Generating MM output to '%s'", *outputPath)
	log.Printf("Building %s version", *version)
	log.Printf("Building %s provider", providerName)

	// Building compute takes a long time and can't be parallelized within the product
	// so lets build it first
	sort.Slice(allProductFiles, func(i int, j int) bool {
		if allProductFiles[i] == "products/compute" {
			return true
		}
		return false
	})

	var providerToGenerate provider.Provider

	productFileChannel := make(chan string, len(allProductFiles))
	productsForVersionChannel := make(chan *api.Product, len(allProductFiles))
	for _, pf := range allProductFiles {
		productFileChannel <- pf
	}

	for i := 0; i < len(allProductFiles); i++ {
		wg.Add(1)
		go GenerateProduct(productFileChannel, providerToGenerate, productsForVersionChannel, startTime, productsToGenerate, *resourceToGenerate, *overrideDirectory, generateCode, generateDocs)
	}
	wg.Wait()

	close(productFileChannel)
	close(productsForVersionChannel)

	var productsForVersion []*api.Product

	for p := range productsForVersionChannel {
		productsForVersion = append(productsForVersion, p)
	}

	slices.SortFunc(productsForVersion, func(p1, p2 *api.Product) int {
		return strings.Compare(strings.ToLower(p1.Name), strings.ToLower(p2.Name))
	})

	// In order to only copy/compile files once per provider this must be called outside
	// of the products loop. This will get called with the provider from the final iteration
	// of the loop
	providerToGenerate = setProvider(*forceProvider, *version, productsForVersion[0], startTime)
	providerToGenerate.CopyCommonFiles(*outputPath, generateCode, generateDocs)

	if generateCode {
		providerToGenerate.CompileCommonFiles(*outputPath, productsForVersion, "")
	}

	provider.FixImports(*outputPath, *showImportDiffs)
}