package basic

import (
	"encoding/json"
	"fmt"
	"testing"
	"time"

	. "git.wecise.com/wecise/odbserver/odb"
	"git.wecise.com/wecise/odbserver/odb/test"
	"gitee.com/wecisecode/util/logger"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

type CollectTests struct {
	Test *testing.T
	g    *Gutil
}

func AuthGroupUpdateTest(t *testing.T) {
	g := test.TestG()

	t.Run("InitG", func(t *testing.T) {
		test := &CollectTests{Test: t, g: g}
		test.InitG()
	})
	t.Run("AuthGroupUpdate", func(t *testing.T) {
		test := &CollectTests{Test: t, g: g}
		test.AuthGroupUpdate()
	})
}

func CollectTest(t *testing.T) {

	g := test.TestG()

	t.Run("InitG", func(t *testing.T) {
		test := &CollectTests{Test: t, g: g}
		test.InitG()
	})

	t.Run("Class", func(t *testing.T) {
		test := &CollectTests{Test: t, g: g}
		test.Class()
	})

	t.Run("Data", func(t *testing.T) {
		test := &CollectTests{Test: t, g: g}
		test.Data()
	})

	time.Sleep(time.Duration(1) * time.Second)

	t.Run("Valid", func(t *testing.T) {
		test := &CollectTests{Test: t, g: g}
		test.Valid()
	})

	time.Sleep(time.Duration(1) * time.Second)

	t.Run("Search", func(t *testing.T) {
		test := &CollectTests{Test: t, g: g}
		test.Search()
	})

	t.Run("Aggr", func(t *testing.T) {
		test := &CollectTests{Test: t, g: g}
		test.Aggr()
	})

	t.Run("AuthGroup", func(t *testing.T) {
		test := &CollectTests{Test: t, g: g}
		test.AuthGroup()
	})

}

func (t *CollectTests) InitG() {
	require.NotNil(t.Test, t.g)
}

func (t *CollectTests) Class() {

	_, _, err := t.g.Query(`
		typedef  if not exists STRSTR = varchar ;
		typedef  if not exists VENUM	=  enum {
								"0":["command", 	"命令"],
								"1":["shell",		"shell脚本"],
								"2":["lua",			"lua脚本"],
								"3":["task",		"任务"],
								"4":["js",			"js脚本"]
							} ;
		typedef  if not exists	FLIST  =  float[0..?]	;
		typedef  if not exists	FFLIST  =  FLIST ;
		typedef  if not exists	FFFLIST = 	FFLIST ;
	
		create class if not exists /test();
		create class if not exists /test/collect (
		
		v_varchar		varchar,
		v_map			map<STRSTR, STRSTR>,
		v_list			list<STRSTR>,
		d_list			double[2..3],
		f_list			FFFLIST,
		i_list			list<int>,
		v_set			set<STRSTR>,
		v_type			VENUM,
		indexes(v_varchar, v_map, v_list, v_set, v_type, d_list, f_list, i_list),
		keys(v_varchar)
	);`)

	if err != nil {
		logger.Errorf("%v", err)
	}

	require.Nil(t.Test, err, fmt.Sprint(err))
}

func (t *CollectTests) Data() {
	var err error
	_, _, err = t.g.Query(`insert into /test/collect (v_varchar, v_map, v_list, d_list, f_list, i_list, v_set, v_type ) values ('1', {"map1": "val1", "map2":"2"}, ["list1", "list2"], [2.5, 2.5], [3.6, 3.6], [1, 2], ["set1", "set2"], "4"  )`)

	_, _, err = t.g.Query(`insert into /test/collect (v_varchar, v_map, v_list, v_set, v_type ) values ('2', {"map1": "val2", "map2":"2"}, ["list1", "list2"], ["set1", "set3"], "shell脚本"  )`)

	_, _, err = t.g.Query(`insert into /test/collect (v_varchar, v_map, v_list, v_set, v_type ) values ('3', {"map1": "val3", "map2":"2"}, ["list1", "list3"], ["set1", "set2"], "2"   )`)

	_, _, err = t.g.Query(`insert into /test/collect (v_varchar, v_map, v_list, v_set, v_type ) values ('4', {"map1": "val3", "map2":"2"}, [], ["set1", "set4"], "3"  )`)

	_, _, err = t.g.Query(`insert into /test/collect (v_varchar, v_map, v_list, v_set, v_type ) values ('5', {"map1": "val3", "map2":"2"}, nil, ["set1", "set4"], "3"  )`)

	if err != nil {
		logger.Errorf("%v", err)
	}
	require.Nil(t.Test, err, fmt.Sprint(err))
}

func (t *CollectTests) Valid() {

	rtn, _, err := t.g.Query(`select * from /test/collect`)

	if err != nil {
		logger.Errorf("%v", err)
	}

	if assert.Nil(t.Test, err) {
		if assert.NotNil(t.Test, rtn) {
			assert.Equal(t.Test, 5, len(rtn), "they should be equal")
		}
	}

	_, _, err = t.g.Query(`alter class /test/collect modify v_type merge enum { "5": [ "测试", "测试" ] }`)
	if err != nil {
		logger.Errorf("%v", err)
	}
	require.Nil(t.Test, err, fmt.Sprint(err))

	_, _, err = t.g.Query(`alter class /test/collect modify v_type merge enum { "0": [] }`)
	if err != nil {
		logger.Errorf("%v", err)
	}
	require.Nil(t.Test, err, fmt.Sprint(err))

	_, _, err = t.g.Query(`alter class /test/collect add index column v_text text`)
	// if err != nil {
	// 	logger.Errorf("%v", err)
	// }
	// require.Nil(t.Test, err, fmt.Sprint(err))
	// 忽略二次执行报错
}

func (t *CollectTests) Search() {

	var err error
	var rtn []map[string]interface{}

	rtn, _, err = t.g.Query(`select *  from /test/collect where v_map[key] = 'map1'`)
	if err != nil {
		logger.Errorf("%v", err)
	}
	if assert.Nil(t.Test, err) {
		assert.Equal(t.Test, 5, len(rtn), fmt.Sprintf("not find v_map key = %v", "map1"))
	}

	rtn, _, err = t.g.Query(`select *  from /test/collect where v_map = 'val2'`)
	if err != nil {
		logger.Errorf("%v", err)
	}
	if assert.Nil(t.Test, err) {
		assert.Equal(t.Test, 1, len(rtn), fmt.Sprintf("not find v_map = %v", "val2"))
	}

	rtn, _, err = t.g.Query(`select * from /test/collect where v_map['map1'] = 'val2'`)
	if err != nil {
		logger.Errorf("%v", err)
	}
	if assert.Nil(t.Test, err) {
		assert.Equal(t.Test, 1, len(rtn), fmt.Sprintf("not find v_map['map1'] = %v", "val2"))
	}

	rtn, _, err = t.g.Query(`select * from /test/collect where v_list = 'list1'`)
	if err != nil {
		logger.Errorf("%v", err)
	}
	if assert.Nil(t.Test, err) {
		assert.Equal(t.Test, 3, len(rtn), fmt.Sprintf("not find v_list = %v", "list1"))
	}

	rtn, _, err = t.g.Query(`select * from /test/collect where v_set = 'set1'`)
	if err != nil {
		logger.Errorf("%v", err)
	}
	if assert.Nil(t.Test, err) {
		assert.Equal(t.Test, 5, len(rtn), fmt.Sprintf("not find v_set = %v", "set1"))
	}
}

func (t *CollectTests) Aggr() {

	var err error
	var rtn []map[string]interface{}

	rtn, _, err = t.g.Query(`select count(*) from /test/collect group by v_list`)
	if err != nil {
		logger.Errorf("%v", err)
	}

	//-------------------------------
	// 目前无法区分nil 和 ""
	//-------------------------------
	if assert.Nil(t.Test, err) {
		assert.Equal(t.Test, 3, len(rtn), fmt.Sprintf("not find v_map key = %v", "map1"))
	}
}

func (t *CollectTests) AuthGroup() {

	var err error
	var rtn []map[string]interface{}

	stat, err := t.g.Prepare(`update /matrix/group set _group = _group + ? where name in ? `)

	if err != nil {
		fmt.Printf("%v", err)
	}

	if assert.Nil(t.Test, err) {
		_, _, err = stat.Exec(map[string][]string{"add": []string{"网络部"}, "delete": []string{"网络部"}, "edit": []string{"网络部"}, "list": []string{"网络部"}}, []string{"admin"})
		assert.Nil(t.Test, err, err)

		rtn, _, err = t.g.Query(`select _group from /matrix/group where name = 'admin' refresh`)
		if assert.Nil(t.Test, err) {
			if assert.Equal(t.Test, 1, len(rtn), "not find .") {

				groups := rtn[0]["_group"].(map[string][]string)
				assert.Equal(t.Test, []string{"网络部"}, groups["delete"], "not find .")
			}
		}

		_, _, err = stat.Exec(map[string][]interface{}{"add": []interface{}{"市场部"}}, []interface{}{"admin"})
		assert.Nil(t.Test, err)

		rtn, _, err = t.g.Query(`select _group from /matrix/group where name = 'admin' refresh`)
		if assert.Nil(t.Test, err) {
			if assert.Equal(t.Test, 1, len(rtn), "not find .") {
				groups := rtn[0]["_group"].(map[string][]string)
				assert.Equal(t.Test, 2, len(groups["add"]), "not find .")
			}
		}
	}
}

func (t *CollectTests) AuthGroupUpdate() {

	{
		rtn, _, err := t.g.Query(`select _group from /matrix/group where name = 'admin' refresh`)
		if err != nil {
			fmt.Printf("%v", err)
			return
		}
		bs, _ := json.MarshalIndent(rtn, "", "  ")
		fmt.Println("group info:", string(bs))

		rtn, _, err = t.g.Query(`update /matrix/group set _group = null where name = 'admin'`)
		if err != nil {
			fmt.Printf("%v", err)
			return
		}

		rtn, _, err = t.g.Query(`select _group from /matrix/group where name = 'admin' refresh`)
		if err != nil {
			fmt.Printf("%v", err)
			return
		}
		bs, _ = json.MarshalIndent(rtn, "", "  ")
		fmt.Println("null group info:", string(bs))
		if len(rtn) != 1 || rtn[0] == nil ||
			(rtn[0]["_group"] != nil && rtn[0]["_group"].(map[string][]string) != nil && len(rtn[0]["_group"].(map[string][]string)) > 0) {
			err = fmt.Errorf("group info is not null")
			fmt.Println(err)
			assert.Nil(t.Test, err)
			return
		}
	}

	var err error
	var rtn []map[string]interface{}

	stat, err := t.g.Prepare(`update /matrix/group set _group = _group + ? where name in ? `)

	if err != nil {
		fmt.Printf("%v", err)
	}

	if assert.Nil(t.Test, err) {
		_, _, err = stat.Exec(map[string][]string{"add": []string{"网络部"}, "delete": []string{"网络部"}, "edit": []string{"网络部"}, "list": []string{"网络部"}}, []string{"admin"})
		assert.Nil(t.Test, err, err)

		rtn, _, err = t.g.Query(`select _group from /matrix/group where name = 'admin' refresh`)
		if assert.Nil(t.Test, err) {
			if assert.Equal(t.Test, 1, len(rtn), "not find .") {

				groups := rtn[0]["_group"].(map[string][]string)
				assert.Equal(t.Test, []string{"网络部"}, groups["delete"], "not find .")
			}
		}
		bs, _ := json.MarshalIndent(rtn, "", "  ")
		fmt.Println("update 1 group info:", string(bs))

		_, _, err = stat.Exec(map[string][]interface{}{"add": []interface{}{"市场部"}}, []interface{}{"admin"})
		assert.Nil(t.Test, err)

		rtn, _, err = t.g.Query(`select _group from /matrix/group where name = 'admin' refresh`)
		if assert.Nil(t.Test, err) {
			if assert.Equal(t.Test, 1, len(rtn), "not find .") {
				groups := rtn[0]["_group"].(map[string][]string)
				assert.Equal(t.Test, 2, len(groups["add"]), "not find .")
			}
		}
		bs, _ = json.MarshalIndent(rtn, "", "  ")
		fmt.Println("update 2 group info:", string(bs))
	}

	time.Sleep(300 * time.Millisecond)
	rtn, _, err = t.g.Query(`select _group from /matrix/group where name = 'admin' refresh`)
	if assert.Nil(t.Test, err) {
		if assert.Equal(t.Test, 1, len(rtn), "not find .") {
			groups := rtn[0]["_group"].(map[string][]string)
			assert.Equal(t.Test, 2, len(groups["add"]), "not find .")
		}
	}
	bs, _ := json.MarshalIndent(rtn, "", "  ")
	fmt.Println("sleep 300ms group info:", string(bs))
}