{% macro decapitalize(text) %}
    {{- concat(slice(text, 0, 1) | lower, slice(text, 1, text | length)) -}}
{% endmacro %}

{% macro capitalize(text) %}
    {{- concat(slice(text, 0, 1) | upper, slice(text, 1, text | length)) -}}
{% endmacro %}

{% macro formatNullableOrOptional(expr, nullable, optional) %}
    {{- expr -}}{%- if nullable or optional -%}?{%- endif -%}
{% endmacro %}

{% macro formatValueType(valueType) %}
    {%- import _self as self -%}

    {%- if valueType.baseTypeName == "Array" -%}
        [{{ self.formatValueType(valueType.itemsType) }}]
    {%- elseif valueType.baseTypeName == "Map" -%}
        [{{ self.formatValueType(valueType.keysType) }}: {{ self.formatValueType(valueType.valuesType) }}]
    {%- elseif valueType.baseTypeName == "DateTime" -%}
        DateInRegion
    {%- elseif valueType.baseTypeName == "Long" -%}
        Int64
    {%- elseif valueType.baseTypeName == "Decimal" -%}
        NSDecimalNumber
    {%- else -%}
        {{ valueType.baseTypeName }}
    {%- endif -%}
{% endmacro %}

{% macro formatEncodingValue(field, strong) %}
    {%- import _self as self -%}

    {%- if field.type.type.baseTypeName == "DateTime" -%}
        {{- self.formatEncodingDate(field) -}}
    {%- elseif field.type.type.baseTypeName == "Decimal" -%}
        {%- if strong -%}
            {{ field.name }}
        {%- else -%}
            {{ self.formatNullableOrOptional(field.name, field.nullable, field.optional) -}}
        {%- endif -%}
        .decimalValue
    {%- else -%}
        {{ field.name }}
    {%- endif -%}
{% endmacro %}

{%- macro formatEncodingDate(field) -%}
    ApiDateFormattingService.string(from: {{ field.name -}}, format: .{{- dateFormatToName(field.type.dateFormat) -}})
{%- endmacro -%}

{% macro escapeIfNeeded(expr) %}
    {%- if expr == "default" or expr == "operator" -%}
        `{{ expr }}`
    {%- else -%}
        {{ expr }}
    {%- endif -%}
{% endmacro %}

{% macro encodeIfPresent(field) %}
    {%- import _self as self -%}

    {% if field.type.type.baseTypeName == "DateTime" %}
        if let {{ field.name }} = {{ field.name }} {
            try container.encode({{- self.formatEncodingDate(field) -}}, forKey: .{{- field.name -}})
        }
    {%- else -%}
        try container.encodeIfPresent({{- self.formatEncodingValue(field, false) -}}, forKey: .{{- field.name -}})
    {%- endif -%}
{% endmacro %}

{% macro encodeToContainer(field) %}
    {%- import _self as self -%}

    {%- if field.optional -%}
        {{ self.encodeIfPresent(field) -}}
    {%- elseif field.nullable -%}
        if let {{ field.name }} = {{ field.name }} {
            try container.encode({{- self.formatEncodingValue(field, true) -}}, forKey: .{{- field.name -}})
        } else {
            try container.encodeNil(forKey: .{{- field.name -}})
        }
    {%- else -%}
        try container.encode({{- self.formatEncodingValue(field, false) -}}, forKey: .{{- field.name -}})
    {%- endif -%}
{% endmacro %}

{% macro decodeFromContainer(field) %}
    {%- import _self as self -%}

    {% if field.type.type.baseTypeName == "DateTime" %}
        {{ self.decodeComplexField(field, "String") }}
    {% elseif field.type.type.baseTypeName == "Decimal" %}
        {{ self.decodeComplexField(field, "Decimal") }}
    {%- else -%}
        self.{{ field.name }} = try container.{{- self.formatOptionalDecode(field) -}}({{ self.formatValueType(field.type.type) }}.self, forKey: .{{ field.name }})
    {%- endif -%}
{% endmacro %}

{% macro decodeComplexField(field, decodingType) %}
    {%- import _self as self -%}

    {%- if field.optional or field.nullable -%}
        if let {{ field.name }} = try container.decodeIfPresent({{- decodingType -}}.self, forKey: .{{- field.name -}}) {
            {{ self.initExpr(field) }}
        } else {
            self.{{ field.name }} = nil
        }
    {%- else -%}
        let {{ field.name }} = try container.decode({{- decodingType -}}.self, forKey: .{{- field.name -}})
        {{ self.initExpr(field) }}
    {%- endif -%}
{% endmacro %}

{% macro formatOptionalDecode(field) %}
    {%- if field.optional or field.nullable -%}
        decodeIfPresent
    {%- else -%}
        decode
    {%- endif -%}
{% endmacro %}

{% macro initExpr(field) %}
    {%- if field.type.type.baseTypeName == "DateTime" -%}
        if let date = ApiDateFormattingService.date(from: {{ field.name }}, format: .{{ dateFormatToName(field.type.dateFormat) }}, parsedIn: nil) {
            self.{{ field.name }} = date
        } else {
            throw LeadKitError.failedToDecode(reason: "init?(string:format:fromRegion:) returned nil")
        }
    {%- elseif field.type.type.baseTypeName == "Decimal" -%}
        self.{{ field.name }} = NSDecimalNumber(decimal: {{ field.name }})
    {%- endif -%}
{% endmacro %}

{% macro enumValueName(value) %}
    {%- import _self as self -%}

    {{- self.decapitalize(value.name) -}}
{%- endmacro %}

{% macro defaultValueForField(field) %}
    {%- set nullable = field.nullable -%}
    {%- set optional = field.optional -%}
    {%- set baseTypeName = field.type.type.baseTypeName -%}

    {%- if nullable or optional -%}
        nil
    {%- elseif baseTypeName == "Array" -%}
        []
    {%- elseif baseTypeName == "Map" -%}
        [:]
    {%- elseif baseTypeName == "String" -%}
        ""
    {%- elseif baseTypeName == "DateTime" -%}
        Date().inDefaultRegion()
    {%- elseif baseTypeName == "Double" -%}
        0.0
    {%- elseif baseTypeName == "Long" or baseTypeName == "Int" -%}
        0
    {%- elseif baseTypeName == "Bool" -%}
        false
    {%- elseif baseTypeName == "Decimal" -%}
        .zero
    {%- elseif (field.type.values is not null) -%}
        {%- import _self as self -%}

        .{{ self.enumValueName(first(field.type.values)) }}
    {%- else -%}
        .new{{ baseTypeName }}
    {%- endif -%}
{%- endmacro %}

{% macro valueTypeHasGenerics(valueType) %}
    {%- if valueType.typeParameters is not empty -%}
        {{ true }}
    {%- elseif (valueType.parent is not null) -%}
        {%- import _self as self -%}

        {{- self.valueTypeHasGenerics(valueType.parent) -}}
    {%- endif -%}
{% endmacro %}

{% macro hasGenericsOrNonEqutableCollections(type) %}
    {%- set valueType = type.type -%}

    {%- import _self as self -%}

    {%- if self.valueTypeHasGenerics(valueType) != null -%}
        {{ true }}
    {%- elseif valueType.baseTypeName == "Array" -%}
        {%- if (valueType.itemsType.typeParameters is not null) -%}
            {{ true }}
        {%- else -%}
            {{- self.hasGenericsOrNonEqutableCollections(valueType.itemsType) -}}
        {%- endif -%}
    {%- elseif valueType.baseTypeName == "Map" -%}
        {{ true }}
    {%- elseif type.allFieldsOrdered is not null -%}
        {%- for field in type.allFieldsOrdered -%}
            {{- self.hasGenericsOrNonEqutableCollections(field.type) -}}
        {%- endfor -%}
    {%- endif -%}
{%- endmacro %}

{% macro fieldIsGeneric(field, typeParameters) %}
    {%- for typeParameter in typeParameters -%}
        {%- if typeParameter.baseTypeName == field.type.type.baseTypeName -%}
            {{ true }}
        {%- endif -%}
    {%- endfor -%}
{% endmacro %}