@using System.Collections.Generic
@using System.Linq;
@using System.Text;
@using System;
@using AutoRest.Core.Model
@using AutoRest.Core.Utilities
@using AutoRest.Go
@using AutoRest.Go.Model

@inherits AutoRest.Core.Template<AutoRest.Go.Model.MethodGo>

@{
    List<string> pd = Model.PrepareDecorators;
    List<string> rd = Model.RespondDecorators;
    rd.Insert(0, "resp");
}

@WrapComment("// ", Model.Name + " " + Model.Description.ToSentence())
@if (Model.LocalParameters.Count() > 0)
{
<text>
//
@WrapComment("// ", Model.ParametersDocumentation)
</text>
}

func (client @(Model.Owner)) @(Model.MethodSignature) (@Model.MethodReturnSignature(false)) {
@if (Model.ReturnViaChannel)
{
<text>
    resultChan := make(chan @(Model.MethodReturnType), 1)
    errChan:= make(chan error, 1)
</text>
}
@if ((Model.CodeModel as CodeModelGo).ShouldValidate && !Model.ParameterValidations.IsNullOrEmpty())
{
<text>
    if err := validation.Validate([]validation.Validation{
    @(Model.ParameterValidations)}); err != nil {
    @if (Model.ReturnViaChannel)
    {
    <text>
    errChan @("<-") @(Model.ValidationError)
    close(errChan)
    close(resultChan)
    return resultChan, errChan
    </text>
    }
    else
    {
    @:return result, @(Model.ValidationError)
    }
}
@EmptyLine
</text>
}
@if (Model.ReturnViaChannel)
{
<text>
    go func() {
        var err error
        var result @(Model.MethodReturnType)

        defer func() {
            if err != nil {
                errChan @("<-") err
            }
            resultChan @("<-") result
            close(resultChan)
            close(errChan)
        }()
</text>
}
    req, err := client.@(Model.PreparerMethodName)(@(Model.HelperInvocationParameters(false)))
    if err != nil {
        err = @(Model.AutorestError("Failure preparing request"))
        return
    }
@EmptyLine
    resp, err := client.@(Model.SenderMethodName)(req)
    if err != nil {
        @(Model.Response)
        err = @(Model.AutorestError("Failure sending request", "resp"))
        return
    }
@EmptyLine
    result, err = client.@(Model.ResponderMethodName)(resp)
    if err != nil {
        err = @(Model.AutorestError("Failure responding to request", "resp"))
    }
@if (Model.ReturnViaChannel)
{
<text>
    }()
    return resultChan, errChan
</text>
}
else
{
    @EmptyLine
    @:return
}
}

@EmptyLine
// @(Model.PreparerMethodName) prepares the @(Model.Name) request.
func (client @(Model.Owner)) @(Model.PreparerMethodName)(@(Model.MethodParametersSignature)) (*http.Request, error) {
@if (Model.IsCustomBaseUri && Model.URLParameters.Any())
{
<text>
    @(Model.URLMap)
    @EmptyLine
</text>
}
@if (Model.PathParameters.Any())
{
<text>
    @(Model.PathMap)
    @EmptyLine
</text>
}
@if (Model.QueryParameters.Any())
{
    @if (Model.QueryParameters.Any(p => p.GetParameterName().IsApiVersion())
        && !Model.LocalParameters.Any(p => p.GetParameterName().IsApiVersion())) 
    {
        @:@(string.Format("const APIVersion = \"{0}\"", Model.APIVersion))
    }
    @:@(Model.QueryMap)
    foreach (var p in Model.OptionalQueryParameters)
    {
    @:if @(p.ModelType.GetEmptyCheck(p.GetParameterName(),false)) {
        @:@(p.AddToMap("queryParameters"))
    @:}
    }
    @:@EmptyLine
}

@if (Model.FormDataParameters.Any())
{
<text>
    @(Model.FormDataMap)
    @EmptyLine
</text>
}

    preparer := autorest.CreatePreparer(
                        @(pd.EmitAsArguments()))

@if (Model.BodyParameter != null && !Model.BodyParameter.IsRequired)
{
<text>
    if @(Model.BodyParameter.ModelType.GetEmptyCheck(Model.BodyParameter.Name, false)) {
        preparer = autorest.DecoratePreparer(preparer,
                            @(string.Format("autorest.WithJSON({0})", Model.BodyParameter.Name)))
    }
</text>
}

@foreach (var p in Model.OptionalHeaderParameters)
{
<text>
    if @(p.ModelType.GetEmptyCheck(p.GetParameterName(), false)) {
        preparer = autorest.DecoratePreparer(preparer,
                            @(string.Format("autorest.WithHeader(\"{0}\",autorest.String({1}))",
                            p.SerializedName, p.GetParameterName())))
    }
</text>
}

    @(Model.IsLongRunningOperation()
        ? "return preparer.Prepare(&http.Request{Cancel: cancel})"
        : "return preparer.Prepare(&http.Request{})")
}


@EmptyLine
// @(Model.SenderMethodName) sends the @(Model.Name) request. The method will close the
// http.Response Body if it receives an error.
func (client @(Model.Owner)) @(Model.SenderMethodName)(req *http.Request) (*http.Response, error) {
@if (Model.IsLongRunningOperation())
{
    @:return autorest.SendWithSender(client, req, azure.DoPollForAsynchronous(client.PollingDelay))
}
else
{
    @:return autorest.SendWithSender(client, req)
}
}

@EmptyLine
// @(Model.ResponderMethodName) handles the response to the @(Model.Name) request. The method always
// closes the http.Response Body.
func (client @(Model.Owner)) @(Model.ResponderMethodName)(resp *http.Response) (@(Model.MethodReturnSignature(true))) { 
    @if (Model.ReturnValue().Body.IsStreamType())
    {
    @:result.Value = &resp.Body
    }
    err = autorest.Respond(
            @(rd.EmitAsArguments()))

    @(Model.Response)
    return
}

@if (Model.IsPageable && !Model.NextAlreadyDefined)
{
<text>
@EmptyLine
// @(Model.NextMethodName) retrieves the next set of results, if any.
func (client @(Model.Owner)) @(Model.NextMethodName)(lastResults @(Model.ReturnValue().Body.Name)) (@Model.MethodReturnSignature(true)) {
    req, err := lastResults.@((Model.ReturnValue().Body as CompositeTypeGo).PreparerMethodName)()
    if err != nil {
        return result, @(Model.AutorestError("Failure preparing next results request"))
    }
    if req == nil {
        return
    }

    @EmptyLine
    resp, err := client.@(Model.SenderMethodName)(req)
    if err != nil {
        @(Model.Response)
        return result, @(Model.AutorestError("Failure sending next results request", "resp"))
    }

    @EmptyLine
    result, err = client.@(Model.ResponderMethodName)(resp)
    if err != nil {
        err = @(Model.AutorestError("Failure responding to next results request", "resp"))
    }

    @EmptyLine
    return
}
</text>
}

@if (Model.IsPageable && !Model.IsNextMethod && Model.ListElement != null)
{
<text>
@EmptyLine
// @(Model.ListCompleteMethodName) gets all elements from the list without paging.
func (client @(Model.Owner)) @(Model.ListCompleteMethodName) @(Model.MethodParametersSignatureComplete) @(Model.MethodReturnSignatureComplete) {
    resultChan := make(chan @((Model.ListElement.ModelType as SequenceTypeGo).GetElement))
    errChan := make(chan error, 1)
    go func() {
        defer func() {
			close(resultChan)
			close(errChan)
		}()
        list, err := client.@(Model.Name)(@(Model.HelperInvocationParameters(false)))
        if err != nil {
            errChan @("<-") err
            return
        }
        if list.@(Model.ListElement.Name) != nil {
            for _, item := range *list.@(Model.ListElement.Name) {
                select {
                case @("<-") cancel:
                    return
                case resultChan @("<-") item:
                    // Intentionally left blank
                }
            }
        }
        for list.@(Model.NextLink) != nil {
    @if (Model.NextAlreadyDefined)
    {
          @:list, err = client.@(Model.NextOperationName)(@(Model.NextMethod.HelperInvocationParameters(true)))
    }
    else
    {
          @:list, err = client.@(Model.NextMethodName)(list)
    }
            if err != nil {
                errChan @("<-") err
                return
            }            
            if list.@(Model.ListElement.Name) != nil {
                for _, item := range *list.@(Model.ListElement.Name) {
                    select {
                        case @("<-") cancel:
                            return
                        case resultChan @("<-") item:
                            // Intentionally left blank
                    }
                }
            }
        }
    }()
    return resultChan, errChan
}
</text>
}