httprpc

var ClientTemplate = template.Must(template.New("").Funcs(map[string]interface{}{
	"ToLowerCamel": strcase.ToLowerCamel,
	"ToUpperCamel": strcase.ToUpperCamel,
	"ToURLPath":    httprpc.URLPath,
}).Parse(strings.TrimSpace(`
// Code generated by go-codegen api protobuf go_client httprpc; DO NOT EDIT

package {{.PackageName}}

{{.ImportPackages}}

{{$rootParam := .}}

type BodyMarshaler interface {
	Marshal(v proto.Message) (data []byte, err error)
	ContentType() string
}

type bodyMarshaler struct {
	marshalFunc func(v proto.Message) (data []byte, err error)
	contentType string
}

func (m bodyMarshaler) Marshal(v proto.Message) ([]byte, error) {
	return m.marshalFunc(v)
}

func (m bodyMarshaler) ContentType() string {
	return m.contentType
}

func NewBodyMarshaler(
	marshalFunc func(v proto.Message) (data []byte, err error),
	contentType string,
) BodyMarshaler {
	return bodyMarshaler{
		marshalFunc: marshalFunc,
		contentType: contentType,
	}
}

func NewJSONBodyMarshaler() BodyMarshaler {
	return NewBodyMarshaler(
		func(v proto.Message) ([]byte, error) {
			return json.Marshal(v)
		},
		"application/json",
	)
}

func NewProtoBodyMarshaler() BodyMarshaler {
	return NewBodyMarshaler(
		proto.Marshal,
		"application/protobuf",
	)
}

type BodyUnmarshaler interface {
	Unmarshal(data []byte, v proto.Message) error
}

type bodyUnmarshaler struct {
	unmarshalFunc func(data []byte, v proto.Message) error
}

func (m bodyUnmarshaler) Unmarshal(data []byte, v proto.Message) error {
	return m.unmarshalFunc(data, v)
}

func NewBodyUnmarshaler(
	unmarshalFunc func(data []byte, v proto.Message) error,
) BodyUnmarshaler {
	return bodyUnmarshaler{
		unmarshalFunc: unmarshalFunc,
	}
}

func NewJSONBodyUnmarshaler() BodyUnmarshaler {
	return NewBodyUnmarshaler(
		func(data []byte, v proto.Message) error {
			return json.Unmarshal(data, v)
		},
	)
}

func NewProtoBodyUnmarshaler() BodyUnmarshaler {
	return NewBodyUnmarshaler(
		proto.Unmarshal,
	)
}

func NewClient(
	httpClient *http.Client,
	urlBase url.URL,
	bodyMarshaler BodyMarshaler,
	bodyUnmarshaler BodyUnmarshaler,
	handleErrorResponse func(resp *http.Response) error,
) Client {
	return Client{
		httpClient: httpClient,
		urlBase: urlBase,
		bodyMarshaler: bodyMarshaler,
		bodyUnmarshaler: bodyUnmarshaler,
		handleErrorResponse: handleErrorResponse,
	}
}

type Client struct {
	httpClient *http.Client
	urlBase url.URL
	bodyMarshaler BodyMarshaler
	bodyUnmarshaler BodyUnmarshaler
	handleErrorResponse func(resp *http.Response) error
}

{{- range .Services}}
{{$service := .}}
{{- range .RPCs}}

{{$returnError := "return err"}}
{{if .OutputClientType}}
{{$returnError = "return output, err"}}
{{end}}

func (c Client){{.Name}}(ctx context.Context, input {{.InputClientType.Obj.Name}}) ({{if .OutputClientType}}output {{.OutputClientType.Obj.Name}}, err {{end}}error) {
	u := c.urlBase
	u.Path = path.Join(u.Path, "{{ToURLPath $service.Obj.Name .Name}}")

	inputProtoType := {{$rootParam.TypePrinter.PrintConverterWitoutErrorCheck "input" .InputClientType .InputProtoType}}
	b, err := c.bodyMarshaler.Marshal(&inputProtoType)
	if err != nil {
		{{$returnError}}
	}
	r, err := http.NewRequest("POST", u.String(), bytes.NewReader(b))
	if err != nil {
		{{$returnError}}
	}
	r = r.WithContext(ctx)
	r.Header.Set("Content-Type", c.bodyMarshaler.ContentType())

	resp, err := c.httpClient.Do(r)
	if err != nil {
		{{$returnError}}
	}
	defer func() {
		io.Copy(ioutil.Discard, resp.Body)
		resp.Body.Close()
	}()

	if resp.StatusCode >= 400 {
		err := c.handleErrorResponse(resp)
		{{$returnError}}
	}

	{{- if .OutputClientType}}
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		err = zaperr.Wrap(err, "failed to read response body", zap.Int("statusCode", resp.StatusCode))
		{{$returnError}}
	}
	outputProtoType := {{$rootParam.TypePrinter.PrintRelativeType .OutputProtoType}}{}
	if err := c.bodyUnmarshaler.Unmarshal(body, &outputProtoType); err != nil {
		err = zaperr.Wrap(err, "failed to parse response body", zap.String("body", string(body)))
		{{$returnError}}
	}
	return {{$rootParam.TypePrinter.PrintConverterWitoutErrorCheck "outputProtoType" .OutputProtoType .OutputClientType}}, nil
	{{- else}}
	return nil
	{{- end}}
}
{{- end}}
{{- end}}
`)))

var ClientTemplateUsedPackages = []*types.Package{
	types.NewPackage("net/http", "http"),
	types.NewPackage("net/url", "url"),
	types.NewPackage("bytes", "bytes"),
	types.NewPackage("context", "context"),
	types.NewPackage("io", "io"),
	types.NewPackage("io/ioutil", "ioutil"),
	types.NewPackage("path", "path"),
	types.NewPackage("go.uber.org/zap", "zap"),
	types.NewPackage("github.com/hori-ryota/zaperr", "zaperr"),
	types.NewPackage("encoding/json", "json"),
	types.NewPackage("google.golang.org/protobuf/proto", "proto"),
}