package utils

import (
	"fmt"
	"os"
	"strings"

	resty "github.com/go-resty/resty/v2"
	"github.com/spf13/cobra"
	"github.com/spf13/viper"
	"github.com/tidwall/gjson"
)

var customizedMap = make(map[string]interface{})

func ParseCutomizedFlags(url string, requiredFlags []string, cmd *cobra.Command, args []string) map[string]interface{} {

	if len(requiredFlags) > 0 && len(args) == 0 {
		cmd.Help()
		fmt.Println()
		os.Exit(0)
	}

	argsArrayString := strings.Join(args, "#")
	for _, flag := range requiredFlags {
		if !strings.Contains(argsArrayString, "--"+flag) {
			fmt.Printf("required flag(s) \"%v\" not set\n", flag)
			cmd.Help()
			fmt.Println()
			os.Exit(1)
		}
	}

	fullURL := viper.GetString("datacenter-server-api") + url
	var customizedData gjson.Result
	client := resty.New()
	resp, err := client.R().ForceContentType("application/json").EnableTrace().Get(fullURL)
	if err == nil {
		if gjson.Get(resp.String(), "status").String() == "OK" {
			customizedData = gjson.Get(resp.String(), "data")
		}
	} else {
		fmt.Println(err.Error())
		os.Exit(1)
	}

	if len(customizedData.Map()) > 0 {
		for key_name, valueMap := range customizedData.Map() {
			value_type := valueMap.Get("type").String()
			if value_type == "string" {
				cmd.Flags().String(string(key_name), valueMap.Map()["default"].String(), valueMap.Map()["des"].String())
			} else if value_type == "bool" {
				cmd.Flags().Bool(string(key_name), valueMap.Map()["default"].Bool(), valueMap.Map()["des"].String())
			}
		}
	}

	cmd.DisableFlagParsing = false
	err = cmd.ParseFlags(args)
	if err != nil {
		fmt.Println(err)
		cmd.Help()
		fmt.Println()
		os.Exit(1)
	}

	if cmd.Flag("help").Value.String() == "true" {
		cmd.Help()
		fmt.Println()
		os.Exit(0)
	}

	if len(customizedData.Array()) > 0 {
		for key_name := range customizedData.Map() {
			if cmd.Flag(key_name).Value.String() != cmd.Flag(key_name).DefValue {
				customizedMap[key_name] = cmd.Flag(key_name).Value
			}
		}
	}

	return customizedMap
}

import (
	"fmt"

	"github.com/spf13/cobra"
	"nuke.csf.nokia.net/nuke-cli/utils"
)

var Region string
var requiredFlags []string

var DemoClusterCreate = &cobra.Command{
	Use:                "demo [string to print]",
	Short:              "demo anything to the screen",
	Long:               `demo is for printing anything back to the screen. For many years people have printed back to the screen.`,
	RunE:               createDemoCluster,
	DisableFlagParsing: true,
}

func createDemoCluster(cmd *cobra.Command, args []string) error {

	var customizedMap = utils.ParseCutomizedFlags("/api/v1/demo/custom-api", requiredFlags, cmd, args)

	for va := range customizedMap {
		fmt.Println(va)
		fmt.Println(customizedMap[va])
	}

	fmt.Println(Region)
	return nil
}

func init() {
	// DemoClusterCreate.Flags().StringVarP(&demoVersion, "version", "v", "1.14", "Venilla version, current can be set as 1.10 , 1.11 1.12")
	DemoClusterCreate.Flags().StringVarP(&Region, "region", "r", "zone-a", "(required) AWS region")
	// DemoClusterCreate.MarkFlagRequired("region")
	//特殊处理required的参数
	requiredFlags = append(requiredFlags, "region") 

}

package utils

import (
	"os"
	"sync"

	"github.com/natefinch/lumberjack"
	"github.com/spf13/viper"

	"go.uber.org/zap"
	"go.uber.org/zap/zapcore"
)

var sugarLogger *zap.SugaredLogger

func getEncoder() zapcore.Encoder {
	encoderConfig := zap.NewProductionEncoderConfig()
	// The format time can be customized
	encoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder
	encoderConfig.EncodeLevel = zapcore.CapitalLevelEncoder
	return zapcore.NewConsoleEncoder(encoderConfig)
}

// Save file log cut
func getLogWriter() zapcore.WriteSyncer {
	lumberJackLogger := &lumberjack.Logger{
		Filename:   "./nuke.log", // Log name
		MaxSize:    10,           // File content size, MB
		MaxBackups: 5,            // Maximum number of old files retained
		MaxAge:     30,           // Maximum number of days to keep old files
		Compress:   false,        // Is the file compressed
	}
	return zapcore.AddSync(lumberJackLogger)
}

func InitLog() *zap.SugaredLogger {
	var allCore []zapcore.Core
	writeSyncer := getLogWriter()
	encoder := getEncoder()

	consoleDebugging := zapcore.Lock(os.Stdout)
	// for human operators.
	consoleEncoder := zapcore.NewConsoleEncoder(zap.NewDevelopmentEncoderConfig())

	log_level := viper.GetString("log")

	if log_level == zapcore.DebugLevel.String() {
		allCore = append(allCore, zapcore.NewCore(consoleEncoder, consoleDebugging, zapcore.DebugLevel))
		allCore = append(allCore, zapcore.NewCore(encoder, writeSyncer, zapcore.DebugLevel))
	} else {
		allCore = append(allCore, zapcore.NewCore(consoleEncoder, consoleDebugging, zapcore.InfoLevel))
		allCore = append(allCore, zapcore.NewCore(encoder, writeSyncer, zapcore.InfoLevel))
	}

	core := zapcore.NewTee(allCore...)
	// Print function lines
	logger := zap.New(core).WithOptions(zap.AddCaller())
	return logger.Sugar()
}

var once sync.Once

func SugaredLogger() *zap.SugaredLogger {
	once.Do(func() {
		sugarLogger = InitLog()
	})
	return sugarLogger
}

utils.SugaredLogger().Infof("info log")
utils.SugaredLogger().Debugf("debug format log")
utils.SugaredLogger().Debug("debug log")

package main

import (
	"fmt"
	"time"
)

func main() {
	go c()
	fmt.Println("I am main")
	time.Sleep(time.Second * 2)
}
func c() {
	time.Sleep(time.Second * 2)
	fmt.Println("I am concurrent")
}

//=> I am main
//=> I am concurrent