cmd

var AbortRunbookExecution = atomic.Bool{}

var ApiHostToUrlMap = map[string]string{
	"api.moltin.com":             "https://euwest.cm.elasticpath.com/",
	"euwest.api.elasticpath.com": "https://euwest.cm.elasticpath.com/",
	"useast.api.elasticpath.com": "https://useast.cm.elasticpath.com/",
}

var CurlInlineAuth = false

var DeleteApplicationKeys = true

var DisableExampleOutput = false

var DisableLongOutput = false

var LoginCmd = &cobra.Command{
	Use:          "login",
	Short:        "Login to the API via client_credentials, implicit, customer or account management tokens.",
	SilenceUsage: false,
}

var LogoutHeaders = &cobra.Command{
	Use:   "headers",
	Short: "Clear all headers that are persisted in the profile",
	RunE: func(cmd *cobra.Command, args []string) error {
		for k, v := range headergroups.GetAllHeaders() {
			log.Infof("Unsetting: %s = %s", k, v)
		}

		headergroups.ClearAllHeaderGroups()
		return nil
	},
}

var Logs = &cobra.Command{Use: "logs", Short: "Retrieve information about previous requests"}

var LogsClear = &cobra.Command{
	Use:   "clear",
	Short: "Clears all HTTP request and response logs",
	RunE: func(cmd *cobra.Command, args []string) error {
		return profiles.ClearAllRequestLogs()
	},
}

var LogsCurlReplay = &cobra.Command{
	Use:   "curl-replay <NUMBER>",
	Short: "Generate a curl command that replays the request from a specific log entry",
	Args:  cobra.MinimumNArgs(1),

	RunE: func(cmd *cobra.Command, args []string) error {
		i, err := strconv.Atoi(args[0])

		if err != nil {
			return fmt.Errorf("could not get the %s entry => %w", args[0], err)
		}

		content, err := profiles.GetNthRequestLog(i)

		if err != nil {
			return fmt.Errorf("couldn't get log: %v", err)
		}

		lines := strings.Split(content, "\n")
		if len(lines) == 0 {
			return fmt.Errorf("log entry has no content")
		}

		for i := range lines {
			lines[i] = strings.TrimSpace(lines[i])
		}

		requestLine := lines[0]
		parts := strings.Fields(requestLine)
		if len(parts) < 2 {
			return fmt.Errorf("invalid request line: %s", requestLine)
		}

		method := parts[0]
		path := parts[1]

		// Extract headers - they appear after the request line until an empty line
		var host string
		var headers []string
		lineIndex := 1

		for ; lineIndex < len(lines); lineIndex++ {
			line := lines[lineIndex]

			if line == "" {
				break
			}

			if strings.Contains(line, ": ") {
				headerParts := strings.SplitN(line, ": ", 2)
				if len(headerParts) == 2 {
					name := headerParts[0]
					value := headerParts[1]

					if name == "Host" {
						host = value
					}

					if name != "Content-Length" && name != "Accept-Encoding" {
						headers = append(headers, fmt.Sprintf("%s: %s", name, value))
					}

				}
			}
		}

		if host == "" {
			return fmt.Errorf("could not find Host header in request")
		}

		env := config.GetEnv()

		var template = "https://%s%s"

		var authUrl = ""

		reqURL, err := url.Parse(env.EPCC_API_BASE_URL)
		if err != nil {
			log.Debugf("Could not get base url defaulting to https")
			authUrl = fmt.Sprintf("https://%s/oauth/access_token", host)
		} else if reqURL.Scheme != "" {

			template = reqURL.Scheme + "://%s%s"
			authUrl = fmt.Sprintf("%s://%s/oauth/access_token", reqURL.Scheme, host)
		} else {
			authUrl = fmt.Sprintf("https://%s/oauth/access_token", host)
		}

		url := fmt.Sprintf(template, host, path)

		// Look for request body - it would be after the headers and before the response
		var body string
		bodyStartIndex := lineIndex + 1
		responseStartIndex := -1

		for j := bodyStartIndex; j < len(lines); j++ {
			if strings.HasPrefix(lines[j], "HTTP/") {
				responseStartIndex = j
				break
			}
		}

		if responseStartIndex > bodyStartIndex {
			bodyLines := lines[bodyStartIndex:responseStartIndex]
			if len(bodyLines) > 0 {
				body = strings.Join(bodyLines, "\n")
			}
		}

		// Build the curl command
		var sb strings.Builder
		sb.WriteString(fmt.Sprintf("curl -X %s \\\n  '%s'", method, url))

		for _, header := range headers {

			if strings.HasPrefix(header, "Authorization") && CurlInlineAuth {
				if env.EPCC_CLIENT_SECRET != "" {
					sb.WriteString(fmt.Sprintf(" \\\n  -H \"Authorization: Bearer $(curl -s -X POST '%s' -d 'client_id=%s' -d 'client_secret=%s' -d 'grant_type=client_credentials' | jq -r .access_token)\"", authUrl, env.EPCC_CLIENT_ID, env.EPCC_CLIENT_SECRET))
				} else {
					sb.WriteString(fmt.Sprintf(" \\\n  -H \"Authorization: Bearer $(curl -s -X POST '%s' -d 'client_id=%s' -d 'grant_type=implicit' | jq -r .access_token)\"", authUrl, env.EPCC_CLIENT_ID))
				}
			} else {
				sb.WriteString(fmt.Sprintf(" \\\n  -H '%s'", header))
			}

		}

		if strings.TrimSpace(body) != "" {

			escapedBody := strings.ReplaceAll(body, "'", "'\\''")
			sb.WriteString(fmt.Sprintf(" \\\n  -d '%s'", escapedBody))
		}

		fmt.Println(sb.String())
		return nil
	},
}

var LogsList = &cobra.Command{
	Use:   "list",
	Short: "List all HTTP logs",
	RunE: func(cmd *cobra.Command, args []string) error {
		files, err := profiles.GetAllRequestLogTitles()
		if err != nil {
			return err
		}

		for idx, name := range files {
			fmt.Printf("%d %s\n", idx, name)
		}
		return nil
	},
}

var LogsShow = &cobra.Command{
	Use:   "show <NUMBER>",
	Short: "Show HTTP logs for specific number, negative values are from the last value",
	Args:  cobra.MinimumNArgs(1),

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

		i, err := strconv.Atoi(args[0])

		if err != nil {
			return fmt.Errorf("could not get the %s entry => %w", args[0], err)
		}

		content, err := profiles.GetNthRequestLog(i)

		if err != nil {
			return fmt.Errorf("couldn't print logs: %v", err)
		}

		if LogsShowPrettyJson {
			for l := range strings.Lines(content) {

				var s any
				if err := gojson.Unmarshal([]byte(l), &s); err == nil {
					json.PrintJsonToStdout(l)
				} else {
					fmt.Print(l)
				}

			}
		} else {
			fmt.Println(content)
		}

		return nil
	},
}

var LogsShowPrettyJson = false

var NonAlphaCharacter = regexp.MustCompile("[^A-Za-z]+")

var OidcPort uint16 = 8080

var ResetStore = &cobra.Command{
	Use:   "reset-store [STORE_ID]",
	Short: "Resets a store to it's initial state on a \"best effort\" basis.",
	Long:  "This command resets a store to it's initial state. There are some limitations to this as for instance orders cannot be deleted, nor can audit entries.",
	Args:  cobra.MinimumNArgs(1),
	RunE: func(cmd *cobra.Command, args []string) error {
		ctx := clictx.Ctx

		e := config.GetEnv()

		if len(e.EPCC_CLI_DISABLE_RESOURCES) > 0 {
			return fmt.Errorf("Cannot use the reset-store command with EPCC_CLI_DISABLE_RESOURCES set")
		}

		overrides := &httpclient.HttpParameterOverrides{
			QueryParameters: nil,
			OverrideUrlPath: "",
		}

		storeId, err := getStoreId(ctx, args)
		if err != nil {
			return fmt.Errorf("could not determine store id: %w", err)
		}

		rx, err := regexp.Compile("^" + args[0] + "$")

		if err != nil {
			if storeId != args[0] {
				return fmt.Errorf("You are trying to reset store id '%s', but you passed '%s' to this command", storeId, args[0])
			}
		} else {
			if !rx.MatchString(storeId) {
				return fmt.Errorf("You are trying to reset store id '%s', but you passed '%s' to this command which doesn't match", storeId, args[0])
			}
		}

		errors := make([]string, 0)

		err = authentication.ClearCustomerToken()

		if err != nil {
			log.Warnf("Couldn't delete the customer token")
		}

		err = authentication.ClearAccountManagementAuthenticationToken()

		if err != nil {
			log.Warnf("Couldn't delete the account management token")
		}

		_, err = rest.GetInternal(ctx, overrides, []string{"customer-authentication-settings"}, false, false)

		if err != nil {
			errors = append(errors, err.Error())
		}

		_, err = rest.GetInternal(ctx, overrides, []string{"account-authentication-settings"}, false, false)

		if err != nil {
			errors = append(errors, err.Error())
		}

		_, err = rest.GetInternal(ctx, overrides, []string{"merchant-realm-mappings"}, false, false)

		if err != nil {
			errors = append(errors, err.Error())
		}

		_, err = rest.GetInternal(ctx, overrides, []string{"authentication-realms"}, false, false)

		if err != nil {
			errors = append(errors, err.Error())
		}

		err, resetUndeletableResourcesErrors := resetResourcesUndeletableResources(ctx, overrides)

		if err != nil {
			return err
		}

		errors = append(errors, resetUndeletableResourcesErrors...)

		resourceNames := resources.GetPluralResourceNames()
		sort.Strings(resourceNames)
		err, deleteAllResourceDataErrors := deleteAllResourceData(resourceNames)
		if err != nil {
			return err
		}

		errors = append(errors, deleteAllResourceDataErrors...)

		if len(errors) > 0 {
			log.Warnf("The following errors occurred while deleting all data: \n\t%s", strings.Join(errors, "\n\t"))
		}

		err = aliases.ClearAllAliases()
		if err != nil {
			log.Warnf("Couldn't clear all aliases")
		}

		return nil

	},
}

var RootCmd = GetRootCommand()