package main

import (
	"encoding/json"
	"fmt"
	"net"
	"os"
	"testing"
	"time"
)

func TestWrite(t *testing.T) {
	// 创建一个配对的连接
	conn1, conn2 := net.Pipe()
	defer conn1.Close()
	defer conn2.Close()

	// 要写入的数据
	data := map[string]string{"test": "data"}

	// 在一个goroutine中执行写操作
	go func() {
		err := Write(conn1, data)
		if err != nil {
			t.Errorf("Write failed: %v", err)
		}
	}()

	// 读取数据并验证
	var received map[string]string
	err := json.NewDecoder(conn2).Decode(&received)
	if err != nil {
		t.Fatalf("Read failed: %v", err)
	}

	for k, v := range data {
		if received[k] != v {
			t.Errorf("Received data does not match. Expected %v:%v, Got %v:%v", k, v, received[k], received[k])
		}
	}
}

func TestRead(t *testing.T) {
	// 创建一个配对的连接
	conn1, conn2 := net.Pipe()
	defer conn1.Close()
	defer conn2.Close()

	// 准备要读取的数据
	data := map[string]string{"test": "data"}

	// 在一个goroutine中执行写操作
	go func() {
		encoder := json.NewEncoder(conn1)
		err := encoder.Encode(data)
		if err != nil {
			t.Errorf("Write failed: %v", err)
		}
	}()

	// 读取数据并验证
	received, err := Read[map[string]string](conn2)
	if err != nil {
		t.Fatalf("Read failed: %v", err)
	}

	for k, v := range data {
		if (*received)[k] != v {
			t.Errorf("Received data does not match. Expected %v:%v, Got %v:%v", k, v, (*received)[k], (*received)[k])
		}
	}
}

func TestCmdDaemonListen(t *testing.T) {
	socketPath := "/tmp/test.sock"
	daemon := &CmdDaemon{
		SocketPath: socketPath,
		cmds:       make(map[string]CmdHandler),
	}

	// 注册一个简单的命令处理程序
	daemon.RegisterCmd("test", &SimpleCmdHandler{})

	// 启动守护进程
	go func() {
		err := daemon.Listen()
		if err != nil {
			t.Errorf("Listen failed: %v", err)
		}
	}()

	// 等待服务器启动
	time.Sleep(1 * time.Second)

	// 模拟客户端连接
	conn, err := net.Dial("unix", socketPath)
	if err != nil {
		t.Fatalf("Client connect failed: %v", err)
	}
	defer conn.Close()

	// 发送请求
	req := CmdRequest{
		Id:      "1",
		Cmd:     "test",
		Args:    "arg1",
		IsDebug: false,
	}
	err = Write(conn, req)
	if err != nil {
		t.Errorf("Write failed: %v", err)
	}

	// 读取响应
	resp, err := Read[CmdResponse](conn)
	if err != nil {
		t.Fatalf("Read failed: %v", err)
	}

	if resp.Data != "Handled test with args: arg1" || resp.Error != "" {
		t.Errorf("Unexpected response. Data: %v, Error: %v", resp.Data, resp.Error)
	}
}

func TestCmdDaemonRun(t *testing.T) {
	// 这里我们假设有一个正在运行的服务器来处理请求
	// 因此我们需要首先启动一个简单的服务器来测试Run方法
	socketPath := "/tmp/test_run.sock"
	daemon := &CmdDaemon{
		SocketPath: socketPath,
		cmds:       make(map[string]CmdHandler),
	}

	// 注册一个简单的命令处理程序
	daemon.RegisterCmd("test", &SimpleCmdHandler{})

	// 创建一个同步通道来等待守护进程开始监听
	listening := make(chan struct{})

	// 启动守护进程
	go startTestDaemon(daemon, listening)

	// 等待直到监听开始
	// for循环中检查socket文件是否存在,如果存在退出循环，否则sleepeep 1秒
	// 使用一个错误channel来传递错误
	errChan := make(chan error)

	go func() {
		listened := false
		for {

			if listened {
				break
			}
			if _, err := os.Stat(socketPath); err == nil {
				listened = true
			}
			time.Sleep(1 * time.Second)
		}

		// 设置命令行参数
		os.Args = []string{"cmd", "--debug", "test", "arg1"}
		ndaemon := &CmdDaemon{
			SocketPath: socketPath,
		}
		// 执行Run方法
		err := ndaemon.Run()
		if err != nil {
			errChan <- err
		} else {
			t.Log("Run completed successfully")
			close(errChan)
		}
	}()
	err := <-errChan
	if err != nil {
		t.Fatal(err)
	}

}

// startTestDaemon 启动守护进程并在后台运行
func startTestDaemon(daemon *CmdDaemon, ready chan struct{}) {
	err := daemon.Listen()
	if err != nil {
		panic(fmt.Sprintf("Listen failed: %v", err))
	}

}

// SimpleCmdHandler 是一个简单的CmdHandler实现用于测试
type SimpleCmdHandler struct{}

func (h *SimpleCmdHandler) Handle(conn *CmdConn, req *CmdRequest) error {
	err := conn.End(fmt.Sprintf("Handled %s with args: %s", req.Cmd, req.Args))
	return err
}

func (h *SimpleCmdHandler) Description() string {
	return "Simple command handler for testing"
}

func (h *SimpleCmdHandler) Usage() string {
	return "Usage: test [args]"
}