package conversion

import (
	"encoding/base64"
	"encoding/json"
	"fmt"
	"net/http"
	"net/url"
	"regexp"
	"strconv"
	"strings"
)

// ConversionRequest 表示转换请求的参数和配置
// 该结构体包含从HTTP请求解析出的所有转换参数
type ConversionRequest struct {
	// 基本参数
	Target  string   `json:"target"` // 目标格式：clash, surge, quanx, loon, surfboard, v2ray
	URL     string   `json:"url"`    // 源订阅URL
	RawURL  string   `json:"-"`      // 原始请求中的URL参数（可能包含多源）
	Sources []string `json:"-"`      // 解析后的订阅源列表

	// 请求上下文
	UserAgent string `json:"-"` // 客户端传入的 User-Agent，用于远程拉取订阅时复用

	// 可选参数
	ConfigURL        string `json:"config_url,omitempty"` // 自定义配置文件URL
	Emoji            bool   `json:"emoji,omitempty"`      // 是否启用emoji
	UDP              bool   `json:"udp,omitempty"`        // 是否启用UDP支持
	IPv6             bool   `json:"ipv6,omitempty"`       // 是否启用IPv6支持
	Group            string `json:"group,omitempty"`      // 节点分组名称
	Insert           bool   `json:"insert,omitempty"`     // 是否插入URL测试
	Strict           bool   `json:"strict,omitempty"`     // 是否严格模式
	Compatible       bool   `json:"compatible,omitempty"` // 是否兼容模式
	AppendType       bool   `json:"append_type,omitempty"`
	TFO              bool   `json:"tfo,omitempty"`
	Script           bool   `json:"script,omitempty"`
	SkipCert         bool   `json:"skip_cert_verify,omitempty"`
	FilterDeprecated bool   `json:"filter_deprecated,omitempty"`
	ExpandRules      bool   `json:"expand_rules,omitempty"`
	AppendInfo       bool   `json:"append_info,omitempty"`
	Prepend          bool   `json:"prepend,omitempty"`
	Classic          bool   `json:"classic,omitempty"`
	TLS13            bool   `json:"tls13,omitempty"`
	AddEmoji         bool   `json:"add_emoji,omitempty"`
	RemoveEmoji      bool   `json:"remove_emoji,omitempty"`
	Upload           bool   `json:"upload,omitempty"`

	// 过滤参数
	Include     []string `json:"include,omitempty"`      // 包含的关键词
	Exclude     []string `json:"exclude,omitempty"`      // 排除的关键词
	Regex       string   `json:"regex,omitempty"`        // 正则表达式过滤
	Location    string   `json:"location,omitempty"`     // 地区过滤
	RenameRules []string `json:"rename_rules,omitempty"` // 重命名规则

	// 高级参数
	Test         bool     `json:"test,omitempty"`     // 是否启用测试
	List         bool     `json:"list,omitempty"`     // 是否列表模式
	Filename     string   `json:"filename,omitempty"` // 输出文件名
	UploadPath   string   `json:"upload_path,omitempty"`
	FilterScript string   `json:"filter_script,omitempty"`
	DeviceID     string   `json:"device_id,omitempty"`
	Interval     string   `json:"interval,omitempty"`
	Groups       []string `json:"groups,omitempty"`
	Rulesets     []string `json:"rulesets,omitempty"`
	BasePath     string   `json:"-"`
	Providers    []string `json:"providers,omitempty"`
	EmojiRules   []string `json:"emoji_rules,omitempty"`
}

// NewConversionRequest 创建新的转换请求
// 返回包含默认值的ConversionRequest结构体
func NewConversionRequest() *ConversionRequest {
	return &ConversionRequest{
		Target:       "",
		URL:          "",
		RawURL:       "",
		Sources:      []string{},
		UserAgent:    "",
		ConfigURL:    "",
		Emoji:        false,
		UDP:          false,
		IPv6:         false,
		Group:        "",
		Insert:       false,
		Strict:       false,
		Compatible:   true, // 默认启用兼容模式
		Include:      []string{},
		Exclude:      []string{},
		Regex:        "",
		Location:     "",
		RenameRules:  []string{},
		Test:         false,
		List:         false,
		Filename:     "",
		UploadPath:   "",
		FilterScript: "",
		DeviceID:     "",
		Interval:     "",
		Groups:       []string{},
		Rulesets:     []string{},
		BasePath:     "",
		Providers:    []string{},
		EmojiRules:   []string{},
	}
}

// SetURL 设置订阅URL（支持多源）
func (r *ConversionRequest) SetURL(raw string) error {
	trimmed := strings.TrimSpace(raw)
	r.RawURL = trimmed
	if trimmed == "" {
		r.URL = ""
		r.Sources = nil
		return nil
	}
	sources, err := parseSourcesFromRaw(trimmed)
	if err != nil {
		return err
	}
	r.Sources = sources
	if len(sources) > 0 {
		r.URL = sources[0]
	} else {
		r.URL = ""
	}
	return nil
}

// GetSources 返回订阅源列表（拷贝）
func (r *ConversionRequest) GetSources() []string {
	if len(r.Sources) > 0 {
		out := make([]string, len(r.Sources))
		copy(out, r.Sources)
		return out
	}
	if strings.TrimSpace(r.URL) != "" {
		return []string{strings.TrimSpace(r.URL)}
	}
	return nil
}

// SourceSummary 返回用于记录/展示的源URL字符串
func (r *ConversionRequest) SourceSummary() string {
	if strings.TrimSpace(r.RawURL) != "" {
		return r.RawURL
	}
	sources := r.GetSources()
	if len(sources) == 0 {
		return ""
	}
	return strings.Join(sources, "|")
}

// Validate 验证转换请求的有效性
// 返回error如果请求无效，nil表示请求有效
func (r *ConversionRequest) Validate() error {
	// 验证必需字段
	if r.Target == "" {
		return fmt.Errorf("target format cannot be empty")
	}

	sources := r.GetSources()
	if len(sources) == 0 && strings.TrimSpace(r.URL) != "" {
		if err := r.SetURL(r.URL); err != nil {
			return err
		}
		sources = r.GetSources()
	}
	if len(sources) == 0 {
		return fmt.Errorf("source URL cannot be empty")
	}

	// 验证目标格式
	target := strings.ToLower(r.Target)
	if target == "auto" {
		return nil
	}

	validTargets := map[string]bool{
		"clash":     true,
		"clashr":    true,
		"surge":     true,
		"quanx":     true,
		"loon":      true,
		"surfboard": true,
		"v2ray":     true,
	}
	if !validTargets[target] {
		return fmt.Errorf("unsupported target format: %s, must be one of: clash, clashr, surge, quanx, loon, surfboard, v2ray", r.Target)
	}

	// 验证URL格式
	for _, src := range sources {
		if err := r.validateURL(src, "source URL"); err != nil {
			return err
		}
	}

	// 验证配置URL（如果提供）
	if r.ConfigURL != "" {
		if err := r.validateURL(r.ConfigURL, "config URL"); err != nil {
			return err
		}
	}

	// 验证正则表达式
	if r.Regex != "" {
		if _, err := regexp.Compile(r.Regex); err != nil {
			return fmt.Errorf("invalid regex pattern: %v", err)
		}
	}

	// 验证文件名
	if r.Filename != "" {
		if len(r.Filename) > 255 {
			return fmt.Errorf("filename too long (max 255 characters)")
		}
		if strings.ContainsAny(r.Filename, "\\/:*?\"<>|") {
			return fmt.Errorf("filename contains invalid characters")
		}
	}

	return nil
}

// validateURL 验证URL格式
func (r *ConversionRequest) validateURL(rawURL, fieldName string) error {
	parsedURL, err := url.Parse(rawURL)
	if err != nil {
		return fmt.Errorf("invalid %s: %v", fieldName, err)
	}

	if parsedURL.Scheme == "" {
		return fmt.Errorf("%s must have a scheme (http:// or https://)", fieldName)
	}

	if parsedURL.Scheme != "http" && parsedURL.Scheme != "https" {
		return fmt.Errorf("%s scheme must be http or https, got: %s", fieldName, parsedURL.Scheme)
	}

	if parsedURL.Host == "" {
		return fmt.Errorf("%s must have a host", fieldName)
	}

	return nil
}

// FromQuery 从HTTP查询参数解析转换请求
// 根据查询参数自动填充ConversionRequest字段
func (r *ConversionRequest) FromQuery(query string) error {
	values, err := url.ParseQuery(query)
	if err != nil {
		return fmt.Errorf("failed to parse query: %v", err)
	}

	splitAndTrim := func(input, sep string) []string {
		parts := strings.Split(input, sep)
		out := make([]string, 0, len(parts))
		for _, part := range parts {
			if trimmed := strings.TrimSpace(part); trimmed != "" {
				out = append(out, trimmed)
			}
		}
		return out
	}

	decodeBase64List := func(key, sep string) ([]string, error) {
		raw := values.Get(key)
		if raw == "" {
			return nil, nil
		}
		decoded, err := base64.StdEncoding.DecodeString(raw)
		if err != nil {
			return nil, fmt.Errorf("invalid %s parameter: %v", key, err)
		}
		decodedStr := strings.TrimSpace(string(decoded))
		if decodedStr == "" {
			return []string{}, nil
		}
		return splitAndTrim(decodedStr, sep), nil
	}

	parseBool := func(key string, setter func(bool)) error {
		raw := values.Get(key)
		if raw == "" {
			return nil
		}
		parsed, err := strconv.ParseBool(raw)
		if err != nil {
			return fmt.Errorf("invalid %s parameter: %v", key, err)
		}
		setter(parsed)
		return nil
	}

	// 基本参数
	if target := values.Get("target"); target != "" {
		r.Target = target
	}
	if urlStr := values.Get("url"); urlStr != "" {
		if err := r.SetURL(urlStr); err != nil {
			return err
		}
	}

	// 可选参数
	if configURL := values.Get("config"); configURL != "" {
		r.ConfigURL = configURL
	}
	if err := parseBool("emoji", func(v bool) { r.Emoji = v }); err != nil {
		return err
	}
	if err := parseBool("udp", func(v bool) { r.UDP = v }); err != nil {
		return err
	}
	if err := parseBool("ipv6", func(v bool) { r.IPv6 = v }); err != nil {
		return err
	}
	if group := values.Get("group"); group != "" {
		r.Group = group
	}
	if err := parseBool("insert", func(v bool) { r.Insert = v }); err != nil {
		return err
	}
	if err := parseBool("strict", func(v bool) { r.Strict = v }); err != nil {
		return err
	}
	if err := parseBool("compatible", func(v bool) { r.Compatible = v }); err != nil {
		return err
	}
	if err := parseBool("append_type", func(v bool) { r.AppendType = v }); err != nil {
		return err
	}
	if err := parseBool("tfo", func(v bool) { r.TFO = v }); err != nil {
		return err
	}
	if err := parseBool("script", func(v bool) { r.Script = v }); err != nil {
		return err
	}
	if err := parseBool("scv", func(v bool) { r.SkipCert = v }); err != nil {
		return err
	}
	if err := parseBool("fdn", func(v bool) { r.FilterDeprecated = v }); err != nil {
		return err
	}
	if err := parseBool("expand", func(v bool) { r.ExpandRules = v }); err != nil {
		return err
	}
	if err := parseBool("append_info", func(v bool) { r.AppendInfo = v }); err != nil {
		return err
	}
	if err := parseBool("prepend", func(v bool) { r.Prepend = v }); err != nil {
		return err
	}
	if err := parseBool("classic", func(v bool) { r.Classic = v }); err != nil {
		return err
	}
	if err := parseBool("tls13", func(v bool) { r.TLS13 = v }); err != nil {
		return err
	}
	if err := parseBool("add_emoji", func(v bool) { r.AddEmoji = v }); err != nil {
		return err
	}
	if err := parseBool("remove_emoji", func(v bool) { r.RemoveEmoji = v }); err != nil {
		return err
	}
	if err := parseBool("upload", func(v bool) { r.Upload = v }); err != nil {
		return err
	}

	// 过滤参数
	if include := values.Get("include"); include != "" {
		r.Include = splitAndTrim(include, ",")
	}
	if exclude := values.Get("exclude"); exclude != "" {
		r.Exclude = splitAndTrim(exclude, ",")
	}
	if regex := values.Get("regex"); regex != "" {
		r.Regex = regex
	}
	if location := values.Get("location"); location != "" {
		r.Location = location
	}

	// 高级参数
	if err := parseBool("test", func(v bool) { r.Test = v }); err != nil {
		return err
	}
	if err := parseBool("list", func(v bool) { r.List = v }); err != nil {
		return err
	}
	if filename := values.Get("filename"); filename != "" {
		r.Filename = filename
	}
	if uploadPath := values.Get("upload_path"); uploadPath != "" {
		r.UploadPath = uploadPath
	}
	if rename := values.Get("rename"); rename != "" {
		r.RenameRules = splitAndTrim(rename, "`")
	}
	if filterScript := values.Get("filter_script"); filterScript != "" {
		r.FilterScript = filterScript
	}
	if deviceID := values.Get("dev_id"); deviceID != "" {
		r.DeviceID = deviceID
	}
	if interval := values.Get("interval"); interval != "" {
		r.Interval = interval
	}
	if groups, err := decodeBase64List("groups", "@"); err != nil {
		return err
	} else if groups != nil {
		r.Groups = groups
	}
	if rulesets, err := decodeBase64List("ruleset", "@"); err != nil {
		return err
	} else if rulesets != nil {
		r.Rulesets = rulesets
	}
	if providers, err := decodeBase64List("providers", "@"); err != nil {
		return err
	} else if providers != nil {
		r.Providers = providers
	}
	if emojiRules := values.Get("emoji_rule"); emojiRules != "" {
		r.EmojiRules = splitAndTrim(emojiRules, "`")
	}
	if len(r.EmojiRules) == 0 {
		if emojiRules := values.Get("emoji_rules"); emojiRules != "" {
			r.EmojiRules = splitAndTrim(emojiRules, "`")
		}
	}

	return r.Validate()
}

// FromHTTPRequest 从HTTP请求解析转换请求
// 自动从URL查询参数和请求头中提取转换参数
func (r *ConversionRequest) FromHTTPRequest(req *http.Request) error {
	// 从查询参数解析
	if err := r.FromQuery(req.URL.RawQuery); err != nil {
		return err
	}

	// 从请求头中获取额外的信息
	if userAgent := req.Header.Get("User-Agent"); userAgent != "" {
		// 可以根据User-Agent进行特殊处理
	}

	if accept := req.Header.Get("Accept"); accept != "" {
		// 可以根据Accept头调整输出格式
	}

	return nil
}

// ToQuery 将转换请求转换为查询字符串
// 返回URL编码的查询字符串
func (r *ConversionRequest) ToQuery() string {
	values := url.Values{}

	// 基本参数
	values.Set("target", r.Target)
	values.Set("url", r.SourceSummary())

	// 可选参数
	if r.ConfigURL != "" {
		values.Set("config", r.ConfigURL)
	}
	values.Set("emoji", strconv.FormatBool(r.Emoji))
	values.Set("udp", strconv.FormatBool(r.UDP))
	values.Set("ipv6", strconv.FormatBool(r.IPv6))

	if r.Group != "" {
		values.Set("group", r.Group)
	}
	values.Set("insert", strconv.FormatBool(r.Insert))
	values.Set("strict", strconv.FormatBool(r.Strict))
	values.Set("compatible", strconv.FormatBool(r.Compatible))

	// 过滤参数
	if len(r.Include) > 0 {
		values.Set("include", strings.Join(r.Include, ","))
	}
	if len(r.Exclude) > 0 {
		values.Set("exclude", strings.Join(r.Exclude, ","))
	}
	if r.Regex != "" {
		values.Set("regex", r.Regex)
	}
	if r.Location != "" {
		values.Set("location", r.Location)
	}

	// 高级参数
	values.Set("test", strconv.FormatBool(r.Test))
	values.Set("list", strconv.FormatBool(r.List))
	if r.Filename != "" {
		values.Set("filename", r.Filename)
	}

	return values.Encode()
}

// Clone 创建转换请求的副本
// 返回新的ConversionRequest实例
func (r *ConversionRequest) Clone() *ConversionRequest {
	return &ConversionRequest{
		Target:     r.Target,
		URL:        r.URL,
		RawURL:     r.RawURL,
		Sources:    append([]string{}, r.Sources...),
		ConfigURL:  r.ConfigURL,
		Emoji:      r.Emoji,
		UDP:        r.UDP,
		Group:      r.Group,
		Insert:     r.Insert,
		Strict:     r.Strict,
		Compatible: r.Compatible,
		Include:    append([]string{}, r.Include...),
		Exclude:    append([]string{}, r.Exclude...),
		Regex:      r.Regex,
		Location:   r.Location,
		Test:       r.Test,
		List:       r.List,
		Filename:   r.Filename,
		Providers:  append([]string{}, r.Providers...),
		EmojiRules: append([]string{}, r.EmojiRules...),
	}
}

// CacheSignature returns a canonical representation of the request for caching.
func (r *ConversionRequest) CacheSignature() string {
	sources := r.GetSources()
	signature := struct {
		Target           string   `json:"target"`
		Sources          []string `json:"sources"`
		ConfigURL        string   `json:"config_url"`
		Emoji            bool     `json:"emoji"`
		UDP              bool     `json:"udp"`
		IPv6             bool     `json:"ipv6"`
		Group            string   `json:"group"`
		Insert           bool     `json:"insert"`
		Strict           bool     `json:"strict"`
		Compatible       bool     `json:"compatible"`
		AppendType       bool     `json:"append_type"`
		TFO              bool     `json:"tfo"`
		Script           bool     `json:"script"`
		SkipCert         bool     `json:"skip_cert"`
		FilterDeprecated bool     `json:"filter_deprecated"`
		ExpandRules      bool     `json:"expand_rules"`
		AppendInfo       bool     `json:"append_info"`
		Prepend          bool     `json:"prepend"`
		Classic          bool     `json:"classic"`
		TLS13            bool     `json:"tls13"`
		AddEmoji         bool     `json:"add_emoji"`
		RemoveEmoji      bool     `json:"remove_emoji"`
		Upload           bool     `json:"upload"`
		UploadPath       string   `json:"upload_path"`
		Filename         string   `json:"filename"`
		Test             bool     `json:"test"`
		List             bool     `json:"list"`
		DeviceID         string   `json:"device_id"`
		Interval         string   `json:"interval"`
		Include          []string `json:"include"`
		Exclude          []string `json:"exclude"`
		Regex            string   `json:"regex"`
		Location         string   `json:"location"`
		RenameRules      []string `json:"rename_rules"`
		Groups           []string `json:"groups"`
		Rulesets         []string `json:"rulesets"`
		Providers        []string `json:"providers"`
		EmojiRules       []string `json:"emoji_rules"`
		FilterScript     string   `json:"filter_script"`
		BasePath         string   `json:"base_path"`
	}{
		Target:           strings.ToLower(r.Target),
		Sources:          append([]string{}, sources...),
		ConfigURL:        r.ConfigURL,
		Emoji:            r.Emoji,
		UDP:              r.UDP,
		IPv6:             r.IPv6,
		Group:            r.Group,
		Insert:           r.Insert,
		Strict:           r.Strict,
		Compatible:       r.Compatible,
		AppendType:       r.AppendType,
		TFO:              r.TFO,
		Script:           r.Script,
		SkipCert:         r.SkipCert,
		FilterDeprecated: r.FilterDeprecated,
		ExpandRules:      r.ExpandRules,
		AppendInfo:       r.AppendInfo,
		Prepend:          r.Prepend,
		Classic:          r.Classic,
		TLS13:            r.TLS13,
		AddEmoji:         r.AddEmoji,
		RemoveEmoji:      r.RemoveEmoji,
		Upload:           r.Upload,
		UploadPath:       r.UploadPath,
		Filename:         r.Filename,
		Test:             r.Test,
		List:             r.List,
		DeviceID:         r.DeviceID,
		Interval:         r.Interval,
		Include:          append([]string{}, r.Include...),
		Exclude:          append([]string{}, r.Exclude...),
		Regex:            r.Regex,
		Location:         r.Location,
		RenameRules:      append([]string{}, r.RenameRules...),
		Groups:           append([]string{}, r.Groups...),
		Rulesets:         append([]string{}, r.Rulesets...),
		Providers:        append([]string{}, r.Providers...),
		EmojiRules:       append([]string{}, r.EmojiRules...),
		FilterScript:     r.FilterScript,
		BasePath:         r.BasePath,
	}

	data, err := json.Marshal(signature)
	if err != nil {
		return fmt.Sprintf("%s|%s|%t|%t|%t", signature.Target, r.SourceSummary(), r.AddEmoji, r.RemoveEmoji, r.Upload)
	}
	return string(data)
}

func parseSourcesFromRaw(raw string) ([]string, error) {
	trimmed := strings.TrimSpace(raw)
	if trimmed == "" {
		return nil, nil
	}
	sources := splitSources(trimmed)
	if len(sources) <= 1 {
		if decoded, ok := decodeURLListFromBase64(trimmed); ok {
			sources = splitSources(decoded)
		}
	}
	if len(sources) == 0 && trimmed != "" {
		sources = []string{trimmed}
	}
	return sources, nil
}

func splitSources(input string) []string {
	if input == "" {
		return nil
	}
	normalized := strings.ReplaceAll(input, "\r\n", "\n")
	normalized = strings.ReplaceAll(normalized, "\r", "\n")
	parts := strings.FieldsFunc(normalized, func(r rune) bool {
		switch r {
		case '|', '\n', ',', ';':
			return true
		default:
			return false
		}
	})
	result := make([]string, 0, len(parts))
	for _, part := range parts {
		if trimmed := strings.TrimSpace(part); trimmed != "" {
			result = append(result, trimmed)
		}
	}
	if len(result) == 0 {
		if trimmed := strings.TrimSpace(input); trimmed != "" {
			result = append(result, trimmed)
		}
	}
	return result
}

func decodeURLListFromBase64(raw string) (string, bool) {
	data, ok := decodeBase64String(raw)
	if !ok || len(data) == 0 {
		return "", false
	}
	decoded := strings.TrimSpace(string(data))
	lower := strings.ToLower(decoded)
	if !strings.Contains(lower, "http://") && !strings.Contains(lower, "https://") {
		return "", false
	}
	return decoded, true
}

func decodeBase64String(raw string) ([]byte, bool) {
	s := strings.TrimSpace(raw)
	if s == "" {
		return nil, false
	}
	s = strings.ReplaceAll(s, "\n", "")
	s = strings.ReplaceAll(s, "\r", "")
	if rem := len(s) % 4; rem != 0 {
		s += strings.Repeat("=", 4-rem)
	}
	for _, enc := range []*base64.Encoding{base64.StdEncoding, base64.URLEncoding} {
		decoded, err := enc.DecodeString(s)
		if err == nil && len(decoded) > 0 {
			return decoded, true
		}
	}
	return nil, false
}

// MatchesFilter 检查代理是否匹配过滤条件
// 返回true如果代理匹配所有过滤条件
func (r *ConversionRequest) MatchesFilter(proxyName, proxyLocation string) bool {
	// 检查包含关键词
	for _, include := range r.Include {
		if !strings.Contains(strings.ToLower(proxyName), strings.ToLower(include)) {
			return false
		}
	}

	// 检查排除关键词
	for _, exclude := range r.Exclude {
		if strings.Contains(strings.ToLower(proxyName), strings.ToLower(exclude)) {
			return false
		}
	}

	// 检查正则表达式
	if r.Regex != "" {
		if matched, err := regexp.MatchString(r.Regex, proxyName); err != nil || !matched {
			return false
		}
	}

	// 检查地区
	if r.Location != "" && proxyLocation != "" {
		if !strings.EqualFold(proxyLocation, r.Location) {
			return false
		}
	}

	return true
}

// GetOutputFilename 获取输出文件名
// 根据配置生成合适的输出文件名
func (r *ConversionRequest) GetOutputFilename() string {
	if r.Filename != "" {
		// 确保有正确的扩展名
		if !strings.HasSuffix(r.Filename, "."+r.GetFileExtension()) {
			return r.Filename + "." + r.GetFileExtension()
		}
		return r.Filename
	}

	// 生成默认文件名
	defaultName := "converted"
	if r.Group != "" {
		defaultName = r.Group
	}

	return fmt.Sprintf("%s.%s", defaultName, r.GetFileExtension())
}

// GetFileExtension 获取目标格式的文件扩展名
// 返回对应格式的文件扩展名
func (r *ConversionRequest) GetFileExtension() string {
	switch strings.ToLower(r.Target) {
	case "clash":
		return "yaml"
	case "surge":
		return "conf"
	case "quanx":
		return "conf"
	case "loon":
		return "conf"
	case "surfboard":
		return "conf"
	case "v2ray":
		return "json"
	default:
		return "txt"
	}
}

// GetContentType 获取响应的Content-Type
// 返回适合目标格式的MIME类型
func (r *ConversionRequest) GetContentType() string {
	if r.List {
		return "text/plain; charset=utf-8"
	}
	switch strings.ToLower(r.Target) {
	case "clash":
		return "text/yaml; charset=utf-8"
	case "surge", "quanx", "loon", "surfboard":
		return "text/plain; charset=utf-8"
	case "v2ray":
		return "application/json; charset=utf-8"
	default:
		return "text/plain; charset=utf-8"
	}
}

// IsCompatible 检查是否与C++版本兼容
// 返回true如果使用兼容模式
func (r *ConversionRequest) IsCompatible() bool {
	return r.Compatible
}

// ShouldIncludeTests 检查是否应该包含测试信息
// 返回true如果启用了测试模式
func (r *ConversionRequest) ShouldIncludeTests() bool {
	return r.Test
}

// ShouldShowList 检查是否应该显示列表
// 返回true如果是列表模式
func (r *ConversionRequest) ShouldShowList() bool {
	return r.List
}

// ShouldInsertURLTest 检查是否应该插入URL测试
// 返回true如果启用了插入URL测试
func (r *ConversionRequest) ShouldInsertURLTest() bool {
	return r.Insert
}

// IsStrictMode 检查是否是严格模式
// 返回true如果启用了严格模式
func (r *ConversionRequest) IsStrictMode() bool {
	return r.Strict
}