wip: log

log/log.go

@@ -1,10 +1,12 @@
 package log
 
 import (
+	"errors"
 	"fmt"
 	"github.com/rs/zerolog"
 	"io"
 	"os"
+	"reflect"
 )
 
 type Level zerolog.Level
@@ -43,14 +45,18 @@ const (
 )
 
 var (
-	globalLevel      Level = Error
-	logger           zerolog.Logger
-	onLogWriterError zerolog.Logger
-	writer           *Writer
-	DefaultOutlet    io.Writer
+	globalLevel       Level = Error
+	logger            zerolog.Logger
+	onLogWriterError  zerolog.Logger
+	writer            *Writer
+	DefaultOutlet     io.Writer
+	errType           reflect.Type
+	invalidTypeError  error = errors.New("invalid type")
+	noValidFieldError error = errors.New("no valid field")
 )
 
 func init() {
+	errType = reflect.TypeOf((*error)(nil)).Elem()
 	DefaultOutlet = os.Stderr
 	writer = NewWriter()
 	logger = zerolog.New(writer)
@@ -79,6 +85,8 @@ func (p *Payload) Fields(a ...any) *Payload {
 	var (
 		event *zerolog.Event
 		key   string
+		val   reflect.Value
+		typ   reflect.Type
 	)
 
 	event = (*zerolog.Event)(p)
@@ -86,15 +94,31 @@ func (p *Payload) Fields(a ...any) *Payload {
 		if i%2 == 0 {
 			key = part.(string)
 		} else {
-			switch v := part.(type) {
-			case string:
-				event = event.Str(key, v)
-			case error:
-				event = event.Err(v)
+			val = reflect.ValueOf(part)
+			typ = val.Type()
+			switch typ.Kind() {
+			case reflect.String:
+				event = event.Str(key, val.String())
+			case reflect.Slice:
+			case reflect.Pointer:
 
 			default:
-				event = event.Str(key, fmt.Sprintf("[no data type handle] %v", v))
+				if typ.Implements(errType) {
+
+				} else {
+					event = payload(event).unhandledField(key, part)
+				}
 			}
+
+			//switch v := part.(type) {
+			//case string:
+			//	event = event.Str(key, v)
+			//case error:
+			//	event = event.Err(v)
+			//
+			//default:
+			//	event = event.Str(key, fmt.Sprintf("[no data type handle] %v", v))
+			//}
 		}
 	}
 	return (*Payload)(event)
@@ -114,6 +138,91 @@ func (p *Payload) Send(ws ...io.Writer) {
 	event.Send()
 }
 
+func (p *Payload) unhandledField(key string, v any) *zerolog.Event {
+	var (
+		event *zerolog.Event
+	)
+
+	event = (*zerolog.Event)(p)
+	return event.Str(key, fmt.Sprintf("[unhandled data type / invalid] %+v", v))
+}
+
+func (p *Payload) slice(val reflect.Value) (*zerolog.Array, error) {
+	var (
+		vlen   int
+		outlen int
+		i      int
+		rval   *zerolog.Array
+		event  *zerolog.Event
+		err    error
+	)
+
+	vlen = val.Len()
+	rval = zerolog.Arr()
+	for i = 0; i < vlen; i++ {
+		switch val.Index(i).Kind() {
+		//TODO: handle more cases
+		case reflect.String:
+			outlen++
+			rval.Str(val.String())
+		case reflect.Struct:
+			event, err = p.structType(val)
+			if err == nil {
+				rval.Dict(event)
+				outlen++
+			}
+		default:
+			rval.Str(fmt.Sprintf("[unhandled data type / invalid] %+v", val.Interface()))
+		}
+	}
+	return nil, nil //TODO: placeholder, FIX ME!
+}
+
+func (p *Payload) pointer(val reflect.Value) (*Payload, error) {
+	val = val.Elem()
+	if val.Kind() != reflect.Struct {
+		return nil, invalidTypeError
+	}
+
+	event, err := p.structType(val)
+	if err != nil {
+		return nil, err
+	}
+
+	return payload(event), nil
+}
+
+func (p *Payload) structType(val reflect.Value) (*zerolog.Event, error) {
+	var (
+		typ   reflect.Type
+		event *zerolog.Event
+	)
+
+	typ = val.Type()
+	for _, sf := range reflect.VisibleFields(typ) {
+		if sf.Type.Kind() == reflect.String {
+			if event == nil {
+				event = zerolog.Dict()
+			}
+			event.Str(sf.Name, val.FieldByIndex(sf.Index).String())
+		}
+	}
+
+	if event == nil {
+		return nil, noValidFieldError
+	}
+
+	return event, nil
+}
+
+func (p *Payload) event() *zerolog.Event {
+	return (*zerolog.Event)(p)
+}
+
+func payload(event *zerolog.Event) *Payload {
+	return (*Payload)(event)
+}
+
 func Print(a ...any) {
 	globalLevel.Print(a...)
 }