package schema

import (
	"errors"
	"reflect"

	"github.com/sashabaranov/go-openai/jsonschema"
)

type object struct {
	basic

	ref reflect.Type

	fields map[string]Type
}

func (o object) SchemaType() jsonschema.DataType {
	return jsonschema.Object
}

func (o object) Definition() jsonschema.Definition {
	def := o.basic.Definition()
	def.Type = jsonschema.Object
	def.Properties = make(map[string]jsonschema.Definition)
	for k, v := range o.fields {
		def.Properties[k] = v.Definition()
	}

	def.AdditionalProperties = false
	return def
}

func (o object) FromAny(val any) (reflect.Value, error) {
	// if the value is nil, we can't do anything
	if val == nil {
		return reflect.Value{}, nil
	}

	// now make a new object of the type we're trying to parse
	obj := reflect.New(o.ref).Elem()

	// now we need to iterate over the fields and set the values
	for k, v := range o.fields {
		// get the field by name
		field := obj.FieldByName(k)
		if !field.IsValid() {
			return reflect.Value{}, errors.New("field " + k + " not found")
		}

		// get the value from the map
		val2, ok := val.(map[string]interface{})[k]
		if !ok {
			return reflect.Value{}, errors.New("field " + k + " not found in map")
		}

		// now we need to convert the value to the correct type
		val3, err := v.FromAny(val2)
		if err != nil {
			return reflect.Value{}, err
		}

		// now we need to set the value on the field
		v.SetValueOnField(field, val3)

	}

	return obj, nil
}

func (o object) SetValueOnField(obj reflect.Value, val reflect.Value) {
	// if this basic type is not required that means it's a pointer type so we need to set the value to the address of the value
	if !o.required {
		val = val.Addr()
	}

	obj.Field(o.index).Set(val)
}