config

var (
	ErrProfileNotFound = errors.New("profile not found")
)

var LoginFunc = func(ctx context.Context) (*megaport.Client, error) {
	return LoginFuncWithOutput(ctx, "")
}

var LoginFuncWithOutput = func(ctx context.Context, outputFormat string) (*megaport.Client, error) {
	var accessKey, secretKey string

	env, err := resolveEnvironment(false)
	if err != nil {
		return nil, err
	}

	if utils.ProfileOverride != "" {
		manager, err := NewConfigManager()
		if err != nil {
			return nil, fmt.Errorf("failed to load config: %w", err)
		}
		profile, err := manager.GetProfile(utils.ProfileOverride)
		if err != nil {
			return nil, fmt.Errorf("profile %q not found. Use 'megaport config list-profiles' to see available profiles", utils.ProfileOverride)
		}
		accessKey = profile.AccessKey
		secretKey = profile.SecretKey
	} else {

		if utils.Env != "" {

			accessKey = os.Getenv("MEGAPORT_ACCESS_KEY")
			secretKey = os.Getenv("MEGAPORT_SECRET_KEY")

			if accessKey == "" || secretKey == "" {
				manager, err := NewConfigManager()
				if err == nil {
					profile, _, err := manager.GetCurrentProfile()
					if err == nil {
						if accessKey == "" {
							accessKey = profile.AccessKey
						}
						if secretKey == "" {
							secretKey = profile.SecretKey
						}
					}
				}
			}
		} else {

			manager, err := NewConfigManager()
			if err == nil {
				profile, _, err := manager.GetCurrentProfile()
				if err == nil {
					accessKey = profile.AccessKey
					secretKey = profile.SecretKey
				}
			}

			if accessKey == "" {
				accessKey = os.Getenv("MEGAPORT_ACCESS_KEY")
			}
			if secretKey == "" {
				secretKey = os.Getenv("MEGAPORT_SECRET_KEY")
			}
		}
	}

	if accessKey == "" {
		return nil, fmt.Errorf("megaport API access key not provided. Configure an active profile or set MEGAPORT_ACCESS_KEY environment variable")
	}
	if secretKey == "" {
		return nil, fmt.Errorf("megaport API secret key not provided. Configure an active profile or set MEGAPORT_SECRET_KEY environment variable")
	}

	envOpt := environmentOption(env)
	httpClient := &http.Client{Timeout: 30 * time.Second}

	megaportClient, err := megaport.New(httpClient, megaport.WithCredentials(accessKey, secretKey), envOpt)
	if err != nil {
		return nil, err
	}

	spinner := output.PrintLoggingInWithOutput(false, outputFormat)
	_, err = megaportClient.Authorize(ctx)

	if err != nil {
		spinner.Stop()
		return nil, err
	} else {

		envDisplay := env
		if len(envDisplay) > 0 {
			envDisplay = strings.ToUpper(envDisplay[:1]) + envDisplay[1:]
		}
		spinner.StopWithSuccess(fmt.Sprintf("Successfully logged in to Megaport %s", envDisplay))
	}

	return megaportClient, nil
}

var NewUnauthenticatedClientFunc = func() (*megaport.Client, error) {
	env, err := resolveEnvironment(true)
	if err != nil {
		return nil, err
	}

	envOpt := environmentOption(env)
	httpClient := &http.Client{Timeout: 30 * time.Second}
	return megaport.New(httpClient, envOpt)
}