{{/*
Copyright 2019-present Facebook Inc. All rights reserved.
This source code is licensed under the Apache 2.0 license found
in the LICENSE file in the root directory of this source tree.
*/}}

{{/* gotype: entgo.io/ent/entc/gen.typeScope */}}

{{ define "dialect/sql/decode/one" }}
{{ $receiver := $.Receiver }}

{{ $idnulltype := $.ID.NullType }}{{ if not $.ID.UserDefined }}{{ $idnulltype = "sql.NullInt64" }}{{ end }}
{{ $ctypes := dict $idnulltype (list $.ID.Constant) }}
{{ range $f := $.Fields }}
	{{ $names := list }}
	{{ if hasKey $ctypes $f.NullType }}
		{{ $names = get $ctypes $f.NullType }}
	{{ end }}
	{{ $names = append $names $f.Constant }}
	{{ $ctypes = set $ctypes $f.NullType $names }}
{{ end }}

// scanValues returns the types for scanning values from sql.Rows.
func (*{{ $.Name }}) scanValues(columns []string) ([]interface{}, error) {
	values := make([]interface{}, len(columns))
	for i := range columns {
		switch columns[i] {
			{{- range $type, $columns := $ctypes }}
				case {{ range $i, $c := $columns }}{{ if ne $i 0 }},{{ end }}{{ $.Package }}.{{ $c }}{{ end }}:
					values[i] = new({{ $type }})
			{{- end }}
			{{- range $i, $fk := $.UnexportedForeignKeys }}
				{{- $f := $fk.Field }}
				case {{ $.Package }}.ForeignKeys[{{ $i }}]: // {{ $f.Name }}
					values[i] = new({{ if not $f.UserDefined }}sql.NullInt64{{ else }}{{ $f.NullType }}{{ end }})
			{{- end }}
			default:
				return nil, fmt.Errorf("unexpected column %q for type {{ $.Name }}", columns[i])
		}
	}
	return values, nil
}

// assignValues assigns the values that were returned from sql.Rows (after scanning)
// to the {{ $.Name }} fields.
func ({{ $receiver }} *{{ $.Name }}) assignValues(columns []string, values []interface{}) error {
	if m, n := len(values), len(columns); m < n {
		return fmt.Errorf("mismatch number of scan values: %d != %d", m, n)
	}
	{{- $idx := "i" }}{{ if eq $idx $receiver }}{{ $idx = "j" }}{{ end }}
	for {{ $idx }} := range columns {
		switch columns[{{ $idx }}] {
		case {{ $.Package }}.{{ $.ID.Constant }}:
			{{- if and $.ID.UserDefined (or $.ID.IsString $.ID.IsUUID) }}
				{{- with extend $ "Idx" $idx "Field" $.ID "Rec" $receiver }}
					{{ template "dialect/sql/decode/field" . }}
				{{- end }}
			{{- else }}
				value, ok := values[{{ $idx }}].(*sql.NullInt64)
				if !ok {
					return fmt.Errorf("unexpected type %T for field id", value)
				}
				{{ $receiver }}.ID = {{ $.ID.Type }}(value.Int64)
			{{- end }}
		{{- range  $f := $.Fields }}
			case {{ $.Package }}.{{ $f.Constant }}:
				{{- with extend $ "Idx" $idx "Field" $f "Rec" $receiver }}
					{{ template "dialect/sql/decode/field" . }}
				{{- end }}
		{{- end }}
		{{- range $i, $fk := $.UnexportedForeignKeys }}
			{{- $f := $fk.Field }}
			case {{ if $fk.UserDefined }}{{ $.Package }}.{{ $.ID.Constant }}{{ else }}{{ $.Package }}.ForeignKeys[{{ $i }}]{{ end }}:
				{{- if or $fk.UserDefined (and $f.UserDefined (or $f.IsString $f.IsUUID)) }}
					{{- with extend $ "Idx" $idx "Field" $f "Rec" $receiver "StructField" $fk.StructField }}
						{{ template "dialect/sql/decode/field" . }}
					{{- end }}
				{{- else }}
					if value, ok := values[{{ $idx }}].(*sql.NullInt64); !ok {
						return fmt.Errorf("unexpected type %T for edge-field {{ $f.Name}}", value)
					} else if value.Valid {
						{{ $receiver }}.{{ $fk.StructField }} = new({{ $f.Type }})
						{{ if and $f.Nillable (not $f.Type.Nillable) }}*{{ end }}{{ $receiver }}.{{ $fk.StructField }} = {{ $f.Type }}(value.Int64)
					}
				{{- end }}
		{{- end }}
		}
	}
	return nil
}
{{ end }}

{{ define "dialect/sql/decode/field" }}
	{{- $i := $.Scope.Idx -}}
	{{- $f := $.Scope.Field -}}
	{{- $ret := $.Scope.Rec -}}
	{{- $field := $f.StructField }}{{ with $.Scope.StructField }}{{ $field = . }}{{ end }}
	{{- if $f.IsJSON }}
		if value, ok := values[{{ $i }}].(*{{ $f.NullType }}); !ok {
			return fmt.Errorf("unexpected type %T for field {{ $f.Name }}", values[{{ $i }}])
		} else if value != nil && len(*value) > 0 {
			if err := json.Unmarshal(*value, &{{ $ret }}.{{ $field }}); err != nil {
				return fmt.Errorf("unmarshal field {{ $f.Name }}: %w", err)
			}
		}
	{{- else }}
		{{- $nulltype := $f.NullType -}}
		if value, ok := values[{{ $i }}].(*{{ $nulltype }}); !ok {
			return fmt.Errorf("unexpected type %T for field {{ $f.Name }}", values[{{ $i }}])
		{{- if and (not $f.Type.ValueScanner) (hasPrefix $nulltype "sql") }}
			} else if value.Valid {
				{{- if $f.NillableValue }}
					{{ $ret }}.{{ $field }} = new({{ $f.Type }})
					*{{ $ret }}.{{ $field }} = {{ $f.NullTypeField "value" }}
				{{- else }}
					{{ $ret }}.{{ $field }} = {{ $f.NullTypeField "value" }}
				{{- end }}
		{{- else }}
			} else if value != nil {
				{{ $ret }}.{{ $field }} = {{ if and (not $f.Nillable) (not $f.Type.RType.IsPtr) }}*{{ end }}value
		{{- end }}
		}
	{{- end }}
{{- end }}

{{ define "dialect/sql/decode/many" }}
{{ end }}