template_files.go

// Code generated by go-bindata.
// sources:
// codegen/templates/augmented_mock.tmpl
// codegen/templates/dependency_struct.tmpl
// codegen/templates/endpoint.tmpl
// codegen/templates/endpoint_collection.tmpl
// codegen/templates/endpoint_test.tmpl
// codegen/templates/endpoint_test_tchannel_client.tmpl
// codegen/templates/fixture_types.tmpl
// codegen/templates/http_client.tmpl
// codegen/templates/main.tmpl
// codegen/templates/main_test.tmpl
// codegen/templates/middleware_http.tmpl
// codegen/templates/middleware_tchannel.tmpl
// codegen/templates/module_class_initializer.tmpl
// codegen/templates/module_initializer.tmpl
// codegen/templates/module_mock_initializer.tmpl
// codegen/templates/service.tmpl
// codegen/templates/service_mock.tmpl
// codegen/templates/structs.tmpl
// codegen/templates/tchannel_client.tmpl
// codegen/templates/tchannel_client_test_server.tmpl
// codegen/templates/tchannel_endpoint.tmpl
// codegen/templates/workflow.tmpl
// codegen/templates/workflow_mock.tmpl
// codegen/templates/workflow_mock_clients_type.tmpl
// DO NOT EDIT!

package templates

import (
	"fmt"
	"io/ioutil"
	"os"
	"path/filepath"
	"strings"
	"time"
)

type asset struct {
	bytes []byte
	info  os.FileInfo
}

type bindataFileInfo struct {
	name    string
	size    int64
	mode    os.FileMode
	modTime time.Time
}

func (fi bindataFileInfo) Name() string {
	return fi.name
}
func (fi bindataFileInfo) Size() int64 {
	return fi.size
}
func (fi bindataFileInfo) Mode() os.FileMode {
	return fi.mode
}
func (fi bindataFileInfo) ModTime() time.Time {
	return fi.modTime
}
func (fi bindataFileInfo) IsDir() bool {
	return false
}
func (fi bindataFileInfo) Sys() interface{} {
	return nil
}

var _augmented_mockTmpl = []byte(`{{- /* template to render client mock code for custom client */ -}}
{{- $methods := .Methods}}
{{- $fixturePkg := .Fixture.ImportPath -}}
{{- $scenarios := .Fixture.Scenarios -}}
package clientmock

import (
	"github.com/golang/mock/gomock"
)

// MockClientWithFixture is a mock of Client interface with preset fixture
type MockClientWithFixture struct {
	*MockClient
	fixture *ClientFixture

	{{range $method := $methods}}
	{{$methodName := $method.Name -}}
	{{$methodMockType := printf "%sMock" $methodName -}}
	{{camel $methodMockType}} *{{$methodMockType}}
	{{- end}}
}

// New creates a new mock instance
func New(ctrl *gomock.Controller, fixture *ClientFixture) *MockClientWithFixture {
	return &MockClientWithFixture{
		MockClient: NewMockClient(ctrl),
		fixture:    fixture,
	}
}

// EXPECT shadows the EXPECT method on the underlying mock client.
// It should not be called directly.
func (m *MockClientWithFixture) EXPECT() {
	panic("should not call EXPECT directly.")
}


{{range $method := $methods}}
{{$methodName := $method.Name -}}
{{$methodMockType := printf "%sMock" $methodName -}}
{{$methodMockField := camel $methodMockType -}}
{{$methodScenarios := index $scenarios $methodName -}}
// {{$methodMockType}} mocks the {{$methodName}} method
type {{$methodMockType}} struct {
	scenarios  *{{$methodName}}Scenarios
	mockClient *MockClient
}
{{$methodMockMethod := printf "Expect%s" $methodName -}}
// {{$methodMockMethod}} returns an object that allows the caller to choose expected scenario for {{$methodName}}
func (m *MockClientWithFixture) {{$methodMockMethod}}() *{{$methodMockType}} {
	if m.{{$methodMockField}} == nil {
		m.{{$methodMockField}} = &{{$methodMockType}}{
			scenarios:  m.fixture.{{$methodName}},
			mockClient: m.MockClient,
		}
	}
	return m.{{$methodMockField}}
}

{{- range $scenario := $methodScenarios -}}
{{$scenarioMethod := pascal $scenario}}
// {{$scenarioMethod}} sets the expected scenario as defined in the concrete fixture package
// {{$fixturePkg}}
func (s *{{$methodMockType}}) {{$scenarioMethod}}() {
	f := s.scenarios.{{$scenarioMethod}}

	{{range $argName, $argType := $method.In}}
	var {{$argName}} interface{}
	{{$argName}} = f.{{title $argName}}
	if f.{{title $argName}}Any {
		{{$argName}} = gomock.Any()
	}
	{{- end}}

	{{range $retName, $retType := $method.Out}}
	{{$retName}} := f.{{title $retName}}
	{{- end}}

	s.mockClient.EXPECT().{{$methodName}}({{$method.InString}}).Return({{$method.OutString}})
}
{{- end -}}
{{- end -}}
`)

func augmented_mockTmplBytes() ([]byte, error) {
	return _augmented_mockTmpl, nil
}

func augmented_mockTmpl() (*asset, error) {
	bytes, err := augmented_mockTmplBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "augmented_mock.tmpl", size: 2491, mode: os.FileMode(420), modTime: time.Unix(1, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _dependency_structTmpl = []byte(`{{$instance := . -}}
package module

import (
	{{range $classType, $moduleInstances := $instance.ResolvedDependencies -}}
	{{range $idx, $moduleInstance := $moduleInstances -}}
	{{$moduleInstance.PackageInfo.ImportPackageAlias}} "{{$moduleInstance.PackageInfo.ImportPackagePath}}"
	{{end -}}
	{{end}}

	zanzibar "github.com/uber/zanzibar/runtime"
)

// Dependencies contains dependencies for the {{$instance.InstanceName}} {{$instance.ClassName}} module
type Dependencies struct {
	Default *zanzibar.DefaultDependencies
	{{range $classType, $moduleInstances := $instance.ResolvedDependencies -}}
	{{$classType | pascal}} *{{$classType | pascal}}Dependencies
	{{end -}}
}

{{range $classType, $moduleInstances := $instance.ResolvedDependencies -}}
// {{$classType | pascal}}Dependencies contains {{$classType}} dependencies
type {{$classType | pascal}}Dependencies struct {
	{{ range $idx, $dependency := $moduleInstances -}}
	{{- /* TODO: the dependency type should cover all types instead of just interface type */ -}}
	{{$dependency.PackageInfo.QualifiedInstanceName}} {{$dependency.PackageInfo.ImportPackageAlias}}.{{$dependency.PackageInfo.ExportType}}
	{{end -}}
}
{{end -}}
`)

func dependency_structTmplBytes() ([]byte, error) {
	return _dependency_structTmpl, nil
}

func dependency_structTmpl() (*asset, error) {
	bytes, err := dependency_structTmplBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "dependency_struct.tmpl", size: 1180, mode: os.FileMode(420), modTime: time.Unix(1, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _endpointTmpl = []byte(`{{/* template to render gateway http endpoint code */ -}}
{{- $instance := .Instance }}
package {{$instance.PackageInfo.PackageName}}

{{- $reqHeaderMap := .ReqHeaders }}
{{- $reqHeaderMapKeys := .ReqHeadersKeys }}
{{- $reqHeaderRequiredKeys := .ReqRequiredHeadersKeys }}
{{- $resHeaderMap := .ResHeaders }}
{{- $resHeaderMapKeys := .ResHeadersKeys }}
{{- $resHeaderRequiredKeys := .ResRequiredHeadersKeys }}
{{- $clientName := title .ClientName }}
{{- $serviceMethod := printf "%s%s" (title .Method.ThriftService) (title .Method.Name) }}
{{- $handlerName := printf "%sHandler" $serviceMethod }}
{{- $clientMethodName := title .ClientMethodName }}
{{- $endpointId := .Spec.EndpointID }}
{{- $handleId := .Spec.HandleID }}
{{- $middlewares := .Spec.Middlewares }}
{{- $workflowPkg := .WorkflowPkg }}
{{- $workflowInterface := printf "%sWorkflow" $serviceMethod }}
{{- $traceKey := .TraceKey }}

import (
	"context"
	"encoding/json"
	"io/ioutil"
	"net/http"

	"github.com/opentracing/opentracing-go"
	"github.com/pkg/errors"
	"go.uber.org/thriftrw/ptr"
	"go.uber.org/zap"
	"go.uber.org/zap/zapcore"
	zanzibar "github.com/uber/zanzibar/runtime"

	{{range $idx, $pkg := .IncludedPackages -}}
	{{$pkg.AliasName}} "{{$pkg.PackageName}}"
	{{end -}}

	{{if .Method.Downstream }}
	{{- range $idx, $pkg := .Method.Downstream.IncludedPackages -}}
	{{$file := basePath $pkg.PackageName -}}
	{{$pkg.AliasName}} "{{$pkg.PackageName}}"
	{{end}}
	{{- end}}

	{{- if len $middlewares | ne 0 }}
	{{- range $idx, $middleware := $middlewares }}
	"{{$middleware.ImportPath}}"
	{{- end}}
	{{- end}}

	module "{{$instance.PackageInfo.ModulePackagePath}}"
)

{{with .Method -}}

// {{$handlerName}} is the handler for "{{.HTTPPath}}"
type {{$handlerName}} struct {
	Dependencies  *module.Dependencies
	endpoint      *zanzibar.RouterEndpoint
}

// New{{$handlerName}} creates a handler
func New{{$handlerName}}(deps *module.Dependencies) *{{$handlerName}} {
	handler := &{{$handlerName}}{
		Dependencies: deps,
	}
	handler.endpoint = zanzibar.NewRouterEndpoint(
		deps.Default.Logger, deps.Default.Scope, deps.Default.Tracer,
		"{{$endpointId}}", "{{$handleId}}",
		{{ if len $middlewares | ne 0 -}}
		zanzibar.NewStack([]zanzibar.MiddlewareHandle{
			{{range $idx, $middleware := $middlewares -}}
			deps.Middleware.{{$middleware.Name | pascal}}.NewMiddlewareHandle(
				{{$middleware.Name}}.Options{
				{{range $key, $value := $middleware.PrettyOptions -}}
					{{$key}} : {{$value}},
				{{end -}}
				},
			),
			{{end -}}
		}, handler.HandleRequest).Handle,
		{{- else -}}
		handler.HandleRequest,
		{{- end}}
	)
	return handler
}

// Register adds the http handler to the gateway's http router
func (h *{{$handlerName}}) Register(g *zanzibar.Gateway) error {
	return g.HTTPRouter.Register(
		"{{.HTTPMethod}}", "{{.HTTPPath}}",
		h.endpoint,
	)
}

// HandleRequest handles "{{.HTTPPath}}".
func (h *{{$handlerName}}) HandleRequest(
	ctx context.Context,
	req *zanzibar.ServerHTTPRequest,
	res *zanzibar.ServerHTTPResponse,
) {
	{{- if $reqHeaderRequiredKeys -}}
	if !req.CheckHeaders({{$reqHeaderRequiredKeys | printf "%#v" }}) {
		return
	}
	{{- end -}}

	{{if ne .RequestType ""}}
	var requestBody {{unref .RequestType}}

	{{- if ne .HTTPMethod "GET"}}
	if ok := req.ReadAndUnmarshalBody(&requestBody); !ok {
		return
	}
	{{end}}

	{{range $index, $line := .RequestParamGoStatements -}}
	{{$line}}
	{{end}}

	{{end}}

	{{range $index, $line := .ReqHeaderGoStatements -}}
	{{$line}}
	{{end}}

	{{range $index, $line := .ParseQueryParamGoStatements -}}
	{{$line}}
	{{end}}

	// log endpoint request to downstream services
	if ce := req.Logger.Check(zapcore.DebugLevel, "stub"); ce != nil {
		zfields := []zapcore.Field{
			zap.String("endpoint", h.endpoint.EndpointName),
		}
		{{- if ne .RequestType ""}}
		zfields = append(zfields, zap.String("body", fmt.Sprintf("%s", req.GetRawBody())))
		{{- end}}
		for _, k := range req.Header.Keys() {
			if val, ok := req.Header.Get(k); ok {
				zfields = append(zfields, zap.String(k, val))
			}
		}
		req.Logger.Debug("endpoint request to downstream", zfields...)
	}

	w := {{$workflowPkg}}.New{{$workflowInterface}}(h.Dependencies)
	if span := req.GetSpan(); span != nil {
		ctx = opentracing.ContextWithSpan(ctx, span)
	}

	{{if and (eq .RequestType "") (eq .ResponseType "")}}
	cliRespHeaders, err := w.Handle(ctx, req.Header)
	{{else if eq .RequestType ""}}
	response, cliRespHeaders, err := w.Handle(ctx, req.Header)
	{{else if eq .ResponseType ""}}
	cliRespHeaders, err := w.Handle(ctx, req.Header, &requestBody)
	{{else}}
	response, cliRespHeaders, err := w.Handle(ctx, req.Header, &requestBody)

	// log downstream response to endpoint
	if ce := req.Logger.Check(zapcore.DebugLevel, "stub"); ce != nil {
		zfields := []zapcore.Field{
			zap.String("endpoint", h.endpoint.EndpointName),
		}
		{{- if ne .ResponseType ""}}
		if body, err := json.Marshal(response); err == nil {
			zfields = append(zfields, zap.String("body", fmt.Sprintf("%s", body)))
		}
		{{- end}}
		for _, k := range cliRespHeaders.Keys() {
			if val, ok := cliRespHeaders.Get(k); ok {
				zfields = append(zfields, zap.String(k, val))
			}
		}
		if traceKey, ok := req.Header.Get("{{$traceKey}}"); ok {
			zfields = append(zfields, zap.String("{{$traceKey}}", traceKey))
		}
		req.Logger.Debug("downstream service response", zfields...)
	}

	{{end -}}
	if err != nil {
		{{- if eq (len .Exceptions) 0 -}}
		res.SendError(500, "Unexpected server error", err)
		return
		{{ else }}
		switch errValue := err.(type) {
		{{range $idx, $exception := .Exceptions}}
		case *{{$exception.Type}}:
			res.WriteJSON(
				{{$exception.StatusCode.Code}}, cliRespHeaders, errValue,
			)
			return
		{{end}}
		  default:
			 res.SendError(500, "Unexpected server error", err)
			 return
		}
		{{ end }}
	}

	{{if eq .ResponseType "" -}}
	res.WriteJSONBytes({{.OKStatusCode.Code}}, cliRespHeaders, nil)
	{{- else if eq .ResponseType "string" -}}
	bytes, err := json.Marshal(response)
	if err != nil {
		res.SendError(500, "Unexpected server error", errors.Wrap(err, "Unable to marshal resp json"))
		return
	}
	res.WriteJSONBytes({{.OKStatusCode.Code}}, cliRespHeaders, bytes)
	{{- else -}}
	res.WriteJSON({{.OKStatusCode.Code}}, cliRespHeaders, response)
	{{- end }}
}

{{end -}}
`)

func endpointTmplBytes() ([]byte, error) {
	return _endpointTmpl, nil
}

func endpointTmpl() (*asset, error) {
	bytes, err := endpointTmplBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "endpoint.tmpl", size: 6268, mode: os.FileMode(420), modTime: time.Unix(1, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _endpoint_collectionTmpl = []byte(`{{- $instance := .Instance -}}
{{- $endpointMeta := .EndpointMeta -}}

package {{$instance.PackageInfo.PackageName}}

import (
	module "{{$instance.PackageInfo.ModulePackagePath}}"
	zanzibar "github.com/uber/zanzibar/runtime"
)

// Endpoint registers a request handler on a gateway
type Endpoint interface{
	Register(*zanzibar.Gateway) error
}

// NewEndpoint returns a collection of endpoints that can be registered on
// a gateway
func NewEndpoint(deps *module.Dependencies) Endpoint {
	return &EndpointHandlers{
		{{- range $idx, $meta := $endpointMeta }}
		{{$serviceMethod := printf "%s%s" (title .Method.ThriftService) (title .Method.Name) -}}
		{{$handlerName := printf "%sHandler"  $serviceMethod -}}
		{{$handlerName}}: New{{$handlerName}}(deps),
		{{- end}}
	}
}


// EndpointHandlers is a collection of individual endpoint handlers
type EndpointHandlers struct {
	{{- range $idx, $meta := $endpointMeta }}
	{{$serviceMethod := printf "%s%s" (title $meta.Method.ThriftService) (title $meta.Method.Name) -}}
	{{$handlerName := printf "%sHandler"  $serviceMethod -}}
	{{$handlerName}} *{{$handlerName}}
	{{- end}}
}

// Register registers the endpoint handlers with the gateway
func (handlers *EndpointHandlers) Register(gateway *zanzibar.Gateway) error {
	{{- range $idx, $meta := $endpointMeta }}
	{{$serviceMethod := printf "%s%s" (title .Method.ThriftService) (title .Method.Name) -}}
	{{$handlerName := printf "%sHandler"  $serviceMethod -}}
	err{{$idx}} := handlers.{{$handlerName}}.Register(gateway)
	if err{{$idx}} != nil {
		return err{{$idx}}
	}
	{{- end}}
	return nil
}


`)

func endpoint_collectionTmplBytes() ([]byte, error) {
	return _endpoint_collectionTmpl, nil
}

func endpoint_collectionTmpl() (*asset, error) {
	bytes, err := endpoint_collectionTmplBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "endpoint_collection.tmpl", size: 1591, mode: os.FileMode(420), modTime: time.Unix(1, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _endpoint_testTmpl = []byte(`{{/* template to render gateway http endpoint tests */ -}}
{{- $instance := .Instance }}
package {{$instance.PackageInfo.PackageName}}

import (
	"bytes"
	"path/filepath"
	"net/http"
	"testing"
	"runtime"

	"github.com/stretchr/testify/assert"
	"github.com/uber/zanzibar/test/lib/bench_gateway"
	testBackend "github.com/uber/zanzibar/test/lib/test_backend"
	testGateway "github.com/uber/zanzibar/test/lib/test_gateway"
)

{{- $clientID := .ClientID }}
{{- $relativePathToRoot := .RelativePathToRoot}}
{{- $headers := .ReqHeaders }}
{{with .Method -}}
{{- $clientPackage := .Downstream.PackageName -}}
{{- $clientMethod := .DownstreamMethod -}}
{{- $clientMethodName := $clientMethod.Name | title -}}
{{- $clientMethodRequestType := fullTypeName  ($clientMethod).RequestType ($clientPackage) -}}
{{- $clientMethodResponseType := fullTypeName  ($clientMethod).ResponseType ($clientPackage) -}}


{{range $testName, $testFixture := $.TestFixtures}}

func getDirName{{$testFixture.HandleID | title}}{{$testFixture.TestName | title}}() string {
	_, file, _, _ := runtime.Caller(0)

	return filepath.Dir(file)
}

func Test{{$testFixture.HandleID | title}}{{$testFixture.TestName | title}}OKResponse(t *testing.T) {
	var counter int

	gateway, err := testGateway.CreateGateway(t, nil, &testGateway.Options{
		KnownHTTPBackends: []string{"{{$clientID}}"},
		TestBinary: filepath.Join(
			getDirName{{$testFixture.HandleID | title}}{{$testFixture.TestName | title}}(),
			"{{$relativePathToRoot}}",
			"build", "services", "{{$testFixture.TestServiceName}}",
			"main", "main.go",
		),
		ConfigFiles: []string{
			filepath.Join(
				getDirName{{$testFixture.HandleID | title}}{{$testFixture.TestName | title}}(),
				"{{$relativePathToRoot}}",
				"config", "test.json",
			),
			filepath.Join(
				getDirName{{$testFixture.HandleID | title}}{{$testFixture.TestName | title}}(),
				"{{$relativePathToRoot}}",
				"config", "{{$testFixture.TestServiceName}}", "test.json",
			),
		},
	})
	if !assert.NoError(t, err, "got bootstrap err") {
		return
	}
	defer gateway.Close()

	{{range $clientCallName, $clientCallFixture := $testFixture.ClientTestFixtures}}
	fake{{$clientCallFixture.ClientMethod | title}} := func(w http.ResponseWriter, r *http.Request) {

		{{range $k, $v := $clientCallFixture.ClientReqHeaders -}}
		assert.Equal(
			t,
			"{{$v}}",
			r.Header.Get("{{$k}}"))
		{{end}}

		{{range $k, $v := $clientCallFixture.ClientResHeaders -}}
		w.Header().Set("{{$k}}", "{{$v}}")
		{{end}}
		w.WriteHeader({{$.Method.OKStatusCode.Code}})

		{{ if $clientCallFixture.ClientResponse.Body -}}
		payload := []byte({{printf "` + "`" + `%s` + "`" + `" $clientCallFixture.ClientResponse.Body}})
		{{else}}
		var payload []byte
		{{- end}}

		// TODO(zw): generate client response.
		if _, err := w.Write(payload); err != nil {
			t.Fatal("can't write fake response")
		}
		counter++
	}

	gateway.HTTPBackends()["{{$clientID}}"].HandleFunc(
		"{{$clientMethod.HTTPMethod}}", "{{$clientMethod.HTTPPath}}", fake{{$clientCallFixture.ClientMethod | title}},
	)

	{{end -}}

	headers := map[string]string{}
	{{ if $headers -}}
	{{range $k, $v := $testFixture.EndpointReqHeaders -}}
	headers["{{$k}}"] = "{{$v}}"
	{{end}}
	{{- end}}

	{{ if $testFixture.EndpointRequest.Body -}}
	endpointRequest := []byte({{printf "` + "`" + `%s` + "`" + `" $testFixture.EndpointRequest.Body}})
	{{else}}
	endpointRequest := []byte(` + "`" + `{}` + "`" + `)
	{{- end}}

	res, err := gateway.MakeRequest(
		"{{$.Method.HTTPMethod}}",
		"{{$.Method.HTTPPath}}",
		headers,
		bytes.NewReader(endpointRequest),
	)
	if !assert.NoError(t, err, "got http error") {
		return
	}

	assert.Equal(t, {{$.Method.OKStatusCode.Code}}, res.StatusCode)
	{{range $k, $v := $testFixture.EndpointResHeaders -}}
	assert.Equal(
		t,
		"{{$v}}",
		res.Header.Get("{{$k}}"))	
	{{end}}
	assert.Equal(t, 1, counter)
}

{{end -}}
{{end -}}
`)

func endpoint_testTmplBytes() ([]byte, error) {
	return _endpoint_testTmpl, nil
}

func endpoint_testTmpl() (*asset, error) {
	bytes, err := endpoint_testTmplBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "endpoint_test.tmpl", size: 3821, mode: os.FileMode(420), modTime: time.Unix(1, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _endpoint_test_tchannel_clientTmpl = []byte(`{{/* template to render gateway http endpoint tests */}}
{{- $instance := .Instance }}
package {{$instance.PackageInfo.PackageName}}

import (
	"bytes"
	"context"
	{{if .Method.DownstreamMethod.ResponseType -}}
	"encoding/json"
	{{end -}}
	"path/filepath"
	"testing"
	{{if ne .Method.ResponseType "" -}}
	"io/ioutil"
	{{end}}

	"github.com/stretchr/testify/assert"
	testGateway "github.com/uber/zanzibar/test/lib/test_gateway"
	"github.com/uber/zanzibar/test/lib/util"

	{{range $idx, $pkg := .IncludedPackages -}}
	{{$pkg.AliasName}} "{{$pkg.PackageName}}"
	{{end}}
)

{{- $clientName := camel .ClientName -}}
{{- $headers := .ReqHeaders }}

{{with .Method -}}
{{- $responseType := .ResponseType -}}
{{- $clientPackage := .Downstream.PackageName -}}
{{- $thriftService := .DownstreamMethod.ThriftService -}}
{{- $clientMethod := .DownstreamMethod -}}
{{- $clientMethodName := $clientMethod.Name -}}
{{- $clientMethodRequestType := fullTypeName  ($clientMethod).RequestType ($clientPackage) -}}
{{- $clientMethodResponseType := fullTypeName  ($clientMethod).ResponseType ($clientPackage) -}}
{{- $counter := printf "test%sCounter" $clientMethodName -}}

{{range $testName, $testFixture := $.TestFixtures}}
func Test{{title $testFixture.HandleID}}{{title $testFixture.TestName}}OKResponse(t *testing.T) {
	{{$counter}} := 0

	gateway, err := testGateway.CreateGateway(t, map[string]interface{}{
		{{/* the serviceName here is service discovery name, therefore is ok to be arbitrary */ -}}
		"clients.{{$clientName}}.serviceName": "{{$clientName}}Service",
	}, &testGateway.Options{
	KnownTChannelBackends: []string{"{{$clientName}}"},
		TestBinary:            util.DefaultMainFile("{{$testFixture.TestServiceName}}"),
		ConfigFiles:           util.DefaultConfigFiles("{{$testFixture.TestServiceName}}"),
	})
	if !assert.NoError(t, err, "got bootstrap err") {
		return
	}
	defer gateway.Close()

	{{range $clientCallName, $clientCallFixture := $testFixture.ClientTestFixtures}}
	{{$clientFunc := printf "fake%s" (title $clientCallFixture.ClientMethod) -}}
	{{$clientFunc}} := func(
		ctx context.Context,
		reqHeaders map[string]string,
		{{if $clientMethod.RequestType -}}
		args {{$clientMethodRequestType}},
		{{end -}}
	) ({{- if $clientMethod.ResponseType -}}{{$clientMethodResponseType}}, {{- end -}}map[string]string, error) {
		{{$counter}}++

		{{range $k, $v := $clientCallFixture.ClientReqHeaders -}}
		assert.Equal(
			t,
			"{{$v}}",
			reqHeaders["{{$k}}"])
		{{end -}}

		var resHeaders map[string]string
		{{if (len $clientCallFixture.ClientResHeaders) -}}
		resHeaders = map[string]string{}
		{{end -}}
		{{range $k, $v := $clientCallFixture.ClientResHeaders -}}
		resHeaders["{{$k}}"] = "{{$v}}"
		{{end}}

		{{if $clientMethod.ResponseType -}}
		var res {{unref $clientMethod.ResponseType}}

		clientResponse := []byte({{printf "` + "`" + `%s` + "`" + `" $clientCallFixture.ClientResponse.Body}})
		err := json.Unmarshal(clientResponse, &res)
		if err!= nil {
			t.Fatal("cant't unmarshal client response json to client response struct")
			return nil, resHeaders, err
		}
		return &res, resHeaders, nil
		{{else -}}
		return resHeaders, nil
		{{end -}}
	}

	err = gateway.TChannelBackends()["{{$clientName}}"].Register(
		"{{$testFixture.EndpointID}}", "{{$testFixture.HandleID}}", "{{$thriftService}}::{{$clientMethodName}}",
		{{$clientPackage}}.New{{$thriftService}}{{title $clientMethodName}}Handler({{$clientFunc}}),
	)
	assert.NoError(t, err)
	{{end}}

	headers := map[string]string{}
	{{ if $headers -}}
	{{range $k, $v := $testFixture.EndpointReqHeaders -}}
	headers["{{$k}}"] = "{{$v}}"
	{{end}}
	{{- end}}

	{{ if $testFixture.EndpointRequest.Body -}}
	endpointRequest := []byte({{printf "` + "`" + `%s` + "`" + `" $testFixture.EndpointRequest.Body}})
	{{else}}
	endpointRequest := []byte(` + "`" + `{}` + "`" + `)
	{{- end}}

	res, err := gateway.MakeRequest(
		"{{$.Method.HTTPMethod}}",
		"{{$.Method.HTTPPath}}",
		headers,
		bytes.NewReader(endpointRequest),
	)
	if !assert.NoError(t, err, "got http error") {
		return
	}

	{{if $responseType -}}
	defer func() { _ = res.Body.Close() }()
	data, err := ioutil.ReadAll(res.Body)
	if !assert.NoError(t, err, "failed to read response body") {
		return
	}
	{{end}}

	assert.Equal(t, 1, {{$counter}})
	assert.Equal(t, {{$.Method.OKStatusCode.Code}}, res.StatusCode)
	{{range $k, $v := $testFixture.EndpointResHeaders -}}
	assert.Equal(
		t,
		"{{$v}}",
		res.Header.Get("{{$k}}"))
	{{end -}}
	{{if $responseType -}}
		assert.JSONEq(t, ` + "`" + `{{$testFixture.EndpointResponse.Body}}` + "`" + `, string(data))
	{{end -}}
}

{{end -}}
{{end -}}
`)

func endpoint_test_tchannel_clientTmplBytes() ([]byte, error) {
	return _endpoint_test_tchannel_clientTmpl, nil
}

func endpoint_test_tchannel_clientTmpl() (*asset, error) {
	bytes, err := endpoint_test_tchannel_clientTmplBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "endpoint_test_tchannel_client.tmpl", size: 4542, mode: os.FileMode(420), modTime: time.Unix(1, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _fixture_typesTmpl = []byte(`{{- /* template to render fixture type code for custom client */ -}}
{{- $imports := .Imports}}
{{- $methods := .Methods}}
{{- $scenariosMap := .Fixture.Scenarios}}
package clientmock

{{if (len $imports)}}
import (
	{{- range $path, $alias := $imports}}
	{{$alias}} "{{$path}}"
	{{- end}}
)
{{end}}

// ClientFixture defines the client fixture type
type ClientFixture struct {
{{- range $method := $methods}}
{{$methodName := $method.Name -}}
{{$methodName}} *{{$methodName}}Scenarios
{{- end -}}
}

{{range $method := $methods}}
{{$methodName := $method.Name -}}
{{$scenarios := index $scenariosMap $methodName -}}
// {{$methodName}}Scenarios defines all fixture scenarios for {{$methodName}}
type {{$methodName}}Scenarios struct {
{{range $scenario := $scenarios -}}
{{pascal $scenario}} *{{$methodName}}Fixture ` + "`" + `scenario:"{{$scenario}}"` + "`" + `
{{end -}}
}
{{end -}}


{{- range $method := $methods}}
{{$methodName := $method.Name -}}
// {{$methodName}}Fixture defines the fixture type for {{$methodName}}
type {{$methodName}}Fixture struct {
	{{- range $argName, $argType := $method.In}}
	{{title $argName}} {{$argType}}
	{{- end}}

	// Arg{n}Any indicates the nth argument could be gomock.Any
	{{- range $argName, $argType := $method.In}}
	{{title $argName}}Any bool
	{{- end}}

	{{range $retName, $retType := $method.Out}}
	{{title $retName}} {{$retType}}
	{{- end}}
}
{{- end}}
`)

func fixture_typesTmplBytes() ([]byte, error) {
	return _fixture_typesTmpl, nil
}

func fixture_typesTmpl() (*asset, error) {
	bytes, err := fixture_typesTmplBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "fixture_types.tmpl", size: 1379, mode: os.FileMode(420), modTime: time.Unix(1, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _http_clientTmpl = []byte(`{{- /* template to render edge gateway http client code */ -}}
{{- $instance := .Instance }}
package {{$instance.PackageInfo.PackageName}}

import (
	"context"
	"fmt"
	"strconv"
	"time"

	"github.com/pkg/errors"
	zanzibar "github.com/uber/zanzibar/runtime"

	module "{{$instance.PackageInfo.ModulePackagePath}}"
	{{range $idx, $pkg := .IncludedPackages -}}
	{{$pkg.AliasName}} "{{$pkg.PackageName}}"
	{{end}}
)

{{- $clientID := .ClientID -}}
{{$exposedMethods := .ExposedMethods -}}
{{- $clientName := printf "%sClient" (camel $clientID) }}
{{- $exportName := .ExportName}}
{{- $sidecarRouter := .SidecarRouter}}

// Client defines {{$clientID}} client interface.
type Client interface {
	HTTPClient() *zanzibar.HTTPClient
{{- range $svc := .Services -}}
{{range .Methods}}
{{$serviceMethod := printf "%s::%s" $svc.Name .Name -}}
{{$methodName := (title (index $exposedMethods $serviceMethod)) -}}
{{- if $methodName -}}
	{{$methodName}}(
		ctx context.Context,
		reqHeaders map[string]string,
		{{if ne .RequestType "" -}}
		args {{.RequestType}},
		{{end -}}
	) ({{- if ne .ResponseType "" -}} {{.ResponseType}}, {{- end -}}map[string]string, error)
{{- end -}}
{{- end -}}
{{- end -}}
}

// {{$clientName}} is the http client.
type {{$clientName}} struct {
	clientID string
	httpClient   *zanzibar.HTTPClient

	{{if $sidecarRouter -}}
	calleeHeader string
	callerHeader string
	callerName   string
	calleeName   string
	{{end -}}
}

// {{$exportName}} returns a new http client.
func {{$exportName}}(deps *module.Dependencies) Client {
	{{if $sidecarRouter -}}
	ip := deps.Default.Config.MustGetString("sidecarRouter.{{$sidecarRouter}}.http.ip")
	port := deps.Default.Config.MustGetInt("sidecarRouter.{{$sidecarRouter}}.http.port")
	callerHeader := deps.Default.Config.MustGetString("sidecarRouter.{{$sidecarRouter}}.http.callerHeader")
	calleeHeader := deps.Default.Config.MustGetString("sidecarRouter.{{$sidecarRouter}}.http.calleeHeader")
	callerName := deps.Default.Config.MustGetString("serviceName")
	calleeName := deps.Default.Config.MustGetString("clients.{{$clientID}}.serviceName")
	{{else -}}
	ip := deps.Default.Config.MustGetString("clients.{{$clientID}}.ip")
	port := deps.Default.Config.MustGetInt("clients.{{$clientID}}.port")
	{{end -}}
	baseURL := fmt.Sprintf("http://%s:%d", ip, port)
	timeout := time.Duration(deps.Default.Config.MustGetInt("clients.{{$clientID}}.timeout")) * time.Millisecond
	defaultHeaders := make(map[string]string)
	if deps.Default.Config.ContainsKey("clients.{{$clientID}}.defaultHeaders") {
		deps.Default.Config.MustGetStruct("clients.{{$clientID}}.defaultHeaders", &defaultHeaders)
	}

	return &{{$clientName}}{
		clientID: "{{$clientID}}",
		{{if $sidecarRouter -}}
		callerHeader: callerHeader,
		calleeHeader: calleeHeader,
		callerName: callerName,
		calleeName: calleeName,
		{{end -}}
		httpClient: zanzibar.NewHTTPClient(
			deps.Default.Logger, deps.Default.Scope,
			"{{$clientID}}",
			[]string{
				{{range $serviceMethod, $methodName := $exposedMethods -}}
				"{{$methodName}}",
				{{end}}
			},
			baseURL,
			defaultHeaders,
			timeout,
		),
	}
}

// HTTPClient returns the underlying HTTP client, should only be
// used for internal testing.
func (c *{{$clientName}}) HTTPClient() *zanzibar.HTTPClient {
	return c.httpClient
}

{{range $svc := .Services}}
{{range .Methods}}
{{$serviceMethod := printf "%s::%s" $svc.Name .Name -}}
{{$methodName := (title (index $exposedMethods $serviceMethod)) -}}
{{if $methodName -}}

// {{$methodName}} calls "{{.HTTPPath}}" endpoint.
func (c *{{$clientName}}) {{$methodName}}(
	ctx context.Context,
	headers map[string]string,
	{{if ne .RequestType "" -}}
	r {{.RequestType}},
	{{end -}}
) ({{- if ne .ResponseType "" -}} {{.ResponseType}}, {{- end -}}map[string]string, error) {
	{{if .ResponseType -}}
	var defaultRes  {{.ResponseType}}
	{{end -}}
	req := zanzibar.NewClientHTTPRequest(c.clientID, "{{$methodName}}", c.httpClient)

	{{if .ReqHeaderGoStatements }}
	{{range $index, $line := .ReqClientHeaderGoStatements -}}
	{{$line}}
	{{end -}}
	{{- end}}

	{{if $sidecarRouter -}}
	headers[c.callerHeader] = c.callerName
	headers[c.calleeHeader] = c.calleeName
	{{end}}

	// Generate full URL.
	fullURL := c.httpClient.BaseURL
	{{- range $k, $segment := .PathSegments -}}
	{{- if eq $segment.Type "static" -}}+"/{{$segment.Text}}"
	{{- else -}}+"/"+string(r{{$segment.BodyIdentifier | title}})
	{{- end -}}
	{{- end}}

	{{range $index, $line := .WriteQueryParamGoStatements -}}
	{{$line}}
	{{end}}

	{{$emptyBody := or (eq .HTTPMethod "GET") (eq .HTTPMethod "DELETE") -}}
	{{if (and (ne .RequestType "") (not $emptyBody))}}
	err := req.WriteJSON("{{.HTTPMethod}}", fullURL, headers, r)
	{{else}}
	err := req.WriteJSON("{{.HTTPMethod}}", fullURL, headers, nil)
	{{end}} {{- /* <if .RequestType ne ""> */ -}}
	if err != nil {
		return {{if eq .ResponseType ""}}nil, err{{else}}defaultRes, nil, err{{end}}
	}

	{{if .ReqHeaders }}
	headerErr := req.CheckHeaders({{.ReqHeaders | printf "%#v"}})
	if headerErr != nil {
		return {{ if eq .ResponseType "" -}}
			nil, headerErr
			{{- else -}}
			defaultRes, nil, headerErr
			{{- end}}
	}
	{{- end}}

	res, err := req.Do(ctx)
	if err != nil {
		return {{if eq .ResponseType ""}}nil, err{{else}}defaultRes, nil, err{{end}}
	}

	respHeaders := map[string]string{}
	for k := range res.Header {
		respHeaders[k] = res.Header.Get(k)
	}

	{{- if .ResHeaders }}
	// TODO(jakev): verify mandatory response headers
	{{- end}}

	res.CheckOKResponse([]int{
		{{- range $index, $code := .ValidStatusCodes -}}
		{{if $index}},{{end}}{{$code}}
		{{- end -}}
	})

	{{if and (eq .ResponseType "") (eq (len .Exceptions) 0)}}
	switch res.StatusCode {
		case {{.OKStatusCode.Code}}:
			_, err = res.ReadAll()
			if err != nil {
				return respHeaders, err
			}
			return respHeaders, nil
		default:
			_, err = res.ReadAll()
			if err != nil {
				return respHeaders, err
			}
	}
	{{else if eq (len .Exceptions) 0}}
	switch res.StatusCode {
		case {{.OKStatusCode.Code}}:
			var responseBody {{unref .ResponseType}}
			err = res.ReadAndUnmarshalBody(&responseBody)
			if err != nil {
				return defaultRes, respHeaders, err
			}

			{{- if .ResHeaderFields }}
			// TODO(jakev): read response headers and put them in body
			{{- end}}

			return {{if isPointerType .ResponseType}}&{{end}}responseBody, respHeaders, nil
		default:
			_, err = res.ReadAll()
			if err != nil {
				return defaultRes, respHeaders, err
			}
	}
	{{else if eq .ResponseType ""}}
	switch res.StatusCode {
		case {{.OKStatusCode.Code}}:
			_, err = res.ReadAll()
			if err != nil {
				return respHeaders, err
			}

			return respHeaders, nil
		{{range $idx, $exception := .Exceptions}}
		case {{$exception.StatusCode.Code}}:
			var exception {{$exception.Type}}
			err = res.ReadAndUnmarshalBody(&exception)
			if err != nil {
				return respHeaders, err
			}
			return respHeaders, &exception
		{{end}}
		default:
			_, err = res.ReadAll()
			if err != nil {
				return respHeaders, err
			}
	}
	{{else}}
	switch res.StatusCode {
		case {{.OKStatusCode.Code}}:
			var responseBody {{unref .ResponseType}}
			err = res.ReadAndUnmarshalBody(&responseBody)
			if err != nil {
				return defaultRes, respHeaders, err
			}

			{{- if .ResHeaderFields }}
			// TODO(jakev): read response headers and put them in body
			{{- end}}

			return {{if isPointerType .ResponseType}}&{{end}}responseBody, respHeaders, nil
		{{range $idx, $exception := .Exceptions}}
		case {{$exception.StatusCode.Code}}:
			var exception {{$exception.Type}}
			err = res.ReadAndUnmarshalBody(&exception)
			if err != nil {
				return defaultRes, respHeaders, err
			}
			return defaultRes, respHeaders, &exception
		{{end}}
		default:
			_, err = res.ReadAll()
			if err != nil {
				return defaultRes, respHeaders, err
			}
	}
	{{end}}

	return {{if ne .ResponseType ""}}defaultRes, {{end}}respHeaders, &zanzibar.UnexpectedHTTPError{
		StatusCode: res.StatusCode,
		RawBody: res.GetRawBody(),
	}
}
{{end}}
{{end}}
{{end}}
`)

func http_clientTmplBytes() ([]byte, error) {
	return _http_clientTmpl, nil
}

func http_clientTmpl() (*asset, error) {
	bytes, err := http_clientTmplBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "http_client.tmpl", size: 8003, mode: os.FileMode(420), modTime: time.Unix(1, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _mainTmpl = []byte(`{{- /* template to render gateway main.go */ -}}
{{- $instance := . -}}

package main

import (
	"flag"
	"os"
	"os/signal"
	"path/filepath"
	"runtime"
	"strings"
	"syscall"

	"go.uber.org/zap"

	"github.com/uber/zanzibar/config"
	"github.com/uber/zanzibar/runtime"

	service "{{$instance.PackageInfo.GeneratedPackagePath}}"
	module "{{$instance.PackageInfo.ModulePackagePath}}"
)

var configFiles *string

func getDirName() string {
	_, file, _, _ := runtime.Caller(0)
	return zanzibar.GetDirnameFromRuntimeCaller(file)
}

func getConfig() *zanzibar.StaticConfig {
	var files []string

	if configFiles == nil {
		files = []string{}
	} else {
		files = strings.Split(*configFiles, ";")
	}

	return config.NewRuntimeConfigOrDie(files, nil)
}

func createGateway() (*zanzibar.Gateway, error) {
	config := getConfig()
	
	gateway, _, err := service.CreateGateway(config, nil)
	if err != nil {
		return nil, err
	}

	return gateway, nil
}

func logAndWait(server *zanzibar.Gateway) {
	server.Logger.Info("Started {{$instance.InstanceName | pascal}}",
		zap.String("realHTTPAddr", server.RealHTTPAddr),
		zap.String("realTChannelAddr", server.RealTChannelAddr),
		zap.Any("config", server.InspectOrDie()),
	)

	go func(){
		sig := make(chan os.Signal, 1)
		signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM)
		<-sig
		server.WaitGroup.Add(1)
		server.Shutdown()
		server.WaitGroup.Done()
	}()
	server.Wait()
}

func readFlags() {
	configFiles = flag.String(
		"config",
		"",
		"an ordered, semi-colon separated list of configuration files to use",
	)
	flag.Parse()
}

func main() {
	readFlags()
	server, err := createGateway()
	if err != nil {
		panic(err)
	}

	err = server.Bootstrap()
	if err != nil {
		panic(err)
	}

	logAndWait(server)
}
`)

func mainTmplBytes() ([]byte, error) {
	return _mainTmpl, nil
}

func mainTmpl() (*asset, error) {
	bytes, err := mainTmplBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "main.tmpl", size: 1738, mode: os.FileMode(420), modTime: time.Unix(1, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _main_testTmpl = []byte(`{{- /* template to render gateway main_test.go 
This template is the test entrypoint for spawning a gateway
as a child process using the test coverage features etc.
*/ -}}
{{- $instance := . -}}

package main

import (
	"flag"
	"os"
	"os/signal"
	"syscall"
	"testing"

	"go.uber.org/zap"
	"go.uber.org/zap/zapcore"
	"github.com/uber/zanzibar/runtime"

	module "{{$instance.PackageInfo.ModulePackagePath}}"
)

var cachedServer *zanzibar.Gateway

func TestMain(m *testing.M) {
	readFlags()
	if os.Getenv("GATEWAY_RUN_CHILD_PROCESS_TEST") != "" {
		listenOnSignals()

		code := m.Run()
		os.Exit(code)
	} else {
		os.Exit(0)
	}
}

func listenOnSignals() {
	sigs := make(chan os.Signal, 1)

	signal.Notify(sigs, syscall.SIGUSR2)

	go func() {
		_ = <-sigs

		if cachedServer != nil {
			cachedServer.Close()
		}
	}()
}

func TestStartGateway(t *testing.T) {
	testLogger := zap.New(
		zapcore.NewCore(
			zapcore.NewJSONEncoder(zap.NewProductionEncoderConfig()),
			os.Stderr,
			zap.InfoLevel,
		),
	)

	gateway, err := createGateway()
	if err != nil {
		testLogger.Error(
			"Failed to CreateGateway in TestStartGateway()",
			zap.Error(err),
		)
		return
	}

	cachedServer = gateway
	err = gateway.Bootstrap()
	if err != nil {
		testLogger.Error(
			"Failed to Bootstrap in TestStartGateway()",
			zap.Error(err),
		)
		return
	}
	logAndWait(gateway)
}
`)

func main_testTmplBytes() ([]byte, error) {
	return _main_testTmpl, nil
}

func main_testTmpl() (*asset, error) {
	bytes, err := main_testTmplBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "main_test.tmpl", size: 1351, mode: os.FileMode(420), modTime: time.Unix(1, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _middleware_httpTmpl = []byte(`{{$instance := . -}}

package {{$instance.PackageInfo.PackageName}}

import (
	zanzibar "github.com/uber/zanzibar/runtime"
	module "{{$instance.PackageInfo.ModulePackagePath}}"
	handle "{{index .Config "path"}}"
)

// Middleware is a container for module.Deps and factory for MiddlewareHandle
type Middleware struct {
	Deps *module.Dependencies
}

// NewMiddleware is a factory method for the struct
func NewMiddleware(deps *module.Dependencies) Middleware {
	return Middleware {
		Deps: deps,
	}
}

// NewMiddlewareHandle calls back to the custom middleware to build a MiddlewareHandle
func (m *Middleware) NewMiddlewareHandle(o handle.Options) zanzibar.MiddlewareHandle {
	return handle.NewMiddleware(m.Deps, o)
}


`)

func middleware_httpTmplBytes() ([]byte, error) {
	return _middleware_httpTmpl, nil
}

func middleware_httpTmpl() (*asset, error) {
	bytes, err := middleware_httpTmplBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "middleware_http.tmpl", size: 718, mode: os.FileMode(420), modTime: time.Unix(1, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _middleware_tchannelTmpl = []byte(`{{$instance := . -}}

package {{$instance.PackageInfo.PackageName}}

import (
	zanzibar "github.com/uber/zanzibar/runtime"
	module "{{$instance.PackageInfo.ModulePackagePath}}"
	handle "{{index .Config "path"}}"
)

// Middleware is a container for module.Deps and factory for MiddlewareHandle
type Middleware struct {
	Deps *module.Dependencies
}

// NewMiddleware is a factory method for the struct
func NewMiddleware(deps *module.Dependencies) Middleware {
	return Middleware {
		Deps: deps,
	}
}

// NewMiddlewareHandle calls back to the custom middleware to build a MiddlewareHandle
func (m *Middleware) NewMiddlewareHandle(o handle.Options) zanzibar.MiddlewareTchannelHandle {
	return handle.NewMiddleware(m.Deps, o)
}


`)

func middleware_tchannelTmplBytes() ([]byte, error) {
	return _middleware_tchannelTmpl, nil
}

func middleware_tchannelTmpl() (*asset, error) {
	bytes, err := middleware_tchannelTmplBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "middleware_tchannel.tmpl", size: 726, mode: os.FileMode(420), modTime: time.Unix(1, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _module_class_initializerTmpl = []byte(`{{- $className := index . 0 }}
{{- $instance := index . 1 }}

{{- $moduleInstances := (index $instance.RecursiveDependencies $className)}}
{{- $initializedDeps := printf "initialized%sDependencies" (title $className) }}

{{- if eq (len .) 3 }}
{{$initializedDeps}} := &{{index . 2}}.{{$className | title}}DependenciesNodes{}
{{- else }}
{{$initializedDeps}} := &{{$className | title}}DependenciesNodes{}
{{- end }}
tree.{{$className | title}} = {{$initializedDeps}}

{{- range $idx, $dependency := $moduleInstances}}
	{{- $pkgInfo := $dependency.PackageInfo }}
	{{$initializedDeps}}.{{$pkgInfo.QualifiedInstanceName}} = {{$pkgInfo.ImportPackageAlias}}.{{$pkgInfo.ExportName}}(&{{$pkgInfo.ModulePackageAlias}}.Dependencies{
	Default: initializedDefaultDependencies,
	{{- range $className, $moduleInstances := $dependency.ResolvedDependencies}}
	{{$className | pascal}}: &{{$pkgInfo.ModulePackageAlias}}.{{$className | pascal}}Dependencies{
		{{- range $idy, $subDependency := $moduleInstances}}
		{{$subDependency.PackageInfo.QualifiedInstanceName}}: initialized{{$className | pascal}}Dependencies.{{$subDependency.PackageInfo.QualifiedInstanceName}},
		{{- end}}
	},
	{{- end}}
})
{{- end}}
`)

func module_class_initializerTmplBytes() ([]byte, error) {
	return _module_class_initializerTmpl, nil
}

func module_class_initializerTmpl() (*asset, error) {
	bytes, err := module_class_initializerTmplBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "module_class_initializer.tmpl", size: 1191, mode: os.FileMode(420), modTime: time.Unix(1, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _module_initializerTmpl = []byte(`{{$instance := . -}}

package module

import (
	{{range $classType, $moduleInstances := $instance.RecursiveDependencies -}}
	{{range $idx, $moduleInstance := $moduleInstances -}}
	{{$moduleInstance.PackageInfo.ImportPackageAlias}} "{{$moduleInstance.PackageInfo.ImportPackagePath}}"
	{{$moduleInstance.PackageInfo.ModulePackageAlias}} "{{$moduleInstance.PackageInfo.ModulePackagePath}}"
	{{end -}}
	{{end}}

	zanzibar "github.com/uber/zanzibar/runtime"
)

// DependenciesTree contains all deps for this service.
type DependenciesTree struct {
	{{range $idx, $className := $instance.DependencyOrder -}}
	{{$className | title}} *{{$className | title}}DependenciesNodes
	{{end -}}
}

{{range $idx, $className := $instance.DependencyOrder -}}
{{$moduleInstances := (index $instance.RecursiveDependencies $className) -}}
// {{$className | title}}DependenciesNodes contains {{$className}} dependencies
type {{$className | title}}DependenciesNodes struct {
	{{ range $idx, $dependency := $moduleInstances -}}
	{{$dependency.PackageInfo.QualifiedInstanceName}} {{$dependency.PackageInfo.ImportPackageAlias}}.{{$dependency.PackageInfo.ExportType}}
	{{end -}}
}
{{end -}}

// InitializeDependencies fully initializes all dependencies in the dep tree
// for the {{$instance.InstanceName}} {{$instance.ClassName}}
func InitializeDependencies(
	g *zanzibar.Gateway,
) (*DependenciesTree, *Dependencies) {
	tree := &DependenciesTree{}

	initializedDefaultDependencies := &zanzibar.DefaultDependencies{
		Logger:  g.Logger,
		Scope:   g.AllHostScope,
		Tracer:  g.Tracer,
		Config:  g.Config,
		Channel: g.Channel,
	}

	{{range $idx, $className := $instance.DependencyOrder}}
	{{template "module_class_initializer.tmpl" args $className $instance}}
	{{end}}

	dependencies := &Dependencies{
		Default: initializedDefaultDependencies,
		{{- range $className, $moduleInstances := $instance.ResolvedDependencies}}
		{{$className | pascal}}: &{{$className | pascal}}Dependencies{
			{{- range $idy, $subDependency := $moduleInstances}}
			{{$subDependency.PackageInfo.QualifiedInstanceName}}: initialized{{$className | pascal}}Dependencies.{{$subDependency.PackageInfo.QualifiedInstanceName}},
			{{- end}}
		},
		{{- end}}
	}

	return tree, dependencies
}
`)

func module_initializerTmplBytes() ([]byte, error) {
	return _module_initializerTmpl, nil
}

func module_initializerTmpl() (*asset, error) {
	bytes, err := module_initializerTmplBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "module_initializer.tmpl", size: 2237, mode: os.FileMode(420), modTime: time.Unix(1, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _module_mock_initializerTmpl = []byte(`{{$instance := .Instance -}}
{{$leafWithFixture := .LeafWithFixture -}}
{{$leafClass := index $instance.DependencyOrder 0 -}}
{{$mockDeps := printf "Mock%sNodes" (title $leafClass) -}}
{{$classPkg := "module" -}}

package {{$instance.PackageInfo.GeneratedPackageAlias}}mock

import (
	"testing"

	"github.com/golang/mock/gomock"
	zanzibar "github.com/uber/zanzibar/runtime"
	{{$classPkg}} "{{$instance.PackageInfo.ModulePackagePath}}"

	{{range $classType, $moduleInstances := $instance.RecursiveDependencies -}}
	{{range $idx, $moduleInstance := $moduleInstances -}}
	{{if eq $classType $leafClass -}}
	{{$moduleInstance.PackageInfo.GeneratedPackageAlias}} "{{$moduleInstance.PackageInfo.GeneratedPackagePath}}/mock-client"
	{{if (index $leafWithFixture $moduleInstance.InstanceName) -}}
	fixture{{$moduleInstance.PackageInfo.ImportPackageAlias}} "{{index $leafWithFixture $moduleInstance.InstanceName}}"
	{{end -}}
	{{else -}}
	{{$moduleInstance.PackageInfo.ImportPackageAlias}} "{{$moduleInstance.PackageInfo.ImportPackagePath}}"
	{{$moduleInstance.PackageInfo.ModulePackageAlias}} "{{$moduleInstance.PackageInfo.ModulePackagePath}}"
	{{end -}}
	{{end -}}
	{{end}}
)

{{$moduleInstances := (index $instance.RecursiveDependencies $leafClass) -}}
// {{$mockDeps}} contains mock {{$leafClass}} dependencies
type {{$mockDeps}} struct {
	{{ range $idx, $dependency := $moduleInstances -}}
	{{- if (index $leafWithFixture $dependency.InstanceName) }}
	{{$dependency.PackageInfo.QualifiedInstanceName}} *{{$dependency.PackageInfo.GeneratedPackageAlias}}.Mock{{$dependency.PackageInfo.ExportType}}WithFixture
	{{- else }}
	{{$dependency.PackageInfo.QualifiedInstanceName}} *{{$dependency.PackageInfo.GeneratedPackageAlias}}.Mock{{$dependency.PackageInfo.ExportType}}
	{{- end }}
	{{- end}}
}

// InitializeDependenciesMock fully initializes all dependencies in the dep tree
// for the {{$instance.InstanceName}} {{$instance.ClassName}} with leaf nodes being mocks
func InitializeDependenciesMock(
	g *zanzibar.Gateway,
	ctrl *gomock.Controller,
) (*{{$classPkg}}.DependenciesTree, *{{$classPkg}}.Dependencies, *{{$mockDeps}}) {
	tree := &{{$classPkg}}.DependenciesTree{}

	initializedDefaultDependencies := &zanzibar.DefaultDependencies{
		Logger:  g.Logger,
		Scope:   g.AllHostScope,
		Config:  g.Config,
		Channel: g.Channel,
		Tracer:  g.Tracer,
	}

	{{range $idx, $className := $instance.DependencyOrder}}
	{{if eq $className $leafClass -}}
	{{- $moduleInstances := (index $instance.RecursiveDependencies $className)}}
	{{camel $mockDeps}} := &{{$mockDeps}}{
		{{- range $idx, $dependency := $moduleInstances}}
		{{- $pkgInfo := $dependency.PackageInfo }}
		{{- if (index $leafWithFixture $dependency.InstanceName) }}
		{{$pkgInfo.QualifiedInstanceName}}: {{$pkgInfo.GeneratedPackageAlias}}.New(ctrl, fixture{{$pkgInfo.ImportPackageAlias}}.Fixture),
		{{- else }}
		{{$pkgInfo.QualifiedInstanceName}}: {{$pkgInfo.GeneratedPackageAlias}}.NewMock{{title $className}}(ctrl),
		{{- end }}
		{{- end }}
	}
	{{- $initializedDeps := printf "initialized%sDependencies" (title $className) }}
	{{$initializedDeps}} := &{{$classPkg}}.{{$className | title}}DependenciesNodes{}
	tree.{{$className | title}} = {{$initializedDeps}}
	{{- range $idx, $dependency := $moduleInstances}}
	{{- $pkgInfo := $dependency.PackageInfo }}
	{{$initializedDeps}}.{{$pkgInfo.QualifiedInstanceName}} = {{camel $mockDeps}}.{{$pkgInfo.QualifiedInstanceName}}
	{{- end }}
	{{else -}}
	{{template "module_class_initializer.tmpl" args $className $instance $classPkg}}
	{{end}}
	{{end}}

	dependencies := &{{$classPkg}}.Dependencies{
		Default: initializedDefaultDependencies,
		{{- range $className, $moduleInstances := $instance.ResolvedDependencies}}
		{{$className | pascal}}: &{{$classPkg}}.{{$className | pascal}}Dependencies{
			{{- range $idy, $subDependency := $moduleInstances}}
			{{$subDependency.PackageInfo.QualifiedInstanceName}}: initialized{{$className | pascal}}Dependencies.{{$subDependency.PackageInfo.QualifiedInstanceName}},
			{{- end}}
		},
		{{- end}}
	}

	return tree, dependencies, {{camel $mockDeps}}
}
`)

func module_mock_initializerTmplBytes() ([]byte, error) {
	return _module_mock_initializerTmpl, nil
}

func module_mock_initializerTmpl() (*asset, error) {
	bytes, err := module_mock_initializerTmplBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "module_mock_initializer.tmpl", size: 4094, mode: os.FileMode(420), modTime: time.Unix(1, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _serviceTmpl = []byte(`{{- /* template to render gateway main.go */ -}}
{{- $instance := . -}}

package {{$instance.PackageInfo.GeneratedPackageAlias}}

import (
	"os"
	"path/filepath"
	"runtime"

	"go.uber.org/zap"
	"github.com/uber/zanzibar/runtime"

	module "{{$instance.PackageInfo.ModulePackagePath}}"
)

// DependenciesTree re-exported for convenience.
type DependenciesTree module.DependenciesTree

// CreateGateway creates a new instances of the {{$instance.InstanceName}}
// service with the specified config
func CreateGateway(
	config *zanzibar.StaticConfig,
	opts *zanzibar.Options,
) (*zanzibar.Gateway, interface{}, error) {
	gateway, err := zanzibar.CreateGateway(config, opts)
	if err != nil {
		return nil, nil, err
	}

	tree, dependencies := module.InitializeDependencies(gateway)
	registerErr := RegisterDeps(gateway, dependencies)
	if registerErr != nil {
		return nil, nil, registerErr
	}

	return gateway, (*DependenciesTree)(tree), nil
}

// RegisterDeps registers direct dependencies of the service
func RegisterDeps(g *zanzibar.Gateway, deps *module.Dependencies) error {
	var err error
	{{- range $class, $instances := $instance.ResolvedDependencies }}
	{{- range $idx, $instance := $instances }}
	err = deps.{{title $class}}.{{$instance.PackageInfo.QualifiedInstanceName}}.Register(g)
	if err != nil {
		return err
	}
	{{- end}}
	{{- end}}
	return nil
}
`)

func serviceTmplBytes() ([]byte, error) {
	return _serviceTmpl, nil
}

func serviceTmpl() (*asset, error) {
	bytes, err := serviceTmplBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "service.tmpl", size: 1358, mode: os.FileMode(420), modTime: time.Unix(1, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _service_mockTmpl = []byte(`{{- $instance := . -}}
{{- $leafClass := index .DependencyOrder 0 -}}
{{- $mockType := printf "Mock%sNodes" (title $leafClass) -}}
{{- $mock := printf "Mock%ss" (title $leafClass) -}}

package {{$instance.PackageInfo.GeneratedPackageAlias}}mock

import (
	"context"
	"errors"
	"io"
	"net/http"
	"path/filepath"
	"runtime"
	"testing"
	"time"


	"github.com/golang/mock/gomock"
	"github.com/uber/zanzibar/config"
	"github.com/uber/zanzibar/runtime"

	service "{{$instance.PackageInfo.GeneratedPackagePath}}"
)

// MockService interface
type MockService interface {
	MakeHTTPRequest(
		method string,
		url string,
		headers map[string]string,
		body io.Reader,
	) (*http.Response, error)
	MakeTChannelRequest(
		ctx context.Context,
		thriftService string,
		method string,
		headers map[string]string,
		req, resp zanzibar.RWTStruct,
	) (bool, map[string]string, error)
	{{$mock}}() *{{$mockType}}
	Server() *zanzibar.Gateway
	Start()
	Stop()
}

type mockService struct {
	started        bool
	server         *zanzibar.Gateway
	ctrl           *gomock.Controller
	{{camel $mock}}    *{{$mockType}}
	httpClient     *http.Client
	tChannelClient zanzibar.TChannelCaller
}

// MustCreateTestService creates a new MockService, panics if it fails doing so.
func MustCreateTestService(t *testing.T) MockService {
	_, file, _, _ := runtime.Caller(0)
	currentDir := zanzibar.GetDirnameFromRuntimeCaller(file)
	testConfigPath := filepath.Join(currentDir, "../../../../config/test.json")
	c := config.NewRuntimeConfigOrDie([]string{testConfigPath}, nil)

	server, err := zanzibar.CreateGateway(c, nil)
	if err != nil {
		panic(err)
	}

	ctrl := gomock.NewController(t)
	_, dependencies, mockNodes := InitializeDependenciesMock(server, ctrl)
	registerErr := service.RegisterDeps(server, dependencies)
	if registerErr != nil {
		panic(registerErr)
	}

	httpClient := &http.Client{
		Transport: &http.Transport{
			DisableKeepAlives:   false,
			MaxIdleConns:        500,
			MaxIdleConnsPerHost: 500,
		},
	}

	timeout := time.Duration(10000) * time.Millisecond
	timeoutPerAttempt := time.Duration(2000) * time.Millisecond

	tchannelClient := zanzibar.NewRawTChannelClient(
		server.Channel,
		server.Logger,
		server.RootScope,
		&zanzibar.TChannelClientOption{
			ServiceName:       server.ServiceName,
			ClientID:          "TestClient",
			Timeout:           timeout,
			TimeoutPerAttempt: timeoutPerAttempt,
		},
	)

	return &mockService{
		server:         		server,
		ctrl:                   ctrl,
		{{camel $mock}}:        mockNodes,
		httpClient:     		httpClient,
		tChannelClient: 		tchannelClient,
	}
}

// Server returns the mock server
func (m *mockService) Server() *zanzibar.Gateway {
	return m.server
}

// Start starts the mock server, panics if fails doing so
func (m *mockService) Start() {
	if err := m.server.Bootstrap(); err != nil {
		panic(err)
	}
	m.started = true
}

// Stop stops the mock server
func (m *mockService) Stop() {
	// m.ctrl.Finish() calls runtime.Goexit() on errors
	// put it in defer so cleanup is always done
	defer func(){
		m.server.Close()
		m.started = false
	}()
	m.ctrl.Finish()
}

// {{$mock}} returns the mock {{$leafClass}}s
func (m *mockService) {{$mock}}() *{{$mockType}} {
	return m.{{camel $mock}}
}

// MakeHTTPRequest makes a HTTP request to the mock server
func (m *mockService) MakeHTTPRequest(
	method string,
	url string,
	headers map[string]string,
	body io.Reader,
) (*http.Response, error) {
	if !m.started {
		return nil, errors.New("mock server is not started")
	}

	client := m.httpClient

	fullURL := "http://" + m.server.RealHTTPAddr + url

	req, err := http.NewRequest(method, fullURL, body)
	for headerName, headerValue := range headers {
		req.Header.Set(headerName, headerValue)
	}

	if err != nil {
		return nil, err
	}

	return client.Do(req)
}

// MakeTChannelRequest makes a TChannel request to the mock server
func (m *mockService) MakeTChannelRequest(
	ctx context.Context,
	thriftService string,
	method string,
	headers map[string]string,
	req, res zanzibar.RWTStruct,
) (bool, map[string]string, error) {
	if !m.started {
		return false, nil, errors.New("mock server is not started")
	}

	sc := m.server.Channel.GetSubChannel(m.server.ServiceName)
	sc.Peers().Add(m.server.RealTChannelAddr)
	return m.tChannelClient.Call(ctx, thriftService, method, headers, req, res)
}
`)

func service_mockTmplBytes() ([]byte, error) {
	return _service_mockTmpl, nil
}

func service_mockTmpl() (*asset, error) {
	bytes, err := service_mockTmplBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "service_mock.tmpl", size: 4338, mode: os.FileMode(420), modTime: time.Unix(1, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _structsTmpl = []byte(`{{- /* template to render edge gateway http client code */ -}}

{{- $instance := .Instance }}
package {{$instance.PackageInfo.PackageName}}

import (
	"runtime"
	"path/filepath"

	"github.com/uber/zanzibar/runtime"
	{{range $idx, $pkg := .Spec.IncludedPackages -}}
	{{$pkg.AliasName}} "{{$pkg.PackageName}}"
	{{end}}
)

func getDirName() string {
	_, file, _, _ := runtime.Caller(0)
	return zanzibar.GetDirnameFromRuntimeCaller(file)
}
`)

func structsTmplBytes() ([]byte, error) {
	return _structsTmpl, nil
}

func structsTmpl() (*asset, error) {
	bytes, err := structsTmplBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "structs.tmpl", size: 436, mode: os.FileMode(420), modTime: time.Unix(1, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _tchannel_clientTmpl = []byte(`{{- /* template to render edge gateway tchannel client code */ -}}
{{- $instance := .Instance }}
package {{$instance.PackageInfo.PackageName}}

import (
	"context"
	"errors"
	"strconv"
	"strings"
	"time"

	"go.uber.org/zap"

	zanzibar "github.com/uber/zanzibar/runtime"
	tchannel "github.com/uber/tchannel-go"

	module "{{$instance.PackageInfo.ModulePackagePath}}"
	{{range $idx, $pkg := .IncludedPackages -}}
	{{$pkg.AliasName}} "{{$pkg.PackageName}}"
	{{end}}
)

{{$clientID := .ClientID -}}
{{$exposedMethods := .ExposedMethods -}}
{{- $clientName := printf "%sClient" (camel $clientID) }}
{{- $exportName := .ExportName}}
{{- $sidecarRouter := .SidecarRouter}}
{{- $stagingReqHeader := .StagingReqHeader}}

// Client defines {{$clientID}} client interface.
type Client interface {
{{range $svc := .Services -}}
{{range .Methods}}
{{$serviceMethod := printf "%s::%s" $svc.Name .Name -}}
{{$methodName := (title (index $exposedMethods $serviceMethod)) -}}
{{- if $methodName -}}
	{{$methodName}}(
		ctx context.Context,
		reqHeaders map[string]string,
		{{if ne .RequestType "" -}}
		args {{.RequestType}},
		{{end -}}
	) ({{- if ne .ResponseType "" -}} {{.ResponseType}}, {{- end -}}map[string]string, error)
{{- end -}}
{{- end -}}
{{- end -}}
}

// NewClient returns a new TChannel client for service {{$clientID}}.
func {{$exportName}}(deps *module.Dependencies) Client {
	{{- /* this is the service discovery service name */}}
	serviceName := deps.Default.Config.MustGetString("clients.{{$clientID}}.serviceName")
	var routingKey string
	if deps.Default.Config.ContainsKey("clients.{{$clientID}}.routingKey") {
		routingKey = deps.Default.Config.MustGetString("clients.{{$clientID}}.routingKey")
	}
	sc := deps.Default.Channel.GetSubChannel(serviceName, tchannel.Isolated)

	{{if $sidecarRouter -}}
	ip := deps.Default.Config.MustGetString("sidecarRouter.{{$sidecarRouter}}.tchannel.ip")
	port := deps.Default.Config.MustGetInt("sidecarRouter.{{$sidecarRouter}}.tchannel.port")
	{{else -}}
	ip := deps.Default.Config.MustGetString("clients.{{$clientID}}.ip")
	port := deps.Default.Config.MustGetInt("clients.{{$clientID}}.port")
	{{end -}}
	sc.Peers().Add(ip + ":" + strconv.Itoa(int(port)))

	var scAltName string
	if deps.Default.Config.ContainsKey("clients.{{$clientID}}.staging.serviceName") {
		scAltName = deps.Default.Config.MustGetString("clients.{{$clientID}}.staging.serviceName")
		ipAlt := deps.Default.Config.MustGetString("clients.{{$clientID}}.staging.ip")
		portAlt := deps.Default.Config.MustGetInt("clients.{{$clientID}}.staging.port")

		scAlt := deps.Default.Channel.GetSubChannel(scAltName, tchannel.Isolated)
		scAlt.Peers().Add(ipAlt + ":" + strconv.Itoa(int(portAlt)))
	} else if deps.Default.Config.ContainsKey("clients.staging.all.serviceName") {
		scAltName = deps.Default.Config.MustGetString("clients.staging.all.serviceName")
		ipAlt := deps.Default.Config.MustGetString("clients.staging.all.ip")
		portAlt := deps.Default.Config.MustGetInt("clients.staging.all.port")

		scAlt := deps.Default.Channel.GetSubChannel(scAltName, tchannel.Isolated)
		scAlt.Peers().Add(ipAlt + ":" + strconv.Itoa(int(portAlt)))
	}

	{{/* TODO: (lu) maybe set these at per method level */ -}}
	timeout := time.Millisecond * time.Duration(
		deps.Default.Config.MustGetInt("clients.{{$clientID}}.timeout"),
	)
	timeoutPerAttempt := time.Millisecond * time.Duration(
		deps.Default.Config.MustGetInt("clients.{{$clientID}}.timeoutPerAttempt"),
	)

	methodNames := map[string]string{
		{{range $svc := .Services -}}
		{{range .Methods -}}
		{{$serviceMethod := printf "%s::%s" $svc.Name .Name -}}
		{{$methodName := (title (index $exposedMethods $serviceMethod)) -}}
			{{if $methodName -}}
			"{{$serviceMethod}}": "{{$methodName}}",
			{{end -}}
		{{ end -}}
		{{ end -}}
	}

	client := zanzibar.NewTChannelClient(
		deps.Default.Channel,
		deps.Default.Logger,
		deps.Default.Scope,
		&zanzibar.TChannelClientOption{
			ServiceName:       serviceName,
			ClientID:          "{{$clientID}}",
			MethodNames:       methodNames,
			Timeout:           timeout,
			TimeoutPerAttempt: timeoutPerAttempt,
			RoutingKey:        &routingKey,
			AltSubchannelName: scAltName,
		},
	)

	return &{{$clientName}}{
		client: client,
	}
}

// {{$clientName}} is the TChannel client for downstream service.
type {{$clientName}} struct {
	client *zanzibar.TChannelClient
}

{{range $svc := .Services}}
{{range .Methods}}
{{$serviceMethod := printf "%s::%s" $svc.Name .Name -}}
{{$methodName := (title (index $exposedMethods $serviceMethod)) -}}
{{if $methodName -}}
	// {{$methodName}} is a client RPC call for method "{{$serviceMethod}}"
	func (c *{{$clientName}}) {{$methodName}}(
		ctx context.Context,
		reqHeaders map[string]string,
		{{if ne .RequestType "" -}}
		args {{.RequestType}},
		{{end -}}
	) ({{- if ne .ResponseType "" -}} {{.ResponseType}}, {{- end -}}map[string]string, error) {
		var result {{.GenCodePkgName}}.{{title $svc.Name}}_{{title .Name}}_Result
		{{if .ResponseType -}}
		var resp {{.ResponseType}}
		{{end}}
		logger := c.client.Loggers["{{$serviceMethod}}"]

		{{if eq .RequestType "" -}}
			args := &{{.GenCodePkgName}}.{{title $svc.Name}}_{{title .Name}}_Args{}
		{{end -}}

		caller := c.client.Call
		if strings.EqualFold(reqHeaders["{{$stagingReqHeader}}"], "true") {
			caller = c.client.CallThruAltChannel
		}
		success, respHeaders, err := caller(
			ctx, "{{$svc.Name}}", "{{.Name}}", reqHeaders, args, &result,
		)

		if err == nil && !success {
			switch {
				{{range .Exceptions -}}
				case result.{{title .Name}} != nil:
					err = result.{{title .Name}}
				{{end -}}
				default:
					err = errors.New("{{$clientName}} received no result or unknown exception for {{title .Name}}")
			}
		}
		if err != nil {
			logger.Warn("TChannel client call returned error", zap.Error(err))
		{{if eq .ResponseType "" -}}
			return nil, err
		{{else -}}
			return resp, nil, err
		{{end -}}
		}

		{{if eq .ResponseType "" -}}
			return respHeaders, err
		{{else -}}
			resp, err = {{.GenCodePkgName}}.{{title $svc.Name}}_{{title .Name}}_Helper.UnwrapResponse(&result)
			if err != nil {
				logger.Warn("Unable to unwrap client response", zap.Error(err))
			}
			return resp, respHeaders, err
		{{end -}}
	}
{{end -}}
{{end -}}
{{end}}
`)

func tchannel_clientTmplBytes() ([]byte, error) {
	return _tchannel_clientTmpl, nil
}

func tchannel_clientTmpl() (*asset, error) {
	bytes, err := tchannel_clientTmplBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "tchannel_client.tmpl", size: 6271, mode: os.FileMode(420), modTime: time.Unix(1, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _tchannel_client_test_serverTmpl = []byte(`{{- /* template to render edge gateway tchannel server code */ -}}
{{- $instance := .Instance }}
package {{$instance.PackageInfo.PackageName}}

import (
	"context"
	"errors"
	"time"

	"github.com/uber/zanzibar/runtime"
	"go.uber.org/thriftrw/wire"

	{{range $idx, $pkg := .IncludedPackages -}}
	{{$pkg.AliasName}} "{{$pkg.PackageName}}"
	{{end}}
)

{{$exposedMethods := .ExposedMethods -}}
{{range $svc := .Services}}
{{range .Methods}}
{{$serviceMethod := printf "%s::%s" $svc.Name .Name -}}
{{$methodName := index $exposedMethods $serviceMethod -}}
{{if $methodName -}}
{{$privateName := lower .Name -}}
{{$genCodePkg := .GenCodePkgName -}}
{{$func := printf "%s%sFunc" $svc.Name (lintAcronym .Name) -}}
{{$handler := printf "%s%sHandler" $svc.Name (lintAcronym .Name) -}}
// {{$func}} is the handler function for "{{.Name}}" method of thrift service "{{$svc.Name}}".
type {{$func}} func (
	ctx context.Context,
	reqHeaders map[string]string,
	{{if ne .RequestType "" -}}
		args {{.RequestType}},
	{{end -}}
) ({{- if ne .ResponseType "" -}}{{.ResponseType}}, {{- end -}}map[string]string, error)

// New{{$handler}} wraps a handler function so it can be registered with a thrift server.
func New{{$handler}}(f {{$func}}) zanzibar.TChannelHandler {
	return &{{$handler}}{f}
}

// {{$handler}} handles the "{{.Name}}" method call of thrift service "{{$svc.Name}}".
type {{$handler}} struct {
	{{$privateName}} {{$func}}
}

// Handle parses request from wire value and calls corresponding handler function.
func (h *{{$handler}}) Handle(
	ctx context.Context,
	reqHeaders map[string]string,
	wireValue *wire.Value,
) (bool, zanzibar.RWTStruct, map[string]string, error) {
	var req {{$genCodePkg}}.{{title $svc.Name}}_{{title .Name}}_Args
	var res {{$genCodePkg}}.{{title $svc.Name}}_{{title .Name}}_Result

	if err := req.FromWire(*wireValue); err != nil {
		return false, nil, nil, err
	}

	{{- if and (eq .RequestType "") (eq .ResponseType "")}}
		respHeaders, err := h.{{$privateName}}(ctx, reqHeaders)
	{{- else if eq .RequestType ""}}
		r, respHeaders, err := h.{{$privateName}}(ctx, reqHeaders)
	{{- else if eq .ResponseType ""}}
		respHeaders, err := h.{{$privateName}}(ctx, reqHeaders, &req)
	{{- else}}
		r, respHeaders, err := h.{{$privateName}}(ctx, reqHeaders, &req)
	{{- end}}

	{{if eq (len .Exceptions) 0 -}}
		if err != nil {
			return false, nil, nil, err
		}
		{{if .ResponseType -}}
		res.Success = {{.RefResponse "r"}}
		{{end -}}
	{{else -}}
		if err != nil {
			switch v := err.(type) {
			{{$method := .Name -}}
			{{range .Exceptions -}}
				case *{{.Type}}:
					if v == nil {
						return false, nil, nil, errors.New(
							"Handler for {{$method}} returned non-nil error type *{{title .Name}} but nil value",
						)
					}
					res.{{title .Name}} = v
			{{end -}}
				default:
					return false, nil, nil, err
			}
		} {{if .ResponseType -}} else {
			res.Success = {{.RefResponse "r"}}
		} {{end -}}
	{{end}}

	return err == nil, &res, respHeaders, nil
}
{{end -}}
{{end -}}
{{end}}
`)

func tchannel_client_test_serverTmplBytes() ([]byte, error) {
	return _tchannel_client_test_serverTmpl, nil
}

func tchannel_client_test_serverTmpl() (*asset, error) {
	bytes, err := tchannel_client_test_serverTmplBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "tchannel_client_test_server.tmpl", size: 3014, mode: os.FileMode(420), modTime: time.Unix(1, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _tchannel_endpointTmpl = []byte(`{{- /* template to render edge gateway tchannel server code */ -}}
{{- $instance := .Instance }}
{{- $spec := .Spec }}
package {{$instance.PackageInfo.PackageName}}

{{- $middlewares := .Spec.Middlewares }}
import (
	"context"
	"time"

	"github.com/pkg/errors"
	"go.uber.org/thriftrw/wire"
	"go.uber.org/zap"
	tchannel "github.com/uber/tchannel-go"
	zanzibar "github.com/uber/zanzibar/runtime"

	{{range $idx, $pkg := .IncludedPackages -}}
	{{$pkg.AliasName}} "{{$pkg.PackageName}}"
	{{end -}}

	{{- if len $middlewares | ne 0 }}
	{{- range $idx, $middleware := $middlewares }}
	{{$middleware.Name}} "{{$middleware.ImportPath}}"
	{{- end}}
	{{- end}}

	module "{{$instance.PackageInfo.ModulePackagePath}}"
)

{{- $serviceMethod := printf "%s%s" (title .Method.ThriftService) (title .Method.Name) }}
{{- $methodName := .Method.Name }}
{{- $handlerName := printf "%sHandler"  $serviceMethod }}
{{- $genCodePkg := .Method.GenCodePkgName }}
{{- $workflowPkg := .WorkflowPkg }}
{{- $workflowInterface := printf "%sWorkflow" $serviceMethod }}
{{- $deputyReqHeader := .DeputyReqHeader}}
{{- $clientID := .ClientID }}

{{with .Method -}}
// New{{$handlerName}} creates a handler to be registered with a thrift server.
func New{{$handlerName}}(deps *module.Dependencies) *{{$handlerName}} {
	handler := &{{$handlerName}}{
		Deps: deps,
	}
	handler.endpoint = zanzibar.NewTChannelEndpoint(
		deps.Default.Logger, deps.Default.Scope,
		"{{$spec.EndpointID}}", "{{$spec.HandleID}}", "{{.ThriftService}}::{{.Name}}",
		{{ if len $middlewares | ne 0 -}}
			zanzibar.NewTchannelStack([]zanzibar.MiddlewareTchannelHandle{
			{{range $idx, $middleware := $middlewares -}}
				deps.Middleware.{{$middleware.Name | pascal}}.NewMiddlewareHandle(
					{{$middleware.Name}}.Options{
					{{range $key, $value := $middleware.PrettyOptions -}}
						{{$key}} : {{$value}},
					{{end -}}
					},
				),
			{{end -}}
			}, handler),
		{{- else -}}
			handler,
		{{- end}}
	)
	return handler
}

// {{$handlerName}} is the handler for "{{.ThriftService}}::{{.Name}}".
type {{$handlerName}} struct {
	Deps     *module.Dependencies
	endpoint *zanzibar.TChannelEndpoint
}

// Register adds the tchannel handler to the gateway's tchannel router
func (h *{{$handlerName}}) Register(g *zanzibar.Gateway) error {
	return g.TChannelRouter.Register(h.endpoint)
}

// Handle handles RPC call of "{{.ThriftService}}::{{.Name}}".
func (h *{{$handlerName}}) Handle(
	ctx context.Context,
	reqHeaders map[string]string,
	wireValue *wire.Value,
) (bool, zanzibar.RWTStruct, map[string]string, error) {
	wfReqHeaders := zanzibar.ServerTChannelHeader(reqHeaders)
	{{if .ReqHeaders -}}
	if err := wfReqHeaders.Ensure({{.ReqHeaders | printf "%#v" }}, h.endpoint.Logger); err != nil {
		return false, nil, nil, errors.Wrapf(
			err, "%s.%s (%s) missing request headers",
			h.endpoint.EndpointID, h.endpoint.HandlerID, h.endpoint.Method,
		)
	}
	{{- end}}

	var res {{$genCodePkg}}.{{title .ThriftService}}_{{title .Name}}_Result

	{{if ne .RequestType "" -}}
	var req {{unref .RequestType}}
	if err := req.FromWire(*wireValue); err != nil {
		h.endpoint.Logger.Warn("Error converting request from wire", zap.Error(err))
		return false, nil, nil, errors.Wrapf(
			err, "Error converting %s.%s (%s) request from wire",
			h.endpoint.EndpointID, h.endpoint.HandlerID, h.endpoint.Method,
		)
	}


	if hostPort, ok := reqHeaders["{{$deputyReqHeader}}"]; ok {
		if hostPort != "" {
			return h.redirectToDeputy(ctx, reqHeaders, hostPort, &req, &res)
		}
	}
	{{end -}}

	workflow := {{if $workflowPkg}}{{$workflowPkg}}.{{end}}New{{$workflowInterface}}(h.Deps)

	{{if and (eq .RequestType "") (eq .ResponseType "")}}
	wfResHeaders, err := workflow.Handle(ctx, wfReqHeaders)
	{{else if eq .RequestType ""}}
	r, wfResHeaders, err := workflow.Handle(ctx, wfReqHeaders)
	{{else if eq .ResponseType ""}}
	wfResHeaders, err := workflow.Handle(ctx, wfReqHeaders, &req)
	{{else}}
	r, wfResHeaders, err := workflow.Handle(ctx, wfReqHeaders, &req)
	{{end}}

	resHeaders := map[string]string{}
	if wfResHeaders != nil {
		for _, key := range wfResHeaders.Keys() {
			resHeaders[key], _ = wfResHeaders.Get(key)
		}
	}

	{{if eq (len .Exceptions) 0 -}}
		if err != nil {
			h.endpoint.Logger.Warn("Handler returned error", zap.Error(err))
			return false, nil, resHeaders, err
		}
		res.Success = r
	{{else -}}
		if err != nil {
			switch v := err.(type) {
			{{$method := .Name -}}
			{{range .Exceptions -}}
				case *{{.Type}}:
					h.endpoint.Logger.Warn(
						"Handler returned non-nil error type *{{.Type}} but nil value",
						zap.Error(err),
					)
					if v == nil {
						return false, nil, resHeaders, errors.Errorf(
							"%s.%s (%s) handler returned non-nil error type *{{.Type}} but nil value",
							h.endpoint.EndpointID, h.endpoint.HandlerID, h.endpoint.Method,
						)
					}
					res.{{title .Name}} = v
			{{end -}}
				default:
					h.endpoint.Logger.Warn("Handler returned error", zap.Error(err))
					return false, nil, resHeaders, errors.Wrapf(
						err, "%s.%s (%s) handler returned error",
						h.endpoint.EndpointID, h.endpoint.HandlerID, h.endpoint.Method,
					)
			}
		} {{if ne .ResponseType "" -}} else {
			res.Success = r
		} {{end -}}
	{{end}}

	{{- if .ResHeaders}}
	if wfResHeaders == nil {
		return false, nil, nil, errors.Wrapf(
			errors.Errorf(
				"Missing mandatory headers: %s",
				strings.Join({{.ResHeaders | printf "%#v" }}, ", "),
			),
			"%s.%s (%s) missing response headers",
			h.endpoint.EndpointID, h.endpoint.HandlerID, h.endpoint.Method,
		)
	}

	if err := wfResHeaders.Ensure({{.ResHeaders | printf "%#v" }}, h.endpoint.Logger); err != nil {
		return false, nil, nil, errors.Wrapf(
			err, "%s.%s (%s) missing response headers",
			h.endpoint.EndpointID, h.endpoint.HandlerID, h.endpoint.Method,
		)
	}
	{{- end}}

	return err == nil, &res, resHeaders, nil
}

{{if ne .RequestType "" -}}
// redirectToDeputy sends the request to deputy hostPort
func (h *{{$handlerName}}) redirectToDeputy(
	ctx context.Context,
	reqHeaders map[string]string,
	hostPort string,
	req *{{unref .RequestType}},
	res *{{$genCodePkg}}.{{title .ThriftService}}_{{title .Name}}_Result,
) (bool, zanzibar.RWTStruct, map[string]string, error) {
	var routingKey string
	if h.Deps.Default.Config.ContainsKey("tchannel.routingKey") {
		routingKey = h.Deps.Default.Config.MustGetString("tchannel.routingKey")
	}

	serviceName := h.Deps.Default.Config.MustGetString("tchannel.serviceName")
	timeout := time.Millisecond * time.Duration(
		h.Deps.Default.Config.MustGetInt("tchannel.deputy.timeout"),
	)

	timeoutPerAttempt := time.Millisecond * time.Duration(
		h.Deps.Default.Config.MustGetInt("tchannel.deputy.timeoutPerAttempt"),
	)

	methodNames := map[string]string{
		"{{.ThriftService}}::{{.Name}}": "{{$methodName}}",
	}

	sub := h.Deps.Default.Channel.GetSubChannel(serviceName, tchannel.Isolated)
	sub.Peers().Add(hostPort)
	client := zanzibar.NewTChannelClient(
		h.Deps.Default.Channel,
		h.Deps.Default.Logger,
		h.Deps.Default.Scope,
		&zanzibar.TChannelClientOption{
			ServiceName:       serviceName,
			ClientID:           "{{$clientID}}",
			MethodNames:       methodNames,
			Timeout:           timeout,
			TimeoutPerAttempt: timeoutPerAttempt,
			RoutingKey:        &routingKey,
		},
	)

	success, respHeaders, err := client.Call(ctx, "{{.ThriftService}}", "{{$methodName}}", reqHeaders, req, res)
	_ = sub.Peers().Remove(hostPort)
	return success, res, respHeaders, err
}
{{end -}}

{{end -}}
`)

func tchannel_endpointTmplBytes() ([]byte, error) {
	return _tchannel_endpointTmpl, nil
}

func tchannel_endpointTmpl() (*asset, error) {
	bytes, err := tchannel_endpointTmplBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "tchannel_endpoint.tmpl", size: 7479, mode: os.FileMode(420), modTime: time.Unix(1, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _workflowTmpl = []byte(`{{/* template to render gateway workflow interface code */ -}}
{{- $instance := .Instance }}
package workflow

{{- $endpointType := .Spec.EndpointType }}
{{- $reqHeaderMap := .ReqHeaders }}
{{- $reqHeaderMapKeys := .ReqHeadersKeys }}
{{- $reqHeaderRequiredKeys := .ReqRequiredHeadersKeys }}
{{- $resHeaderMap := .ResHeaders }}
{{- $resHeaderMapKeys := .ResHeadersKeys }}
{{- $clientName := title .ClientName }}
{{- $clientMethodName := title .ClientMethodName }}
{{- $serviceMethod := printf "%s%s" (title .Method.ThriftService) (title .Method.Name) }}
{{- $workflowInterface := printf "%sWorkflow" $serviceMethod }}
{{- $workflowStruct := camel $workflowInterface }}

import (
	"context"

	zanzibar "github.com/uber/zanzibar/runtime"

	{{range $idx, $pkg := .IncludedPackages -}}
	{{$pkg.AliasName}} "{{$pkg.PackageName}}"
	{{end -}}

	{{if .Method.Downstream }}
	{{- range $idx, $pkg := .Method.Downstream.IncludedPackages -}}
	{{$file := basePath $pkg.PackageName -}}
	{{$pkg.AliasName}} "{{$pkg.PackageName}}"
	{{end}}
	{{- end}}

	module "{{$instance.PackageInfo.ModulePackagePath}}"
	"go.uber.org/zap"
)

{{with .Method -}}
// {{$workflowInterface}} defines the interface for {{$serviceMethod}} workflow
type {{$workflowInterface}} interface {
Handle(
{{- if and (eq .RequestType "") (eq .ResponseType "") }}
	ctx context.Context,
	reqHeaders zanzibar.Header,
) (zanzibar.Header, error)
{{else if eq .RequestType "" }}
	ctx context.Context,
	reqHeaders zanzibar.Header,
) ({{.ResponseType}}, zanzibar.Header, error)
{{else if eq .ResponseType "" }}
	ctx context.Context,
	reqHeaders zanzibar.Header,
	r {{.RequestType}},
) (zanzibar.Header, error)
{{else}}
	ctx context.Context,
	reqHeaders zanzibar.Header,
	r {{.RequestType}},
) ({{.ResponseType}}, zanzibar.Header, error)
{{- end}}
}

{{end -}}

{{- if .Method.Downstream }}
{{- $method := .Method -}}
{{- with .Method -}}
{{- $methodName := title .Name }}
{{- $clientPackage := .Downstream.PackageName -}}
{{- $clientMethod := .DownstreamMethod -}}
{{- $clientReqType := fullTypeName ($clientMethod).RequestType ($clientPackage) -}}
{{- $clientResType := fullTypeName  ($clientMethod).ResponseType ($clientPackage) -}}
{{- $clientExceptions := .DownstreamMethod.Exceptions -}}

// New{{$workflowInterface}} creates a workflow
func New{{$workflowInterface}}(deps *module.Dependencies) {{$workflowInterface}} {
	return &{{$workflowStruct}}{
		Clients: deps.Client,
		Logger:  deps.Default.Logger,
	}
}

// {{$workflowStruct}} calls thrift client {{$clientName}}.{{$clientMethodName}}
type {{$workflowStruct}} struct {
	Clients *module.ClientDependencies
	Logger  *zap.Logger
}

// Handle calls thrift client.
func (w {{$workflowStruct}}) Handle(
{{- if and (eq .RequestType "") (eq .ResponseType "") }}
	ctx context.Context,
	reqHeaders zanzibar.Header,
) (zanzibar.Header, error) {
{{else if eq .RequestType "" }}
	ctx context.Context,
	reqHeaders zanzibar.Header,
) ({{.ResponseType}}, zanzibar.Header, error) {
{{else if eq .ResponseType "" }}
	ctx context.Context,
	reqHeaders zanzibar.Header,
	r {{.RequestType}},
) (zanzibar.Header, error) {
{{else}}
	ctx context.Context,
	reqHeaders zanzibar.Header,
	r {{.RequestType}},
) ({{.ResponseType}}, zanzibar.Header, error) {
{{- end}}
	{{- if ne .RequestType "" -}}
	clientRequest := convertTo{{title .Name}}ClientRequest(r)
	{{end}}

	{{- if len $method.PropagateHeadersGoStatements | ne 0 }}
		{{- if ne .RequestType "" -}}
			clientRequest = propagateHeaders{{title .Name}}ClientRequests(clientRequest, reqHeaders)
		{{- else -}}
			clientRequest := propagateHeaders{{title .Name}}ClientRequests(nil, reqHeaders)
		{{end}}
	{{end}}

	clientHeaders := map[string]string{}
	{{if (ne (len $reqHeaderMapKeys) 0) }}
	var ok bool
	var h string
	{{- end -}}
	{{range $i, $k := $reqHeaderMapKeys}}
	h, ok = reqHeaders.Get("{{$k}}")
	if ok {
		{{- $typedHeader := index $reqHeaderMap $k -}}
		clientHeaders["{{$typedHeader.TransformTo}}"] = h
	}
	{{- end}}
	{{if and (eq $clientReqType "") (eq $clientResType "")}}
		{{if (eq (len $resHeaderMap) 0) -}}
		_, err := w.Clients.{{$clientName}}.{{$clientMethodName}}(ctx, clientHeaders)
		{{else}}
		cliRespHeaders, err := w.Clients.{{$clientName}}.{{$clientMethodName}}(ctx, clientHeaders)
		{{- end }}
	{{else if eq $clientReqType ""}}
		{{if (eq (len $resHeaderMap) 0) -}}
		clientRespBody, _, err := w.Clients.{{$clientName}}.{{$clientMethodName}}(
			ctx, clientHeaders,
		)
		{{else}}
		clientRespBody, cliRespHeaders, err := w.Clients.{{$clientName}}.{{$clientMethodName}}(
			ctx, clientHeaders,
		)
		{{- end }}
	{{else if eq $clientResType ""}}
		{{if (eq (len $resHeaderMap) 0) -}}
		_, err := w.Clients.{{$clientName}}.{{$clientMethodName}}(
			ctx, clientHeaders, clientRequest,
		)
		{{else}}
		cliRespHeaders, err := w.Clients.{{$clientName}}.{{$clientMethodName}}(
			ctx, clientHeaders, clientRequest,
		)
		{{- end }}
	{{else}}
		{{if (eq (len $resHeaderMap) 0) -}}
		clientRespBody, _, err := w.Clients.{{$clientName}}.{{$clientMethodName}}(
			ctx, clientHeaders, clientRequest,
		)
		{{else}}
		clientRespBody, cliRespHeaders, err := w.Clients.{{$clientName}}.{{$clientMethodName}}(
			ctx, clientHeaders, clientRequest,
		)
		{{- end }}
	{{end -}}

	{{- $responseType := .ResponseType }}
	if err != nil {
		switch errValue := err.(type) {
			{{range $idx, $cException := $clientExceptions}}
			case *{{$cException.Type}}:
				serverErr := convert{{$methodName}}{{title $cException.Name}}(
					errValue,
				)
				{{if eq $responseType ""}}
				return nil, serverErr
				{{else if eq $responseType "string" }}
				return "", nil, serverErr
				{{else}}
				return nil, nil, serverErr
				{{end}}
			{{end}}
			default:
				w.Logger.Warn("Could not make client request",
					zap.Error(errValue),
					zap.String("client", "{{$clientName}}"),
				)

				{{if eq $responseType ""}}
				return nil, err
				{{else if eq $responseType "string" }}
				return "", nil, err
				{{else}}
				return nil, nil, err
				{{end}}
		}
	}

	// Filter and map response headers from client to server response.
	{{if eq $endpointType "tchannel" -}}
	resHeaders := zanzibar.ServerTChannelHeader{}
	{{- else -}}
	resHeaders := zanzibar.ServerHTTPHeader{}
	{{- end -}}
	{{range $i, $k := $resHeaderMapKeys}}
	{{- $resHeaderVal := index $resHeaderMap $k}}
	resHeaders.Set("{{$resHeaderVal.TransformTo}}", cliRespHeaders["{{$k}}"])
	{{- end}}

	{{if eq .ResponseType "" -}}
	return resHeaders, nil
	{{- else -}}
	response := convert{{.DownstreamService}}{{title .Name}}ClientResponse(clientRespBody)
	return response, resHeaders, nil
	{{- end -}}
}

{{if and (ne .RequestType "") (ne $clientReqType "") -}}
{{ range $key, $line := $method.ConvertRequestGoStatements -}}
{{$line}}
{{ end }}
{{end -}}

{{- $exceptionIndex := .ExceptionsIndex }}
{{range $idx, $cException := $clientExceptions}}
{{- $sException := index $exceptionIndex $cException.Name -}}

func convert{{$methodName}}{{title $cException.Name}}(
	clientError *{{$cException.Type}},
) *{{$sException.Type}} {
	// TODO: Add error fields mapping here.
	serverError := &{{$sException.Type}}{}
	return serverError
}
{{end}}

{{if and (ne .ResponseType "") (ne $clientResType "") -}}
{{ range $key, $line := $method.ConvertResponseGoStatements -}}
{{$line}}
{{ end }}

{{end -}}

{{- if len $method.PropagateHeadersGoStatements | ne 0 }}
{{ range $key, $line := $method.PropagateHeadersGoStatements -}}
{{$line}}
{{ end }}
{{end -}}

{{end -}}
{{end -}}
`)

func workflowTmplBytes() ([]byte, error) {
	return _workflowTmpl, nil
}

func workflowTmpl() (*asset, error) {
	bytes, err := workflowTmplBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "workflow.tmpl", size: 7462, mode: os.FileMode(420), modTime: time.Unix(1, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _workflow_mockTmpl = []byte(`{{$instance := .Instance -}}
{{$espec := .EndpointSpec -}}
{{$clientsWithFixture := .ClientsWithFixture -}}
{{$serviceMethod := printf "%s%s" (title $espec.ThriftServiceName) (title $espec.ThriftMethodName) -}}
{{$workflowInterface := printf "%sWorkflow" $serviceMethod -}}
{{$leafWithFixture := .ClientsWithFixture -}}
{{$leafClass := index $instance.DependencyOrder 0 -}}
{{$mockType := printf "Mock%sNodes" (title $leafClass) -}}
{{$classPkg := "module" -}}

package mock{{lower (camel $instance.InstanceName)}}workflow

import (
	"testing"

	"github.com/golang/mock/gomock"
	"go.uber.org/zap"
	zanzibar "github.com/uber/zanzibar/runtime"

	{{range $classType, $moduleInstances := $instance.RecursiveDependencies -}}
	{{range $idx, $moduleInstance := $moduleInstances -}}
	{{if eq $classType $leafClass -}}
	{{$moduleInstance.PackageInfo.ImportPackageAlias}} "{{$moduleInstance.PackageInfo.ImportPackagePath}}"
	{{$moduleInstance.PackageInfo.GeneratedPackageAlias}}mock "{{$moduleInstance.PackageInfo.GeneratedPackagePath}}/mock-client"
	{{if (index $leafWithFixture $moduleInstance.InstanceName) -}}
	fixture{{$moduleInstance.PackageInfo.ImportPackageAlias}} "{{index $leafWithFixture $moduleInstance.InstanceName}}"
	{{end -}}
	{{else -}}
	{{$moduleInstance.PackageInfo.ImportPackageAlias}} "{{$moduleInstance.PackageInfo.ImportPackagePath}}"
	{{$moduleInstance.PackageInfo.ModulePackageAlias}} "{{$moduleInstance.PackageInfo.ModulePackagePath}}"
	{{end -}}
	{{end -}}
	{{end -}}
	{{$instance.PackageInfo.PackageAlias}} "{{$instance.PackageInfo.PackagePath}}"
	module "{{$instance.PackageInfo.ModulePackagePath}}"
	workflow "{{$instance.PackageInfo.GeneratedPackagePath}}/workflow"
)

{{range $idx, $className := $instance.DependencyOrder -}}
{{$moduleInstances := (index $instance.RecursiveDependencies $className) -}}
// {{$className}}DependenciesNodes contains {{$className}} dependencies
type {{$className}}DependenciesNodes struct {
	{{ range $idx, $dependency := $moduleInstances -}}
	{{$dependency.PackageInfo.QualifiedInstanceName}} {{$dependency.PackageInfo.ImportPackageAlias}}.{{$dependency.PackageInfo.ExportType}}
	{{end -}}
}
{{end -}}


// New{{$workflowInterface}}Mock creates a workflow with mock clients
func New{{$workflowInterface}}Mock(t *testing.T) (workflow.{{$workflowInterface}}, *{{$mockType}}) {
	ctrl := gomock.NewController(t)

	initializedDefaultDependencies := &zanzibar.DefaultDependencies {
		Logger: zap.NewNop(),
	}

	{{range $idx, $className := $instance.DependencyOrder}}
	{{- $moduleInstances := (index $instance.RecursiveDependencies $className)}}
	{{- $initializedDeps := printf "initialized%sDependencies" (title $className) }}
	{{$initializedDeps}} := &{{$className}}DependenciesNodes{}
	{{if eq $className $leafClass -}}
	{{camel $mockType}} := &{{$mockType}}{
		{{- range $idx, $dependency := $moduleInstances}}
		{{- $pkgInfo := $dependency.PackageInfo }}
		{{- if (index $leafWithFixture $dependency.InstanceName) }}
		{{$pkgInfo.QualifiedInstanceName}}: {{$pkgInfo.GeneratedPackageAlias}}mock.New(ctrl, fixture{{$pkgInfo.ImportPackageAlias}}.Fixture),
		{{- else }}
		{{$pkgInfo.QualifiedInstanceName}}: {{$pkgInfo.GeneratedPackageAlias}}mock.NewMock{{title $className}}(ctrl),
		{{- end }}
		{{- end }}
	}
	{{- range $idx, $dependency := $moduleInstances}}
	{{- $pkgInfo := $dependency.PackageInfo }}
	{{$initializedDeps}}.{{$pkgInfo.QualifiedInstanceName}} = {{camel $mockType}}.{{$pkgInfo.QualifiedInstanceName}}
	{{- end }}
	{{else -}}
	{{- range $idx, $dependency := $moduleInstances}}
	{{- $pkgInfo := $dependency.PackageInfo }}
	{{$initializedDeps}}.{{$pkgInfo.QualifiedInstanceName}} = {{$pkgInfo.ImportPackageAlias}}.{{$pkgInfo.ExportName}}(&{{$pkgInfo.ModulePackageAlias}}.Dependencies{
	Default: initializedDefaultDependencies,
	{{- range $className, $moduleInstances := $dependency.ResolvedDependencies}}
	{{$className | pascal}}: &{{$pkgInfo.ModulePackageAlias}}.{{$className | pascal}}Dependencies{
		{{- range $idy, $subDependency := $moduleInstances}}
		{{$subDependency.PackageInfo.QualifiedInstanceName}}: initialized{{$className | pascal}}Dependencies.{{$subDependency.PackageInfo.QualifiedInstanceName}},
		{{- end}}
	},
	{{- end}}
})
{{- end}}
	{{end}}
	{{end}}

	w := {{$instance.PackageInfo.PackageAlias}}.New{{$workflowInterface}}(
		&{{$classPkg}}.Dependencies{
			Default: initializedDefaultDependencies,
			{{- range $className, $moduleInstances := $instance.ResolvedDependencies}}
			{{$className | pascal}}: &{{$classPkg}}.{{$className | pascal}}Dependencies{
				{{- range $idy, $subDependency := $moduleInstances}}
				{{$subDependency.PackageInfo.QualifiedInstanceName}}: initialized{{$className | pascal}}Dependencies.{{$subDependency.PackageInfo.QualifiedInstanceName}},
				{{- end}}
			},
			{{- end}}
		},
	)

	return w, {{camel $mockType}}
}`)

func workflow_mockTmplBytes() ([]byte, error) {
	return _workflow_mockTmpl, nil
}

func workflow_mockTmpl() (*asset, error) {
	bytes, err := workflow_mockTmplBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "workflow_mock.tmpl", size: 4831, mode: os.FileMode(420), modTime: time.Unix(1, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _workflow_mock_clients_typeTmpl = []byte(`{{$instance := .Instance -}}
{{$clientsWithFixture := .ClientsWithFixture -}}
{{$leafClass := index $instance.DependencyOrder 0 -}}
{{$typeName := printf "Mock%sNodes" (title $leafClass) -}}
{{$mockDeps := index $instance.RecursiveDependencies $leafClass -}}
package mock{{lower (camel $instance.InstanceName)}}workflow

import (
	{{range $idx, $moduleInstance := $mockDeps -}}
	{{$moduleInstance.PackageInfo.GeneratedPackageAlias}} "{{$moduleInstance.PackageInfo.GeneratedPackagePath}}/mock-{{$leafClass}}"
	{{end}}
)

// {{$typeName}} contains mock {{$leafClass}} dependencies for the {{$instance.InstanceName}} {{$instance.ClassName}} module
type {{$typeName}} struct {
	{{range $idx, $moduleInstance := $mockDeps -}}
	{{- $pkgInfo := $moduleInstance.PackageInfo }}
	{{- if (index $clientsWithFixture $moduleInstance.InstanceName) }}
	{{$pkgInfo.QualifiedInstanceName}} *{{$pkgInfo.GeneratedPackageAlias}}.Mock{{$pkgInfo.ExportType}}WithFixture
	{{- else }}
	{{$pkgInfo.QualifiedInstanceName}} *{{$pkgInfo.GeneratedPackageAlias}}.Mock{{$pkgInfo.ExportType}}
	{{- end }}
	{{- end }}
}
`)

func workflow_mock_clients_typeTmplBytes() ([]byte, error) {
	return _workflow_mock_clients_typeTmpl, nil
}

func workflow_mock_clients_typeTmpl() (*asset, error) {
	bytes, err := workflow_mock_clients_typeTmplBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "workflow_mock_clients_type.tmpl", size: 1087, mode: os.FileMode(420), modTime: time.Unix(1, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

// Asset loads and returns the asset for the given name.
// It returns an error if the asset could not be found or
// could not be loaded.
func Asset(name string) ([]byte, error) {
	cannonicalName := strings.Replace(name, "\\", "/", -1)
	if f, ok := _bindata[cannonicalName]; ok {
		a, err := f()
		if err != nil {
			return nil, fmt.Errorf("Asset %s can't read by error: %v", name, err)
		}
		return a.bytes, nil
	}
	return nil, fmt.Errorf("Asset %s not found", name)
}

// MustAsset is like Asset but panics when Asset would return an error.
// It simplifies safe initialization of global variables.
func MustAsset(name string) []byte {
	a, err := Asset(name)
	if err != nil {
		panic("asset: Asset(" + name + "): " + err.Error())
	}

	return a
}

// AssetInfo loads and returns the asset info for the given name.
// It returns an error if the asset could not be found or
// could not be loaded.
func AssetInfo(name string) (os.FileInfo, error) {
	cannonicalName := strings.Replace(name, "\\", "/", -1)
	if f, ok := _bindata[cannonicalName]; ok {
		a, err := f()
		if err != nil {
			return nil, fmt.Errorf("AssetInfo %s can't read by error: %v", name, err)
		}
		return a.info, nil
	}
	return nil, fmt.Errorf("AssetInfo %s not found", name)
}

// AssetNames returns the names of the assets.
func AssetNames() []string {
	names := make([]string, 0, len(_bindata))
	for name := range _bindata {
		names = append(names, name)
	}
	return names
}

// _bindata is a table, holding each asset generator, mapped to its name.
var _bindata = map[string]func() (*asset, error){
	"augmented_mock.tmpl":                augmented_mockTmpl,
	"dependency_struct.tmpl":             dependency_structTmpl,
	"endpoint.tmpl":                      endpointTmpl,
	"endpoint_collection.tmpl":           endpoint_collectionTmpl,
	"endpoint_test.tmpl":                 endpoint_testTmpl,
	"endpoint_test_tchannel_client.tmpl": endpoint_test_tchannel_clientTmpl,
	"fixture_types.tmpl":                 fixture_typesTmpl,
	"http_client.tmpl":                   http_clientTmpl,
	"main.tmpl":                          mainTmpl,
	"main_test.tmpl":                     main_testTmpl,
	"middleware_http.tmpl":               middleware_httpTmpl,
	"middleware_tchannel.tmpl":           middleware_tchannelTmpl,
	"module_class_initializer.tmpl":      module_class_initializerTmpl,
	"module_initializer.tmpl":            module_initializerTmpl,
	"module_mock_initializer.tmpl":       module_mock_initializerTmpl,
	"service.tmpl":                       serviceTmpl,
	"service_mock.tmpl":                  service_mockTmpl,
	"structs.tmpl":                       structsTmpl,
	"tchannel_client.tmpl":               tchannel_clientTmpl,
	"tchannel_client_test_server.tmpl":   tchannel_client_test_serverTmpl,
	"tchannel_endpoint.tmpl":             tchannel_endpointTmpl,
	"workflow.tmpl":                      workflowTmpl,
	"workflow_mock.tmpl":                 workflow_mockTmpl,
	"workflow_mock_clients_type.tmpl":    workflow_mock_clients_typeTmpl,
}

// AssetDir returns the file names below a certain
// directory embedded in the file by go-bindata.
// For example if you run go-bindata on data/... and data contains the
// following hierarchy:
//     data/
//       foo.txt
//       img/
//         a.png
//         b.png
// then AssetDir("data") would return []string{"foo.txt", "img"}
// AssetDir("data/img") would return []string{"a.png", "b.png"}
// AssetDir("foo.txt") and AssetDir("notexist") would return an error
// AssetDir("") will return []string{"data"}.
func AssetDir(name string) ([]string, error) {
	node := _bintree
	if len(name) != 0 {
		cannonicalName := strings.Replace(name, "\\", "/", -1)
		pathList := strings.Split(cannonicalName, "/")
		for _, p := range pathList {
			node = node.Children[p]
			if node == nil {
				return nil, fmt.Errorf("Asset %s not found", name)
			}
		}
	}
	if node.Func != nil {
		return nil, fmt.Errorf("Asset %s not found", name)
	}
	rv := make([]string, 0, len(node.Children))
	for childName := range node.Children {
		rv = append(rv, childName)
	}
	return rv, nil
}

type bintree struct {
	Func     func() (*asset, error)
	Children map[string]*bintree
}

var _bintree = &bintree{nil, map[string]*bintree{
	"augmented_mock.tmpl":                {augmented_mockTmpl, map[string]*bintree{}},
	"dependency_struct.tmpl":             {dependency_structTmpl, map[string]*bintree{}},
	"endpoint.tmpl":                      {endpointTmpl, map[string]*bintree{}},
	"endpoint_collection.tmpl":           {endpoint_collectionTmpl, map[string]*bintree{}},
	"endpoint_test.tmpl":                 {endpoint_testTmpl, map[string]*bintree{}},
	"endpoint_test_tchannel_client.tmpl": {endpoint_test_tchannel_clientTmpl, map[string]*bintree{}},
	"fixture_types.tmpl":                 {fixture_typesTmpl, map[string]*bintree{}},
	"http_client.tmpl":                   {http_clientTmpl, map[string]*bintree{}},
	"main.tmpl":                          {mainTmpl, map[string]*bintree{}},
	"main_test.tmpl":                     {main_testTmpl, map[string]*bintree{}},
	"middleware_http.tmpl":               {middleware_httpTmpl, map[string]*bintree{}},
	"middleware_tchannel.tmpl":           {middleware_tchannelTmpl, map[string]*bintree{}},
	"module_class_initializer.tmpl":      {module_class_initializerTmpl, map[string]*bintree{}},
	"module_initializer.tmpl":            {module_initializerTmpl, map[string]*bintree{}},
	"module_mock_initializer.tmpl":       {module_mock_initializerTmpl, map[string]*bintree{}},
	"service.tmpl":                       {serviceTmpl, map[string]*bintree{}},
	"service_mock.tmpl":                  {service_mockTmpl, map[string]*bintree{}},
	"structs.tmpl":                       {structsTmpl, map[string]*bintree{}},
	"tchannel_client.tmpl":               {tchannel_clientTmpl, map[string]*bintree{}},
	"tchannel_client_test_server.tmpl":   {tchannel_client_test_serverTmpl, map[string]*bintree{}},
	"tchannel_endpoint.tmpl":             {tchannel_endpointTmpl, map[string]*bintree{}},
	"workflow.tmpl":                      {workflowTmpl, map[string]*bintree{}},
	"workflow_mock.tmpl":                 {workflow_mockTmpl, map[string]*bintree{}},
	"workflow_mock_clients_type.tmpl":    {workflow_mock_clients_typeTmpl, map[string]*bintree{}},
}}

// RestoreAsset restores an asset under the given directory
func RestoreAsset(dir, name string) error {
	data, err := Asset(name)
	if err != nil {
		return err
	}
	info, err := AssetInfo(name)
	if err != nil {
		return err
	}
	err = os.MkdirAll(_filePath(dir, filepath.Dir(name)), os.FileMode(0755))
	if err != nil {
		return err
	}
	err = ioutil.WriteFile(_filePath(dir, name), data, info.Mode())
	if err != nil {
		return err
	}
	err = os.Chtimes(_filePath(dir, name), info.ModTime(), info.ModTime())
	if err != nil {
		return err
	}
	return nil
}

// RestoreAssets restores an asset under the given directory recursively
func RestoreAssets(dir, name string) error {
	children, err := AssetDir(name)
	// File
	if err != nil {
		return RestoreAsset(dir, name)
	}
	// Dir
	for _, child := range children {
		err = RestoreAssets(dir, filepath.Join(name, child))
		if err != nil {
			return err
		}
	}
	return nil
}

func _filePath(dir, name string) string {
	cannonicalName := strings.Replace(name, "\\", "/", -1)
	return filepath.Join(append([]string{dir}, strings.Split(cannonicalName, "/")...)...)
}