error_json.go

package api

import (
	"fmt"
	"strings"
	"reflect"
	"github.com/go-json-experiment/json"
	"github.com/go-json-experiment/json/jsontext"
)

type Semantic_error struct {
	error 	string
	err 	error
}

func (e *Semantic_error) Error() string {
	return e.error
}

func (e *Semantic_error) Unwrap() error {
	return e.err
}

func parse_unmarshal_json_error(err *json.SemanticError, b []byte, input any) error {
	body_fields, serr := get_request_body_fields(b)
	if serr != nil {
		return serr
	}
	
	if err.Err != nil {
		required_fields, serr := required_input_fields(input)
		if serr != nil {
			return serr
		}
		
		unknown_fields := unknown_input_fields(body_fields, required_fields)
		if len(unknown_fields) != 0 {
			return fmt.Errorf("Invalid fields: %s", strings.Join(unknown_fields, ", "))
		}
	} else {
		if terr := invalid_field_type(err, b); terr != nil {
			return terr
		}
	}
	
	return &Semantic_error{fmt.Sprintf("JSON unmarshal error at byte offset %d", err.ByteOffset), err}
	//return fmt.Errorf("JSON unmarshal error at byte offset %d", err.ByteOffset)
}

func parse_unmarshal_json_slice_error(err *json.SemanticError, b []byte, inputs any) (error, []error){
	if err.Err != nil {
		body_slice, serr := get_request_body_slice(b)
		if serr != nil {
			return serr, nil
		}
		
		elem := reflect.ValueOf(inputs).Elem()
		if elem.Kind() != reflect.Slice {
			return fmt.Errorf("Input must be a slice"), nil
		}
		
		input := elem.Index(0)
		required_fields, serr := required_input_fields_elem(input)
		if serr != nil {
			return serr, nil
		}
		
		has_errors	:= false
		errs		:= make([]error, len(body_slice))
		in			:= input.Interface()
		for i, b := range body_slice {
			body_fields, serr := get_request_body_fields(b)
			if serr != nil {
				has_errors = true
				errs[i] = serr
				continue
			}
			
			unknown_fields := unknown_input_fields(body_fields, required_fields)
			if len(unknown_fields) != 0 {
				has_errors = true
				errs[i] = fmt.Errorf("Invalid fields: %s", strings.Join(unknown_fields, ", "))
				continue
			}
			
			if serr := json.Unmarshal(b, &in, json.RejectUnknownMembers(true)); err != nil {
				has_errors = true
				errs[i] = serr
				continue
			}
		}
		
		if has_errors {
			return nil, errs
		}
	} else {
		if terr := invalid_field_type(err, b); terr != nil {
			return terr, nil
		}
	}
	
	return &Semantic_error{fmt.Sprintf("JSON unmarshal error at byte offset %d", err.ByteOffset), err}, nil
	//return fmt.Errorf("JSON unmarshal error at byte offset %d", err.ByteOffset), nil
}

func invalid_field_type(err *json.SemanticError, b []byte) *Semantic_error {
	//	Invalid type
	switch err.JSONKind {
	case 'n':
		return invalid_field_type_error(err, b, "null")
	case 'f', 't':
		return invalid_field_type_error(err, b, "bool")
	case '"':
		return invalid_field_type_error(err, b, "string")
	case '0':
		return invalid_field_type_error(err, b, "number")
	case '{', '}':
		return invalid_field_type_error(err, b, "object")
	case '[', ']':
		return invalid_field_type_error(err, b, "array")
	default:
		return nil
	}
}

func invalid_field_type_error(err *json.SemanticError, b []byte, kind string) *Semantic_error {
	b = b[err.ByteOffset:]
	n := 100
	if n < len(b) {
		b = append(b[:n], []byte{'.','.','.'}...)
	}
	return &Semantic_error{
		fmt.Sprintf("Invalid JSON type. Expected '%s' but got '%s' (at byte offset %d) after: %s", err.GoType, kind, err.ByteOffset, string(b)),
		err,
	}
	//return fmt.Errorf("Invalid JSON type. Expected '%s' but got '%s' (at byte offset %d) after: %s", err.GoType, kind, err.ByteOffset, string(b))
}

func required_input_fields(input any) (map[string]reflect.Type, *Semantic_error){
	return required_input_fields_elem(reflect.ValueOf(input).Elem())
}

func required_input_fields_elem(elem reflect.Value) (map[string]reflect.Type, *Semantic_error){
	list := map[string]reflect.Type{}
	if elem.Kind() != reflect.Struct {
		return nil, &Semantic_error{"Input must be a struct", nil}
		//return list, fmt.Errorf("Input must be a struct")
	}
	struct_val := elem.Type()
	for i := 0; i < struct_val.NumField(); i++ {
		field := struct_val.Field(i)
		list[strings.ToLower(field.Name)] = field.Type
	}
	return list, nil
}

func unknown_input_fields[K comparable, VT any, VR any](target map[K]VT, required map[K]VR) []K {
	list := []K{}
	for k := range target {
		if _, ok := required[k]; !ok {
			list = append(list, k)
		}
	}
	return list
}

func get_request_body_fields(b []byte) (map[string]any, *Semantic_error){
	var body any
	if err := json.Unmarshal(b, &body); err != nil {
		return nil, &Semantic_error{"Request body must be key-value pairs", err}
		//return nil, fmt.Errorf("Request body must be key-value pairs")
	}
	fields, ok := body.(map[string]any)
	if !ok {
		return nil, &Semantic_error{"Request body must be key-value pairs", nil}
		//return nil, fmt.Errorf("Request body must be key-value pairs")
	}
	return fields, nil
}

func get_request_body_slice(b []byte) (body []jsontext.Value, serr *Semantic_error){
	if err := json.Unmarshal(b, &body); err != nil {
		serr = &Semantic_error{"Request body must be an array", err}
		//err = fmt.Errorf("Request body must be an array")
	}
	return
}