package jsoninfo

import (
	"encoding/json"
	"fmt"
	"reflect"
)

// UnmarshalStrictStruct function:
//   * Unmarshals struct fields, ignoring UnmarshalJSON(...) and fields without 'json' tag.
//   * Correctly handles StrictStruct
func UnmarshalStrictStruct(data []byte, value StrictStruct) error {
	decoder, err := NewObjectDecoder(data)
	if err != nil {
		return err
	}
	return value.DecodeWith(decoder, value)
}

type ObjectDecoder struct {
	Data            []byte
	remainingFields map[string]json.RawMessage
}

func NewObjectDecoder(data []byte) (*ObjectDecoder, error) {
	var remainingFields map[string]json.RawMessage
	if err := json.Unmarshal(data, &remainingFields); err != nil {
		return nil, fmt.Errorf("Failed to unmarshal extension properties: %v\nInput: %s", err, data)
	}
	return &ObjectDecoder{
		Data:            data,
		remainingFields: remainingFields,
	}, nil
}

// DecodeExtensionMap returns all properties that were not decoded previously.
func (decoder *ObjectDecoder) DecodeExtensionMap() map[string]json.RawMessage {
	return decoder.remainingFields
}

func (decoder *ObjectDecoder) DecodeStructFieldsAndExtensions(value interface{}) error {
	reflection := reflect.ValueOf(value)
	if reflection.Kind() != reflect.Ptr {
		panic(fmt.Errorf("Value %T is not a pointer", value))
	}
	if reflection.IsNil() {
		panic(fmt.Errorf("Value %T is nil", value))
	}
	reflection = reflection.Elem()
	for (reflection.Kind() == reflect.Interface || reflection.Kind() == reflect.Ptr) && !reflection.IsNil() {
		reflection = reflection.Elem()
	}
	reflectionType := reflection.Type()
	if reflectionType.Kind() != reflect.Struct {
		panic(fmt.Errorf("Value %T is not a struct", value))
	}
	typeInfo := GetTypeInfo(reflectionType)

	// Supported fields
	fields := typeInfo.Fields
	remainingFields := decoder.remainingFields
	for fieldIndex, field := range fields {
		// Fields without JSON tag are ignored
		if !field.HasJSONTag {
			continue
		}

		// Get data
		fieldData, exists := remainingFields[field.JSONName]
		if !exists {
			continue
		}

		// Unmarshal
		if field.TypeIsUnmarshaller {
			fieldType := field.Type
			isPtr := false
			if fieldType.Kind() == reflect.Ptr {
				fieldType = fieldType.Elem()
				isPtr = true
			}
			fieldValue := reflect.New(fieldType)
			if err := fieldValue.Interface().(json.Unmarshaler).UnmarshalJSON(fieldData); err != nil {
				if field.MultipleFields {
					i := fieldIndex + 1
					if i < len(fields) && fields[i].JSONName == field.JSONName {
						continue
					}
				}
				return fmt.Errorf("Error while unmarshalling property '%s' (%s): %v",
					field.JSONName, fieldValue.Type().String(), err)
			}
			if !isPtr {
				fieldValue = fieldValue.Elem()
			}
			reflection.FieldByIndex(field.Index).Set(fieldValue)

			// Remove the field from remaining fields
			delete(remainingFields, field.JSONName)
		} else {
			fieldPtr := reflection.FieldByIndex(field.Index)
			if fieldPtr.Kind() != reflect.Ptr || fieldPtr.IsNil() {
				fieldPtr = fieldPtr.Addr()
			}
			if err := json.Unmarshal(fieldData, fieldPtr.Interface()); err != nil {
				if field.MultipleFields {
					i := fieldIndex + 1
					if i < len(fields) && fields[i].JSONName == field.JSONName {
						continue
					}
				}
				return fmt.Errorf("Error while unmarshalling property '%s' (%s): %v",
					field.JSONName, fieldPtr.Type().String(), err)
			}

			// Remove the field from remaining fields
			delete(remainingFields, field.JSONName)
		}
	}
	return nil
}