@using AutoRest.Go
@using AutoRest.Core.Model
@using AutoRest.Go.Model
@using AutoRest.Go.Templates
@using AutoRest.Core.Utilities

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

@WrapComment("// ", string.Format("{0} is {1}", Model.Name, Model.Documentation.ToSentence()))
@if (Model.IsPolymorphic)
{
<text>
type @(Model.Name) interface {
    @foreach (var dt in Model.DerivedTypes)
    {
    @:As@(dt.Name) () (*@(dt.Name), bool)
    }
}

@EmptyLine
func unmarshal@(Model.Name)(body []byte) (@(Model.Name), error){
    var m map[string]interface{}
	err := json.Unmarshal(body, &m)
	if err != nil {
	    return nil, err
	}
    @EmptyLine
    switch m["@(Model.PolymorphicDiscriminator)"] {
    @foreach (var dt in Model.DerivedTypes)
    {
    <text>
    case string(@((dt as CompositeTypeGo).DiscriminatorEnumValue)):
        var @(dt.Name.FixedValue.ToShortName()) @(dt.Name)
        err := json.Unmarshal(body, &@(dt.Name.FixedValue.ToShortName()))
        return @(dt.Name.FixedValue.ToShortName()), err
    </text>
    }
    default:
        return nil, errors.New("Unsupported type")
    }
}

func unmarshal@(Model.Name)Array(body []byte) ([]@(Model.Name), error){
    var rawMessages []*json.RawMessage
	err := json.Unmarshal(body, &rawMessages)
	if err != nil {
        return nil, err
	}
    @EmptyLine
    @(Model.Name.FixedValue.ToShortName())Array := make([]@(Model.Name), len(rawMessages))
    @EmptyLine
    for index, rawMessage := range rawMessages {
        @(Model.Name.FixedValue.ToShortName()), err := unmarshal@(Model.Name)(*rawMessage)
	    if err != nil {
		    return nil, err
	    }
        @(Model.Name.FixedValue.ToShortName())Array[index] = @(Model.Name.FixedValue.ToShortName())
    }
    return @(Model.Name.FixedValue.ToShortName())Array, nil
}
</text>
}
else
{
<text>
type @(Model.Name) struct {
    @(Model.AddHTTPResponse())
    @(Model.Fields())
}
</text>
}

@if (Model.BaseIsPolymorphic && !Model.IsPolymorphic)
{
<text>
@EmptyLine
// MarshalJSON is the custom marshaler for @(Model.Name).
func (@(Model.Name.FixedValue.ToShortName()) @(Model.Name))MarshalJSON() ([]byte, error){
    @(Model.Name.FixedValue.ToShortName()).@(Model.PolymorphicProperty) = @(Model.DiscriminatorEnumValue)
    type Alias @(Model.Name)
    return json.Marshal(&struct {
        Alias
    }{
        Alias: (Alias)(@(Model.Name.FixedValue.ToShortName())),
    })
}

    @foreach (var st in Model.SiblingTypes)
    {
    <text>
@EmptyLine
// As@(st.Name) is the @(Model.BaseModelType.Name) implementation for @(Model.Name).
func (@(Model.Name.FixedValue.ToShortName()) @(Model.Name)) As@(st.Name)() (*@(st.Name), bool) {
        @if (st.Equals(Model))
        {
    @:return &@(Model.Name.FixedValue.ToShortName()), true
        }
        else
        {
    @:return nil, false
        }
}
    </text>
    }
</text>
}

@if (Model.HasPolymorphicFields && !Model.IsPolymorphic)
{
<text>
// UnmarshalJSON is the custom unmarshaler for @(Model.Name) struct.
func (@(Model.Name.FixedValue.ToShortName()) *@(Model.Name)) UnmarshalJSON(body []byte) error {
    @if (Model.IsWrapperType)
    {
    <text>
    @(Model.BaseType.Name.FixedValue.ToShortName()), err := unmarshal@(Model.BaseType.Name)(body)
	if err != nil {
		return err
	}
    @(Model.Name.FixedValue.ToShortName()).Value = @(Model.BaseType.Name.FixedValue.ToShortName())
    </text>
    }
    else
    {
    <text>
	var m map[string]*json.RawMessage
	err := json.Unmarshal(body, &m)
	if err != nil {
		return err
	}
    
    var v *json.RawMessage
        @foreach (var p in Model.AllProperties)
        {
        <text>
    @EmptyLine
    v = m["@(p.SerializedName)"]
    if v != nil {
            @if (p.ModelType is CompositeType && (p.ModelType as CompositeTypeGo).IsPolymorphic)
            {
        @:@(CodeNamerGo.Instance.GetVariableName(p.SerializedName)), err := unmarshal@(p.ModelType.Name)(*m["@(p.SerializedName)"])
            }
            else if (p.ModelType is SequenceType && (p.ModelType as SequenceTypeGo).ElementType is CompositeType && ((p.ModelType as SequenceTypeGo).ElementType as CompositeType).IsPolymorphic)
            {
        @:@(CodeNamerGo.Instance.GetVariableName(p.SerializedName)), err := unmarshal@((p.ModelType as SequenceTypeGo).ElementType.Name)Array(*m["@(p.SerializedName)"])
            }
            else
            {
            <text>
        var @(CodeNamerGo.Instance.GetVariableName(p.SerializedName)) @(p.ModelType.Name)
        err = json.Unmarshal(*m["@(p.SerializedName)"], &@(CodeNamerGo.Instance.GetVariableName(p.SerializedName)))
            </text>
            }
        if err != nil {
            return err
        }
            @if ((p.ModelType is CompositeType && (p.ModelType as CompositeTypeGo).IsPolymorphic) || (p.ModelType is EnumType))
            {
        @:@(Model.Name.FixedValue.ToShortName()).@(p.Name) = @(CodeNamerGo.Instance.GetVariableName(p.SerializedName))
            }
            else
            {
        @:@(Model.Name.FixedValue.ToShortName()).@(p.Name) = &@(CodeNamerGo.Instance.GetVariableName(p.SerializedName))
            }
    }
        </text>
        }
    </text>
    }
    @EmptyLine
    return nil
}
</text>
}

@if (!string.IsNullOrEmpty(Model.NextLink) && Model.PreparerNeeded)
{
<text>
@EmptyLine
// @(Model.PreparerMethodName) prepares a request to retrieve the next set of results. It returns
// nil if no more results exist.
func (client @(Model.Name)) @(Model.PreparerMethodName)() (*http.Request, error) {
    if client.@(Model.NextLink) == nil || len(to.String(client.@(Model.NextLink))) <= 0 {
        return nil, nil
    }
    return autorest.Prepare(&http.Request{},
        autorest.AsJSON(),
        autorest.AsGet(),
        autorest.WithBaseURL(to.String(client.@(Model.NextLink))));
}
</text>
}