corehandlers

var AddHostExecEnvUserAgentHandler = request.NamedHandler{
	Name: "core.AddHostExecEnvUserAgentHandler",
	Fn: func(r *request.Request) {
		v := os.Getenv(execEnvVar)
		if len(v) == 0 {
			return
		}

		request.AddToUserAgent(r, execEnvUAKey+"/"+v)
	},
}

var AddRetryInfoHeaderHandler = request.NamedHandler{
	Name: "core.AddRetryInfoHeaderHandler",
	Fn: func(r *request.Request) {
		r.HTTPRequest.Header.Set(retryInvocationIDHeader, r.InvocationID)
		r.HTTPRequest.Header.Set(retryAttemptHeader,
			fmt.Sprintf("attempt=%d; max=%d", r.RetryCount+1, r.MaxRetries()+1))
	},
}

var AfterRetryHandler = request.NamedHandler{
	Name: "core.AfterRetryHandler",
	Fn: func(r *request.Request) {

		logger := r.Config.Logger

		if r.Retryable == nil || byteplus.BoolValue(r.Config.EnforceShouldRetryCheck) {
			r.Retryable = byteplus.Bool(r.ShouldRetry(r))
		}

		if r.WillRetry() {
			logger.DebugByLevel(byteplus.LogDebugWithRequestRetries, "[Retry] retry attempt", r.RetryCount+1, "of", r.MaxRetries(), "for request", r.RequestID, "with error", r.Error)
			r.RetryDelay = r.RetryRules(r)

			if sleepFn := r.Config.SleepDelay; sleepFn != nil {
				logger.DebugByLevel(byteplus.LogDebugWithRequestRetries, "[Retry] custom sleepFn, sleeping for", r.RetryDelay)

				sleepFn(r.RetryDelay)
			} else if err := byteplus.SleepWithContext(r.Context(), r.RetryDelay); err != nil {
				r.Error = bytepluserr.New(request.CanceledErrorCode,
					"request context canceled", err)
				r.Retryable = byteplus.Bool(false)
				logger.DebugByLevel(byteplus.LogDebugWithRequestRetries, "[Retry] canceled sleep", r.Error)
				return
			}

			if r.IsErrorExpired() {
				r.Config.Credentials.Expire()
			}

			r.RetryCount++
			r.Error = nil
		}
	}}

var BuildContentLengthHandler = request.NamedHandler{Name: "core.BuildContentLengthHandler", Fn: func(r *request.Request) {
	var length int64

	if slength := r.HTTPRequest.Header.Get("Content-Length"); slength != "" {
		length, _ = strconv.ParseInt(slength, 10, 64)
	} else {
		if r.Body != nil {
			var err error
			length, err = byteplus.SeekerLen(r.Body)
			if err != nil {
				r.Error = bytepluserr.New(request.ErrCodeSerialization, "failed to get request byteplusbody's length", err)
				return
			}
		}
	}

	if length > 0 {
		r.HTTPRequest.ContentLength = length
		r.HTTPRequest.Header.Set("Content-Length", fmt.Sprintf("%d", length))
	} else {
		r.HTTPRequest.ContentLength = 0
		r.HTTPRequest.Header.Del("Content-Length")
	}
}}

var CustomerRequestHandler = request.NamedHandler{
	Name: "core.CustomerRequestHandler",
	Fn: func(r *request.Request) {
		if r.Config.ExtendHttpRequest != nil {
			r.Config.ExtendHttpRequest(r.Context(), r.HTTPRequest)
		}

		if r.Config.ExtendHttpRequestWithMeta != nil {
			r.Config.ExtendHttpRequestWithMeta(r.Context(), r.HTTPRequest, custom.RequestMetadata{
				ServiceName: r.ClientInfo.ServiceName,
				Version:     r.ClientInfo.APIVersion,
				Action:      r.Operation.Name,
				HttpMethod:  r.Operation.HTTPMethod,
				Region:      *r.Config.Region,
			})
		}
	},
}

var SDKVersionUserAgentHandler = request.NamedHandler{
	Name: "core.SDKVersionUserAgentHandler",
	Fn: request.MakeAddToUserAgentHandler(byteplus.SDKName, byteplus.SDKVersion,
		runtime.Version(), runtime.GOOS, runtime.GOARCH),
}

var SendHandler = request.NamedHandler{
	Name: "core.SendHandler",
	Fn: func(r *request.Request) {
		sender := sendFollowRedirects
		if r.DisableFollowRedirects {
			sender = sendWithoutFollowRedirects
		}

		if request.NoBody == r.HTTPRequest.Body {

			reqOrig, reqCopy := r.HTTPRequest, *r.HTTPRequest
			reqCopy.Body = nil
			r.HTTPRequest = &reqCopy
			defer func() {
				r.HTTPRequest = reqOrig
			}()
		}

		var err error
		r.HTTPResponse, err = sender(r)
		if err != nil {
			handleSendError(r, err)
		}
	},
}

var ValidateEndpointHandler = request.NamedHandler{Name: "core.ValidateEndpointHandler", Fn: func(r *request.Request) {
	if r.ClientInfo.SigningRegion == "" && byteplus.StringValue(r.Config.Region) == "" && r.Config.DynamicCredentials == nil {
		r.Error = byteplus.ErrMissingRegion
	} else if r.ClientInfo.Endpoint == "" {
		r.Error = byteplus.ErrMissingEndpoint
	}
}}

var ValidateParametersHandler = request.NamedHandler{Name: "core.ValidateParametersHandler", Fn: func(r *request.Request) {
	if !r.ParamsFilled() {
		return
	}

	if v, ok := r.Params.(request.Validator); ok {
		if err := v.Validate(); err != nil {
			r.Error = err
		}
	}
}}

var ValidateReqSigHandler = request.NamedHandler{
	Name: "core.ValidateReqSigHandler",
	Fn: func(r *request.Request) {

		if r.Config.Credentials == credentials.AnonymousCredentials {
			return
		}

		signedTime := r.Time
		if !r.LastSignedAt.IsZero() {
			signedTime = r.LastSignedAt
		}

		if signedTime.Add(5 * time.Minute).After(time.Now()) {
			return
		}

		fmt.Println("request expired, resigning")
		r.Sign()
	},
}

var ValidateResponseHandler = request.NamedHandler{Name: "core.ValidateResponseHandler", Fn: func(r *request.Request) {
	if r.HTTPResponse.StatusCode == 0 || r.HTTPResponse.StatusCode >= 300 {

		r.Error = bytepluserr.New("UnknownError", "unknown error", nil)
	}
}}