http

var (
	// Response is a lens-like accessor that extracts the *http.Response
	// from a FullResponse. It provides functional access to the response
	// metadata including status code, headers, and other HTTP response fields.
	//
	// Example:
	//   fullResp := MakePair(response, bodyBytes)
	//   resp := Response(fullResp)
	//   statusCode := resp.StatusCode
	Response = P.Head[*H.Response, []byte]

	// Body is a lens-like accessor that extracts the response body bytes
	// from a FullResponse. It provides functional access to the raw body
	// content without needing to read from an io.Reader.
	//
	// Example:
	//   fullResp := MakePair(response, bodyBytes)
	//   body := Body(fullResp)
	//   content := string(body)
	Body = P.Tail[*H.Response, []byte]

	// FromResponse creates a function that constructs a FullResponse from
	// a given *http.Response. It returns a function that takes a body byte
	// slice and combines it with the response to create a FullResponse.
	//
	// This is useful for functional composition where you want to partially
	// apply the response and later provide the body.
	//
	// Example:
	//   makeFullResp := FromResponse(response)
	//   fullResp := makeFullResp(bodyBytes)
	FromResponse = P.FromHead[[]byte, *H.Response]

	// FromBody creates a function that constructs a FullResponse from
	// a given body byte slice. It returns a function that takes an
	// *http.Response and combines it with the body to create a FullResponse.
	//
	// This is useful for functional composition where you want to partially
	// apply the body and later provide the response.
	//
	// Example:
	//   makeFullResp := FromBody(bodyBytes)
	//   fullResp := makeFullResp(response)
	FromBody = P.FromTail[*H.Response, []byte]
)

var (

	// ValidateResponse validates an HTTP response and returns an Either.
	// It checks if the response has a successful status code (2xx range).
	//
	// Returns:
	//   - Right(*http.Response) if status code is 2xx
	//   - Left(error) with HttpError if status code is not 2xx
	//
	// Example:
	//   result := ValidateResponse(response)
	//   E.Fold(
	//       func(err error) { /* handle error */ },
	//       func(resp *http.Response) { /* handle success */ },
	//   )(result)
	ValidateResponse = E.FromPredicate(isValidStatus, StatusCodeError)

	// ValidateJSONResponse validates that an HTTP response is a valid JSON response.
	// It checks both the status code (must be 2xx) and the Content-Type header
	// (must be a JSON media type like "application/json").
	//
	// Returns:
	//   - Right(*http.Response) if response is valid JSON with 2xx status
	//   - Left(error) if status is not 2xx or Content-Type is not JSON
	//
	// Example:
	//   result := ValidateJSONResponse(response)
	//   E.Fold(
	//       func(err error) { /* handle non-JSON or error response */ },
	//       func(resp *http.Response) { /* handle valid JSON response */ },
	//   )(result)
	ValidateJSONResponse = F.Flow2(
		E.Of[error, *H.Response],
		E.ChainFirst(F.Flow5(
			GetHeader,
			R.Lookup[H.Header](HeaderContentType),
			O.Chain(A.First[string]),
			E.FromOption[string](errors.OnNone("unable to access the [%s] header", HeaderContentType)),
			E.ChainFirst(validateJSONContentTypeString),
		)))

	// ValidateJsonResponse checks if an HTTP response is a valid JSON response.
	//
	// Deprecated: use ValidateJSONResponse instead (note the capitalization).
	ValidateJsonResponse = ValidateJSONResponse
)