package influxdb

import (
	"context"
	"sync"
	"testing"
	"time"

	client "github.com/influxdata/influxdb1-client/v2"
	"github.com/stretchr/testify/require"
	"src.dualinventive.com/go/dinet/ditime"
	"src.dualinventive.com/go/dinet/rpc"
	"src.dualinventive.com/go/lib/kv"
)

type testWriter struct {
	c chan *client.Point
}

func (t *testWriter) Add(i *client.Point) {
	t.c <- i
}

func (t *testWriter) Dispatch(ctx context.Context, interval time.Duration) {

}

func TestUnsupportedScheme(t *testing.T) {
	ramKV, err := kv.New(kv.TypeRAM, "")
	require.Nil(t, err)

	i, err := New("ftp://127.0.0.1", "root", "root", "db", 5, ramKV, 1, time.Second)
	require.Nil(t, i)
	require.EqualError(t, err, "Unsupported protocol scheme: ftp, your address"+
		" must start with http:// or https://")
}

func TestSendFail(t *testing.T) {
	testCases := []struct {
		name           string
		msg            *rpc.Msg
		expectRPCWrite bool
	}{
		{"request", &rpc.Msg{
			Dinetrpc:    1,
			DeviceUID:   "01234567890123456789012345678901",
			ID:          1,
			Time:        ditime.Now(),
			Type:        rpc.MsgTypeRequest,
			ClassMethod: rpc.ClassMethodSensorData,
		}, false},
		{"error", &rpc.Msg{
			Dinetrpc:    1,
			DeviceUID:   "01234567890123456789012345678901",
			ID:          1,
			Time:        ditime.Now(),
			Type:        rpc.MsgTypeReply,
			ClassMethod: rpc.ClassMethodSensorData,
			Error:       rpc.GetError(rpc.EAgain),
		}, true},
		{"invalid result", &rpc.Msg{
			Dinetrpc:  1,
			DeviceUID: "01234567890123456789012345678901",
			ID:        1,
			Time:      ditime.Now(),
			Type:      rpc.MsgTypeReply,
			Result:    rpc.NewResult(map[int]interface{}{5: "hoi"}),
		}, true},
	}

	for _, tc := range testCases {
		tc := tc
		t.Run(tc.name, func(t *testing.T) {
			ramKV, err := kv.New(kv.TypeRAM, "")
			require.Nil(t, err)

			i, err := New("http://127.0.0.1", "root", "root", "db", 5, ramKV, 1, time.Second)
			require.Nil(t, err)
			require.NotNil(t, i)

			// Convert the writer is mock writer
			tw := &testWriter{c: make(chan *client.Point)}
			i.writer = tw

			ctx, cancel := context.WithCancel(context.Background())
			var wg sync.WaitGroup
			wg.Add(2)
			go func(cancel func()) {
				defer wg.Done()
				err = i.Send(tc.msg)
				_ = err
				cancel()
			}(cancel)

			go func() {
				defer wg.Done()
				if tc.expectRPCWrite {
					<-tw.c
				}
				time.Sleep(time.Second)
				select {
				case <-tw.c:
					require.Fail(t, "expected no points")
				default:
				}
			}()

			i.Process(ctx, time.Second)
			wg.Wait()
		})
	}
}