package gocmdDaemon

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

func TestMFlag_Int(t *testing.T) {
	// 保存原始参数，以便测试后恢复
	oldArgs := os.Args
	defer func() { os.Args = oldArgs }()

	// 重置flag包状态
	flag.CommandLine = flag.NewFlagSet(os.Args[0], flag.ExitOnError)

	// 设置测试参数
	os.Args = []string{"cmd", "-i", "123", "--int-flag", "456"}

	m := &MFlag{
		flags: make(map[string]interface{}),
	}

	// 注册标志
	m.Int("i", "int-flag", 0, "测试整数标志")
	m.Parse()

	// 测试短标志
	if got := m.GetIntFlag("int-flag"); got != 456 {
		t.Errorf("GetIntFlag() = %v, want %v", got, 456)
	}
}

func TestMFlag_String(t *testing.T) {
	// 保存原始参数，以便测试后恢复
	oldArgs := os.Args
	defer func() { os.Args = oldArgs }()

	// 重置flag包状态
	flag.CommandLine = flag.NewFlagSet(os.Args[0], flag.ExitOnError)

	// 设置测试参数
	os.Args = []string{"cmd", "-s", "hello", "--str-flag", "world"}

	m := &MFlag{
		flags: make(map[string]interface{}),
	}

	// 注册标志
	m.String("s", "str-flag", "", "测试字符串标志")
	m.Parse()

	// 测试长标志
	if got := m.GetStringFlag("str-flag"); got != "world" {
		t.Errorf("GetStringFlag() = %v, want %v", got, "world")
	}
}

func TestMFlag_Bool(t *testing.T) {
	// 保存原始参数，以便测试后恢复
	oldArgs := os.Args
	defer func() { os.Args = oldArgs }()

	// 重置flag包状态
	flag.CommandLine = flag.NewFlagSet(os.Args[0], flag.ExitOnError)

	// 设置测试参数
	os.Args = []string{"cmd", "-b", "--bool-flag"}

	m := &MFlag{
		flags: make(map[string]interface{}),
	}

	// 注册标志
	m.Bool("b", "bool-flag", false, "测试布尔标志")
	m.Parse()

	// 测试布尔标志
	if got := m.GetBoolFlag("bool-flag"); !got {
		t.Errorf("GetBoolFlag() = %v, want %v", got, true)
	}
}

func TestMFlag_GetNonExistentFlags(t *testing.T) {
	m := &MFlag{
		flags: make(map[string]interface{}),
	}

	// 测试获取不存在的标志
	if got := m.GetIntFlag("non-existent"); got != -1 {
		t.Errorf("GetIntFlag() for non-existent flag = %v, want %v", got, -1)
	}

	if got := m.GetStringFlag("non-existent"); got != "" {
		t.Errorf("GetStringFlag() for non-existent flag = %v, want %v", got, "")
	}

	if got := m.GetBoolFlag("non-existent"); got != false {
		t.Errorf("GetBoolFlag() for non-existent flag = %v, want %v", got, false)
	}
}

func TestMFlag_RemainArgs(t *testing.T) {
	// 保存原始参数，以便测试后恢复
	oldArgs := os.Args
	defer func() { os.Args = oldArgs }()

	// 重置flag包状态
	flag.CommandLine = flag.NewFlagSet(os.Args[0], flag.ExitOnError)

	// 设置测试参数，包括剩余参数
	os.Args = []string{"cmd", "-i", "123", "arg1", "arg2", "arg3", "-d"}

	m := &MFlag{
		flags: make(map[string]interface{}),
	}

	// 注册标志
	m.Int("i", "int-flag", 0, "测试整数标志")
	m.Parse()

	// 测试剩余参数
	expectedArgs := []string{"arg1", "arg2", "arg3", "-d"}
	if len(m.RemainArgs) != len(expectedArgs) {
		t.Errorf("RemainArgs length = %v, want %v", len(m.RemainArgs), len(expectedArgs))
	}

	for i, arg := range expectedArgs {
		if i < len(m.RemainArgs) && m.RemainArgs[i] != arg {
			t.Errorf("RemainArgs[%d] = %v, want %v", i, m.RemainArgs[i], arg)
		}
	}
}

func TestMFlag_MultipleFlags(t *testing.T) {
	// 保存原始参数，以便测试后恢复
	oldArgs := os.Args
	defer func() { os.Args = oldArgs }()

	// 重置flag包状态
	flag.CommandLine = flag.NewFlagSet(os.Args[0], flag.ExitOnError)

	// 设置测试参数
	os.Args = []string{"cmd", "-i", "123", "-s", "hello", "-b", "subcmd", "-s", "h1"}

	m := &MFlag{
		flags: make(map[string]interface{}),
	}

	// 注册多个标志
	m.Int("i", "int-flag", 0, "测试整数标志")
	m.String("s", "str-flag", "", "测试字符串标志")
	m.Bool("b", "bool-flag", false, "测试布尔标志")
	m.Parse()

	// 测试所有标志值
	if got := m.GetIntFlag("int-flag"); got != 123 {
		t.Errorf("GetIntFlag() = %v, want %v", got, 123)
	}

	if got := m.GetStringFlag("str-flag"); got != "hello" {
		t.Errorf("GetStringFlag() = %v, want %v", got, "hello")
	}

	if got := m.GetBoolFlag("bool-flag"); !got {
		t.Errorf("GetBoolFlag() = %v, want %v", got, true)
	}
}

func TestMFlag_MarshalJSON(t *testing.T) {
	oldArgs := os.Args
	defer func() { os.Args = oldArgs }()

	// 重置flag包状态
	flag.CommandLine = flag.NewFlagSet(os.Args[0], flag.ExitOnError)

	// 设置测试参数
	os.Args = []string{"cmd", "-i", "123", "-s", "hello", "-b", "subcmd", "-s", "h1"}

	m := &MFlag{
		flags: make(map[string]interface{}),
	}

	// 注册多个标志
	m.Int("i", "int-flag", 0, "测试整数标志")
	m.String("s", "str-flag", "", "测试字符串标志")
	m.Bool("b", "bool-flag", false, "测试布尔标志")
	m.Parse()
	fmt.Println(m.GetIntFlag("int-flag"))
	jsonBytes, err := m.MarshalJSON()
	if err != nil {
		t.Errorf("MarshalJSON() error = %v, want nil", err)
	}
	var result map[string]interface{}
	err = json.Unmarshal(jsonBytes, &result)
	if err != nil {
		t.Errorf("UnmarshalJSON() error = %v, want nil", err)
	}
	if int(result["int-flag"].(float64)) != 123 {
		t.Errorf("MarshalJSON() int-flag = %v, want %v", result["int-flag"], 123)
	}
	if result["str-flag"] != "hello" {
		t.Errorf("MarshalJSON() str-flag = %v, want %v", result["str-flag"], "hello")
	}
	if result["bool-flag"] != true {
		t.Errorf("MarshalJSON() bool-flag = %v, want %v", result["bool-flag"], true)
	}
	m1 := &MFlag{
		flags: make(map[string]interface{}),
	}
	err1 := json.Unmarshal(jsonBytes, m1)
	if err1 != nil {
		t.Errorf("UnmarshalJSON() error = %v, want nil", err)
	}
	if int(m1.GetIntFlag("int-flag")) != 123 {
		t.Errorf("MarshalJSON() int-flag = %v, want %v", m1.GetIntFlag("int-flag"), 123)
	}
	if m1.GetStringFlag("str-flag") != "hello" {
		t.Errorf("MarshalJSON() str-flag = %v, want %v", m1.GetStringFlag("str-flag"), "hello")
	}
	if m1.GetBoolFlag("bool-flag") != true {
		t.Errorf("MarshalJSON() bool-flag = %v, want %v", m1.GetBoolFlag("bool-flag"), true)
	}
}