// package main ...
package wshandler

import (
	"bytes"
	"encoding/json"
	"errors"
	"fmt"
	"reflect"
	"testing"

	"repositories.action2quare.com/ayo/gocommon/session"
)

type TestReceiver struct {
}

func (tr *TestReceiver) Func1([]any) {

}

func (tr *TestReceiver) Func2(args []any) {
	fmt.Println(args...)
}

func TestUnmarshalToken(t *testing.T) {
	// 		 		 0         1         2         3         4         5         6         7         8         9         0         1         2         3         4         5         6         7
	//    		     012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890
	insrc := []byte(`["string value 1",200,["inner string value 1","inner string value 2"],{"inner map key 1":"inner map string value 1","inner map key 2":"inner map string value 2"},500.1]`)

	dec := json.NewDecoder(bytes.NewBuffer(insrc))
	dec.Token()

	for {
		token_start := dec.InputOffset()
		tok, _ := dec.Token()
		token_end := dec.InputOffset()

		var string_val_1 string
		stringtype := reflect.TypeOf(string_val_1)
		stringvalue := reflect.New(stringtype)
		castptr := stringvalue.Interface()

		err := json.Unmarshal(insrc[token_start:token_end], castptr)
		fmt.Println(err)

		if tok == nil {
			break
		}
		fmt.Println(tok, dec.InputOffset())
	}
	// src := []any{"a", 1, false}
	// payload, _ := json.Marshal(src)

	// tr := new(TestReceiver)
	// receiver := MakeWebsocketApiHandler(tr, "test")

	// var con WebsocketApiBroker
	// con.AddHandler(receiver)

}

type peerHandler struct {
	id string
}

func (ph *peerHandler) ApiFunc1(arg1 string, arg2 int) error {
	fmt.Println("ApiFunc1", ph.id, arg1, arg2)
	return errors.New("fake")
}

func (ph *peerHandler) ApiFunc2(arg1 string, arg2 map[string]int) (string, error) {
	fmt.Println("ApiFunc2", ph.id, arg1, arg2)
	return "success", nil
}

func (ph *peerHandler) ApiFunc3(arg1 float64, arg2 []int) {
	fmt.Println("ApiFunc3", ph.id, arg1, arg2)
}

type dummySessionConsumer struct {
}

func (dsc *dummySessionConsumer) Query(string) (session.Authorization, error) {
	return session.Authorization{}, nil
}
func (dsc *dummySessionConsumer) Touch(string) (session.Authorization, error) {
	return session.Authorization{}, nil
}

func TestPeerApiBroker(t *testing.T) {
	handler := MakeWebsocketPeerApiHandler[peerHandler]("test")
	ws := NewWebsocketPeerHandler(&dummySessionConsumer{})
	ws.AddHandler(handler)

	peer := &peerHandler{
		id: "onlyone",
	}
	func1args, _ := json.Marshal([]any{string("arg1"), int(100)})
	ws.Call(peer, "test.ApiFunc1", bytes.NewBuffer(func1args))

	func1args, _ = json.Marshal([]any{string("arg1"), map[string]int{"arg2.key": 99}})
	ws.Call(peer, "test.ApiFunc2", bytes.NewBuffer(func1args))

	func1args, _ = json.Marshal([]any{float64(111.1), []int{99, 98}})
	ws.Call(peer, "test.ApiFunc3", bytes.NewBuffer(func1args))
}