package parser_test

import (
	"testing"

	. "github.com/smartystreets/goconvey/convey"

	"github.com/subconverter-go/internal/config"
	"github.com/subconverter-go/internal/logging"
	parser_pkg "github.com/subconverter-go/internal/parser"
)

func TestParserManager(t *testing.T) {
	Convey("ParserManager", t, func() {
		// 创建日志记录器
		logger, err := logging.NewLogger(&logging.LoggingConfig{
			Level:  "info",
			Format: "text",
			Output: "stdout",
		})
		So(err, ShouldBeNil)

		// 创建配置管理器
		configMgr, err := config.NewConfigManager("")
		So(err, ShouldBeNil)

		// 创建解析器管理器
		parserMgr := parser_pkg.NewParserManager(logger, configMgr)

		Convey("应该正确注册所有解析器", func() {
			protocols := parserMgr.GetSupportedProtocols()
			So(protocols, ShouldContain, "ss")
			So(protocols, ShouldContain, "ssr")
			So(protocols, ShouldContain, "vmess")
			So(protocols, ShouldContain, "trojan")
			So(protocols, ShouldContain, "http")
			So(protocols, ShouldContain, "socks5")
			So(len(protocols), ShouldEqual, 6)
		})

		Convey("应该能获取指定的解析器", func() {
			ssParser, err := parserMgr.GetParser("ss")
			So(err, ShouldBeNil)
			So(ssParser, ShouldNotBeNil)

			vmessParser, err := parserMgr.GetParser("vmess")
			So(err, ShouldBeNil)
			So(vmessParser, ShouldNotBeNil)

			// 测试不支持的协议
			_, err = parserMgr.GetParser("unsupported")
			So(err, ShouldNotBeNil)
			So(err.Error(), ShouldContainSubstring, "parser not found")
		})
	})
}

func TestShadowsocksParser(t *testing.T) {
	Convey("ShadowsocksParser", t, func() {
		logger, err := logging.NewLogger(&logging.LoggingConfig{
			Level:  "info",
			Format: "text",
			Output: "stdout",
		})
		So(err, ShouldBeNil)

		parserInstance := parser_pkg.NewShadowsocksParser(logger)

		Convey("应该能解析标准的Shadowsocks配置", func() {
			// 测试Base64编码的配置
			input := "ss://YWVzLTI1Ni1jZmI6cGFzc3dvcmRAMTkyLjE2OC4xLjE6ODAwMA=="
			config, err := parserInstance.Parse(input)
			So(err, ShouldBeNil)
			So(config, ShouldNotBeNil)
			So(config.Protocol, ShouldEqual, "ss")
			So(config.Server, ShouldEqual, "192.168.1.1")
			So(config.Port, ShouldEqual, 8000)
		})

		Convey("应该能验证Shadowsocks配置", func() {
			config := &parser_pkg.ProxyConfig{
				Protocol: "ss",
				Server:   "192.168.1.1",
				Port:     8000,
				Settings: map[string]interface{}{
					"method":   "aes-256-cfb",
					"password": "password",
					"udp":      true,
				},
			}

			err := parserInstance.Validate(config)
			So(err, ShouldBeNil)

			// 测试无效配置
			invalidConfig := &parser_pkg.ProxyConfig{
				Protocol: "ss",
				Server:   "192.168.1.1",
				Port:     8000,
				Settings: map[string]interface{}{
					"method":   "", // 缺少加密方法
					"password": "password",
				},
			}

			err = parserInstance.Validate(invalidConfig)
			So(err, ShouldNotBeNil)
			So(err.Error(), ShouldContainSubstring, "encryption method is required")
		})

		Convey("应该返回支持的协议", func() {
			protocols := parserInstance.GetSupportedProtocols()
			So(protocols, ShouldResemble, []string{"ss"})
		})
	})
}

func TestVMessParser(t *testing.T) {
	Convey("VMessParser", t, func() {
		logger, err := logging.NewLogger(&logging.LoggingConfig{
			Level:  "info",
			Format: "text",
			Output: "stdout",
		})
		So(err, ShouldBeNil)

		parserInstance := parser_pkg.NewVMessParser(logger)

		Convey("应该能解析标准的VMess配置", func() {
			// 简单的VMess配置测试（实际应该使用真实的Base64编码配置）
			input := "vmess://eyJ2IjoiMiIsInBzIjoidGVzdCIsImFkZCI6IjE5Mi4xNjguMS4xIiwicG9ydCI6IjQ0MyIsImlkIjoiMTIzNDU2NzgtMTIzNC0xMjM0LTEyMzQtMTIzNDU2Nzg5MDEyIiwiYWlkIjoiMCIsIm5ldCI6IndzIiwidHlwZSI6Im5vbmUiLCJob3N0IjoidGVzdC5jb20iLCJwYXRoIjoiL3Rlc3QiLCJ0bHMiOiJ0bHMifQ=="
			config, err := parserInstance.Parse(input)
			So(err, ShouldBeNil)
			So(config, ShouldNotBeNil)
			So(config.Protocol, ShouldEqual, "vmess")
			So(config.Server, ShouldEqual, "192.168.1.1")
			So(config.Port, ShouldEqual, 443)
		})

		Convey("应该能验证VMess配置", func() {
			config := &parser_pkg.ProxyConfig{
				Protocol: "vmess",
				Server:   "192.168.1.1",
				Port:     443,
				Settings: map[string]interface{}{
					"uuid":    "12345678-1234-1234-1234-123456789012",
					"alterId": 0,
					"network": "ws",
					"tls":     "tls",
					"udp":     true,
				},
			}

			err := parserInstance.Validate(config)
			So(err, ShouldBeNil)

			// 测试无效的UUID
			invalidConfig := &parser_pkg.ProxyConfig{
				Protocol: "vmess",
				Server:   "192.168.1.1",
				Port:     443,
				Settings: map[string]interface{}{
					"uuid":    "invalid-uuid",
					"alterId": 0,
					"network": "ws",
				},
			}

			err = parserInstance.Validate(invalidConfig)
			So(err, ShouldNotBeNil)
		})

		Convey("应该返回支持的协议", func() {
			protocols := parserInstance.GetSupportedProtocols()
			So(protocols, ShouldResemble, []string{"vmess"})
		})
	})
}

func TestTrojanParser(t *testing.T) {
	Convey("TrojanParser", t, func() {
		logger, err := logging.NewLogger(&logging.LoggingConfig{
			Level:  "info",
			Format: "text",
			Output: "stdout",
		})
		So(err, ShouldBeNil)

		parserInstance := parser_pkg.NewTrojanParser(logger)

		Convey("应该能解析标准的Trojan配置", func() {
			input := "trojan://password@192.168.1.1:443#test"
			config, err := parserInstance.Parse(input)
			So(err, ShouldBeNil)
			So(config, ShouldNotBeNil)
			So(config.Protocol, ShouldEqual, "trojan")
			So(config.Server, ShouldEqual, "192.168.1.1")
			So(config.Port, ShouldEqual, 443)
		})

		Convey("应该能验证Trojan配置", func() {
			config := &parser_pkg.ProxyConfig{
				Protocol: "trojan",
				Server:   "192.168.1.1",
				Port:     443,
				Settings: map[string]interface{}{
					"password": "password",
					"network":  "tcp",
					"udp":      true,
				},
			}

			err := parserInstance.Validate(config)
			So(err, ShouldBeNil)

			// 测试缺少密码的配置
			invalidConfig := &parser_pkg.ProxyConfig{
				Protocol: "trojan",
				Server:   "192.168.1.1",
				Port:     443,
				Settings: map[string]interface{}{
					"password": "", // 缺少密码
					"network":  "tcp",
				},
			}

			err = parserInstance.Validate(invalidConfig)
			So(err, ShouldNotBeNil)
			So(err.Error(), ShouldContainSubstring, "password is required")
		})

		Convey("应该返回支持的协议", func() {
			protocols := parserInstance.GetSupportedProtocols()
			So(protocols, ShouldResemble, []string{"trojan"})
		})
	})
}

func TestHTTPParser(t *testing.T) {
	Convey("HTTPParser", t, func() {
		logger, err := logging.NewLogger(&logging.LoggingConfig{
			Level:  "info",
			Format: "text",
			Output: "stdout",
		})
		So(err, ShouldBeNil)

		parserInstance := parser_pkg.NewHTTPParser(logger)

		Convey("应该能解析HTTP配置", func() {
			input := "http://username:password@192.168.1.1:8080#test"
			config, err := parserInstance.Parse(input)
			So(err, ShouldBeNil)
			So(config, ShouldNotBeNil)
			So(config.Protocol, ShouldEqual, "http")
			So(config.Server, ShouldEqual, "192.168.1.1")
			So(config.Port, ShouldEqual, 8080)
		})

		Convey("应该能解析HTTPS配置", func() {
			input := "https://192.168.1.1:443#test"
			config, err := parserInstance.Parse(input)
			So(err, ShouldBeNil)
			So(config, ShouldNotBeNil)
			So(config.Protocol, ShouldEqual, "http")
			So(config.Server, ShouldEqual, "192.168.1.1")
			So(config.Port, ShouldEqual, 443)
		})

		Convey("应该能验证HTTP配置", func() {
			config := &parser_pkg.ProxyConfig{
				Protocol: "http",
				Server:   "192.168.1.1",
				Port:     8080,
				Settings: map[string]interface{}{
					"username": "username",
					"password": "password",
					"udp":      false,
				},
			}

			err := parserInstance.Validate(config)
			So(err, ShouldBeNil)
		})

		Convey("应该返回支持的协议", func() {
			protocols := parserInstance.GetSupportedProtocols()
			So(protocols, ShouldResemble, []string{"http", "https"})
		})
	})
}

func TestSocks5Parser(t *testing.T) {
	Convey("Socks5Parser", t, func() {
		logger, err := logging.NewLogger(&logging.LoggingConfig{
			Level:  "info",
			Format: "text",
			Output: "stdout",
		})
		So(err, ShouldBeNil)

		parserInstance := parser_pkg.NewSocks5Parser(logger)

		Convey("应该能解析Socks5配置", func() {
			input := "socks5://username:password@192.168.1.1:1080#test"
			config, err := parserInstance.Parse(input)
			So(err, ShouldBeNil)
			So(config, ShouldNotBeNil)
			So(config.Protocol, ShouldEqual, "socks5")
			So(config.Server, ShouldEqual, "192.168.1.1")
			So(config.Port, ShouldEqual, 1080)
		})

		Convey("应该能验证Socks5配置", func() {
			config := &parser_pkg.ProxyConfig{
				Protocol: "socks5",
				Server:   "192.168.1.1",
				Port:     1080,
				Settings: map[string]interface{}{
					"username": "username",
					"password": "password",
					"udp":      true,
				},
			}

			err := parserInstance.Validate(config)
			So(err, ShouldBeNil)
		})

		Convey("应该返回支持的协议", func() {
			protocols := parserInstance.GetSupportedProtocols()
			So(protocols, ShouldResemble, []string{"socks5"})
		})
	})
}