package app_environment

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

func Test_Set(t *testing.T) {
	var err error
	err = Set("a", "a")
	if err != nil {
		t.Error(err)
	}

	err = Set("b", "b")
	if err != nil {
		t.Error(err)
	}

	err = Set("c", "1")
	if err != nil {
		t.Error(err)
	}

	err = Set("d", "2")
	if err != nil {
		t.Error(err)
	}

	err = Set("e", "true")
	if err != nil {
		t.Error(err)
	}

	err = Set("a", "a")
	if err == nil {
		t.Error("Set覆盖存在问题")
	}

	tm := &tempkv{
		Name: "byron",
	}
	str, _ := json.Marshal(tm)
	Set("str", string(str))

	kvmap := make(map[string]string)
	kvmap["a_1"] = "aaa"
	err = SetMap(kvmap)
	if err != nil {
		t.Error(err)
	}

	err = SetMap(kvmap)
	if err == nil {
		t.Error("SetMap覆盖存在问题")
	}

	kvmap = make(map[string]string)
	kvmap["b_aa"] = "b_aa"
	SetForCoverMap(kvmap)
	SetForCoverMap(kvmap)

	SetForCover("a", "a")
}

func Test_Get(t *testing.T) {
	m := GetAll()
	if len(m) != 8 {
		t.Error(fmt.Sprintf("getall错误  m=%v", len(m)))
	}

	v, isok := Get("a")
	if isok == false {
		t.Error("未获取到a")
	}
	if v != "a" {
		t.Error("get值错误")
	}

	var i int
	var err error
	i, isok, err = GetInt("c")
	if err != nil {
		t.Error("GetInt 出错 err:", err)
	}
	if isok == false {
		t.Error("GetInt 获取失败")
	}
	if i != 1 {
		t.Error("GetInt值失败")
	}

	var i32 int32
	i32, isok, err = GetInt32("c")
	if err != nil {
		t.Error("GetInt 出错 err:", err)
	}
	if isok == false {
		t.Error("GetInt 获取失败")
	}
	if i32 != 1 {
		t.Error("GetInt值失败")
	}

	var i64 int64
	i64, isok, err = GetInt64("d")
	if err != nil {
		t.Error("GetInt64 出错 err:", err)
	}
	if isok == false {
		t.Error("GetInt64 获取失败")
	}
	if i64 != 2 {
		t.Error("GetInt64 值失败")
	}

	var b bool
	b, isok, err = GetBool("e")
	if err != nil {
		t.Error("GetBool 出错 err:", err)
	}
	if isok == false {
		t.Error("GetBool 获取失败")
	}
	if b == false {
		t.Error("GetBool 值失败")
	}

	tm := &tempkv{}
	isok, err = GetModel("str", tm)
	if err != nil {
		t.Error("GetModel 出错 err:", err)
	}
	if isok == false {
		t.Error("GetModel 获取失败")
	}
	if tm.Name != "byron" {
		t.Error("GetModel 值失败")
	}
}

func Test_GetOrDefault(t *testing.T) {
	v := GetOrDefault("notExists", "default")
	if v != "default" {
		t.Error("GetOrDefault 返回默认值不正确")
	}

	Set("stringTest", "ok")
	v = GetOrDefault("stringTest", "default")
	if v != "ok" {
		t.Error("GetOrDefault 返回值不正确")
	}

	i, err := GetIntOrDefault("notExists", -99)
	if err != nil {
		t.Error(err)
	}

	if i != -99 {
		t.Error("GetIntOrDefault 返回默认值不正确")
	}

	Set("intTest", "99")
	i, err = GetIntOrDefault("intTest", -99)
	if err != nil {
		t.Error(err)
	}
	if i != 99 {
		t.Error("GetIntOrDefault 返回值不正确")
	}

	Set("intTestError", "a99")
	i, err = GetIntOrDefault("intTestError", -99)
	if err == nil {
		t.Error("GetIntOrDefault 解析时错误未抛出")
	}

	i32, err := GetInt32OrDefault("notExists", -99)
	if err != nil {
		t.Error(err)
	}

	if i32 != -99 {
		t.Error("GetInt32OrDefault 返回默认值不正确")
	}

	Set("int32Test", "99")
	i32, err = GetInt32OrDefault("int32Test", -99)
	if err != nil {
		t.Error(err)
	}
	if i32 != 99 {
		t.Error("GetInt32OrDefault 返回值不正确")
	}

	Set("int32TestError", "a99")
	i32, err = GetInt32OrDefault("int32TestError", -99)
	if err == nil {
		t.Error("GetInt32OrDefault 解析时错误未抛出")
	}

	i64, err := GetInt64OrDefault("notExists", -99)
	if err != nil {
		t.Error(err)
	}

	if i64 != -99 {
		t.Error("GetInt64OrDefault 返回默认值不正确")
	}

	Set("int64Test", "99")
	i64, err = GetInt64OrDefault("int64Test", -99)
	if err != nil {
		t.Error(err)
	}
	if i64 != 99 {
		t.Error("GetInt64OrDefault 返回值不正确")
	}

	Set("int64TestError", "a99")
	i64, err = GetInt64OrDefault("int64TestError", -99)
	if err == nil {
		t.Error("GetInt64OrDefault 解析时错误未抛出")
	}

	b, err := GetBoolOrDefault("notExists", true)
	if err != nil {
		t.Error(err)
	}

	if !b {
		t.Error("GetBoolOrDefault 返回默认值不正确")
	}

	Set("boolTest", "true")
	b, err = GetBoolOrDefault("boolTest", false)
	if err != nil {
		t.Error(err)
	}
	if !b {
		t.Error("GetBoolOrDefault 返回值不正确")
	}

	Set("boolTestError", "sss")
	b, err = GetBoolOrDefault("boolTestError", true)
	if err == nil {
		t.Error("GetBoolOrDefault 解析时错误未抛出")
	}
}

func Test_Reset(t *testing.T) {
	if err := Reset(nil); err == nil {
		t.Error("Reset nil参数错误未抛出")
	}

	m := make(map[string]string)
	if err := Reset(m); err != nil {
		t.Error("Reset 错误的抛出错误")
	}
}

type tempkv struct {
	Name string
}