backend/frpAct.go

package main

import (
	"database/sql"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"net/http"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
	"super-frpc/postLog"
	"time"

	"gopkg.in/ini.v1"
)

type InstanceInfo struct {
	Name       string `json:"name"`
	ServerAddr string `json:"serverAddr"`
	ServerPort string `json:"serverPort"`
	AuthMethod string `json:"auth_method"`
	// BootAtStart bool                   `json:"bootAtStart"`
	RunUser    string                 `json:"runUser"`
	Additional map[string]interface{} `json:"additionalProperties"`
}

type FrpcProxyInfo struct {
	Name       string `json:"name"`
	Type       string `json:"type"`
	LocalIP    string `json:"local_ip"`
	LocalPort  string `json:"local_port"`
	RemotePort string `json:"remote_port"`
}

type CreateInstanceRequest struct {
	InstanceInfo InstanceInfo           `json:"instanceInfo"`
	BootAtStart  bool                   `json:"bootAtStart"`
	RunUser      string                 `json:"runUser"`
	Additional   map[string]interface{} `json:"additionalProperties"`
}

type FrpcInstance struct {
	ID          int
	UserID      int
	Name        string
	ServerAddr  string
	ServerPort  string
	AuthMethod  string
	BootAtStart bool
	RunUser     string
	ConfigPath  string
	CreatedAt   time.Time
}

var frpcDB *sql.DB

func CloseFrpcDatabase() error {
	if frpcDB != nil {
		return frpcDB.Close()
	}
	return nil
}

func CreateInstanceHandler(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		SendErrorResponse(w, http.StatusMethodNotAllowed, "Invalid request method")
		postLog.Debug(fmt.Sprintf("[CreateInstanceHandler] Invalid request method: %s", r.Method))
		return
	}

	body, err := io.ReadAll(r.Body)
	if err != nil {
		postLog.Error(fmt.Sprintf("[CreateInstanceHandler] Failed to read request body: %v", err))
		SendErrorResponse(w, http.StatusBadRequest, "Failed to read request body")
		return
	}
	defer r.Body.Close()

	// 先解析为map，处理类型不匹配的情况
	var reqMap map[string]interface{}
	if err := json.Unmarshal(body, &reqMap); err != nil {
		postLog.Error(fmt.Sprintf("[CreateInstanceHandler] Failed to unmarshal request body: %v", err))
		SendErrorResponse(w, http.StatusBadRequest, "Invalid request format")
		return
	}

	// 处理bootAtStart字段
	bootAtStart := false
	if bas, ok := reqMap["bootAtStart"]; ok {
		switch v := bas.(type) {
		case bool:
			bootAtStart = v
		case string:
			if v == "true" {
				bootAtStart = true
			}
		}
	}

	// 处理instanceInfo字段
	instanceInfoMap, ok := reqMap["instanceInfo"].(map[string]interface{})
	if !ok {
		SendErrorResponse(w, http.StatusBadRequest, "Invalid instanceInfo format")
		return
	}

	instanceInfo := InstanceInfo{
		Name:       getStringFromMap(instanceInfoMap, "name"),
		ServerAddr: getStringFromMap(instanceInfoMap, "serverAddr"),
		ServerPort: getStringFromMap(instanceInfoMap, "serverPort"),
		AuthMethod: getStringFromMap(instanceInfoMap, "auth_method"),
		RunUser:    getStringFromMap(reqMap, "runUser"),
	}

	// 处理additionalProperties字段
	if additional, ok := reqMap["additionalProperties"].(map[string]interface{}); ok {
		instanceInfo.Additional = additional
	}

	// 从Header中验证token和timeStamp
	userID, _, err := ValidateRequestWithHeader(w, r)
	if err != nil {
		postLog.Error(fmt.Sprintf("[CreateInstanceHandler] Failed to validate request header: %v", err))
		SendErrorResponse(w, http.StatusUnauthorized, err.Error())
		return
	}

	// 构建请求结构体
	req := CreateInstanceRequest{
		InstanceInfo: instanceInfo,
		BootAtStart:  bootAtStart,
		RunUser:      instanceInfo.RunUser,
		Additional:   instanceInfo.Additional,
	}

	if err := CheckPermission(userID, "superuser", "admin"); err != nil {
		postLog.Error(fmt.Sprintf("[CreateInstanceHandler] Failed to check permission: %v", err))
		SendErrorResponse(w, http.StatusForbidden, err.Error())
		return
	}

	if req.InstanceInfo.Name == "" || req.InstanceInfo.ServerAddr == "" ||
		req.InstanceInfo.ServerPort == "" || req.InstanceInfo.AuthMethod == "" {
		SendErrorResponse(w, http.StatusBadRequest, "Missing required fields in instanceInfo")
		return
	}

	runUser := req.RunUser
	if runUser == "" {
		runUser = "root"
	}

	user, err := GetUserByID(userID)
	if err != nil {
		postLog.Error(fmt.Sprintf("[CreateInstanceHandler] Failed to get user info: %v", err))
		SendErrorResponse(w, http.StatusInternalServerError, "Failed to get user info")
		return
	}

	configDir, err := GetConfigDir()
	if err != nil {
		postLog.Error(fmt.Sprintf("[CreateInstanceHandler] Failed to get config directory: %v", err))
		SendErrorResponse(w, http.StatusInternalServerError, "Failed to get config directory")
		return
	}

	// Add frpc instance
	configFileName := fmt.Sprintf("superfrpc_%s_%s.toml", user.Username, req.InstanceInfo.Name)
	configPath := filepath.Join(configDir, configFileName)

	configContent := generateFrpcConfig(req.InstanceInfo)
	if err := os.WriteFile(configPath, []byte(configContent), 0644); err != nil {
		postLog.Error(fmt.Sprintf("[CreateInstanceHandler] Failed to create config file %s: %v", configPath, err))
		SendErrorResponse(w, http.StatusInternalServerError, "Failed to create config file")
		return
	}

	instance := FrpcInstance{
		UserID:      userID,
		Name:        req.InstanceInfo.Name,
		ServerAddr:  req.InstanceInfo.ServerAddr,
		ServerPort:  req.InstanceInfo.ServerPort,
		AuthMethod:  req.InstanceInfo.AuthMethod,
		BootAtStart: req.BootAtStart,
		RunUser:     runUser,
		ConfigPath:  configPath,
	}

	if err := DBAddFrpcInstance(instance); err != nil {
		os.Remove(configPath)
		postLog.Error(fmt.Sprintf("[CreateInstanceHandler] Failed to save instance %s to database: %v", req.InstanceInfo.Name, err))
		SendErrorResponse(w, http.StatusInternalServerError, "Failed to save instance to database")
		return
	}

	if req.BootAtStart {
		if err := createBootService(user.Username, req.InstanceInfo.Name, configPath, runUser); err != nil {
			frpcDB.Exec("DELETE FROM frpcInstances WHERE userID = ? AND name = ?", userID, req.InstanceInfo.Name)
			os.Remove(configPath)
			postLog.Error(fmt.Sprintf("[CreateInstanceHandler] Failed to create boot service for instance %s: %v", req.InstanceInfo.Name, err))
			SendErrorResponse(w, http.StatusInternalServerError, "Failed to create boot service")
			return
		}
	}
	// Finish add frpc instance

	SendSuccessResponse(w, "Instance created successfully", map[string]interface{}{
		"name":        req.InstanceInfo.Name,
		"configPath":  configPath,
		"bootAtStart": req.BootAtStart,
	})
	postLog.Info(fmt.Sprintf("[CreateInstanceHandler] Instance %s created successfully: configPath=%s, bootAtStart=%v, runUser=%s, additionalProperties=%v", req.InstanceInfo.Name, configPath, req.BootAtStart, runUser, req.Additional))
}

func DeleteInstanceHandler(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		SendErrorResponse(w, http.StatusMethodNotAllowed, "Invalid request method")
		return
	}

	body, err := io.ReadAll(r.Body)
	if err != nil {
		postLog.Error(fmt.Sprintf("[DeleteInstanceHandler] Failed to read request body: %v", err))
		SendErrorResponse(w, http.StatusBadRequest, "Failed to read request body")
		return
	}
	defer r.Body.Close()

	var reqMap map[string]interface{}
	if err := json.Unmarshal(body, &reqMap); err != nil {
		postLog.Error(fmt.Sprintf("[DeleteInstanceHandler] Failed to unmarshal request body: %v", err))
		SendErrorResponse(w, http.StatusBadRequest, "Invalid request format")
		return
	}

	instanceName := getStringFromMap(reqMap, "instanceName")
	if instanceName == "" {
		SendErrorResponse(w, http.StatusBadRequest, "instanceName is required")
		return
	}

	userID, _, err := ValidateRequestWithHeader(w, r)
	if err != nil {
		postLog.Error(fmt.Sprintf("[DeleteInstanceHandler] Failed to validate request header: %v", err))
		SendErrorResponse(w, http.StatusUnauthorized, err.Error())
		return
	}

	if err := CheckPermission(userID, "superuser", "admin"); err != nil {
		postLog.Error(fmt.Sprintf("[DeleteInstanceHandler] Failed to check permission: %v", err))
		SendErrorResponse(w, http.StatusForbidden, err.Error())
		return
	}

	user, err := GetUserByID(userID)
	if err != nil {
		postLog.Error(fmt.Sprintf("[DeleteInstanceHandler] Failed to get user info: %v", err))
		SendErrorResponse(w, http.StatusInternalServerError, "Failed to get user info")
		return
	}

	var instance FrpcInstance
	// err = frpcDB.QueryRow(`
	// 	SELECT id, userID, name, serverAddr, serverPort, auth_method, bootAtStart, runUser, configPath, createdAt
	// 	FROM frpcInstances WHERE userID = ? AND name = ?
	// `, userID, instanceName).Scan(
	// 	&instance.ID, &instance.UserID, &instance.Name, &instance.ServerAddr, &instance.ServerPort,
	// 	&instance.AuthMethod, &instance.BootAtStart, &instance.RunUser, &instance.ConfigPath, &instance.CreatedAt)
	instance, err = DBQueryFrpcInstance(userID, instanceName)
	if err == sql.ErrNoRows {
		SendErrorResponse(w, http.StatusNotFound, "Instance not found")
		postLog.Error(fmt.Sprintf("[DeleteInstanceHandler] User %d tried to delete a not existed instance: %s", userID, instanceName))
		return
	}
	if err != nil {
		postLog.Error(fmt.Sprintf("[DeleteInstanceHandler] Failed to query instance: %v", err))
		SendErrorResponse(w, http.StatusInternalServerError, "Failed to query instance")
		return
	}

	if instance.BootAtStart {
		if err := removeBootService(user.Username, instanceName); err != nil {
			postLog.Error(fmt.Sprintf("[DeleteInstanceHandler] Failed to remove boot service for instance %s: %v", instanceName, err))
			SendErrorResponse(w, http.StatusInternalServerError, "Failed to remove boot service")
			return
		}
	}

	if _, err := os.Stat(instance.ConfigPath); err == nil {
		if err := os.Remove(instance.ConfigPath); err != nil {
			postLog.Error(fmt.Sprintf("[DeleteInstanceHandler] Failed to remove config file %s: %v", instance.ConfigPath, err))
			SendErrorResponse(w, http.StatusInternalServerError, "Failed to remove config file")
			return
		}
	}

	if err := DBRemoveFrpcInstance(userID, instanceName); err != nil {
		postLog.Error(fmt.Sprintf("[DeleteInstanceHandler] Failed to delete instance %s from database: %v", instanceName, err))
		SendErrorResponse(w, http.StatusInternalServerError, "Failed to delete instance from database")
		return
	}

	SendSuccessResponse(w, "Instance deleted successfully", map[string]interface{}{
		"name": instanceName,
	})
	postLog.Info(fmt.Sprintf("[DeleteInstanceHandler] Instance %s deleted successfully", instanceName))
}

func ModifyInstanceHandler(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		postLog.Error(fmt.Sprintf("[ModifyInstanceHandler] Invalid request method: %s", r.Method))
		SendErrorResponse(w, http.StatusMethodNotAllowed, "Invalid request method")
		return
	}

	body, err := io.ReadAll(r.Body)
	if err != nil {
		postLog.Error(fmt.Sprintf("[ModifyInstanceHandler] Failed to read request body: %v", err))
		SendErrorResponse(w, http.StatusBadRequest, "Failed to read request body")
		return
	}
	defer r.Body.Close()

	var reqMap map[string]interface{}
	if err := json.Unmarshal(body, &reqMap); err != nil {
		postLog.Error(fmt.Sprintf("[ModifyInstanceHandler] Failed to unmarshal request body: %v", err))
		SendErrorResponse(w, http.StatusBadRequest, "Invalid request format")
		return
	}

	instanceName := getStringFromMap(reqMap, "instanceName")
	if instanceName == "" {
		SendErrorResponse(w, http.StatusBadRequest, "instanceName is required")
		return
	}

	instanceID := getStringFromMap(reqMap, "instanceID")
	if instanceID == "" {
		SendErrorResponse(w, http.StatusBadRequest, "instanceID is required")
		return
	}

	modifyType := getStringFromMap(reqMap, "type")
	if modifyType == "" {
		SendErrorResponse(w, http.StatusBadRequest, "type is required")
		return
	}

	if modifyType != "configFile" && modifyType != "systemConfig" { // Detect valid modify type
		SendErrorResponse(w, http.StatusBadRequest, fmt.Sprintf("Unknown modify type %s", modifyType))
		return
	}

	modifiedData, ok := reqMap["modifiedData"].(map[string]interface{})
	if !ok || modifiedData == nil {
		SendErrorResponse(w, http.StatusBadRequest, "modifiedData is required and must be an object")
		return
	}

	// 从Header中验证token和timeStamp
	userID, _, err := ValidateRequestWithHeader(w, r)
	if err != nil {
		postLog.Error(fmt.Sprintf("[ModifyInstanceHandler] Failed to validate request header: %v", err))
		SendErrorResponse(w, http.StatusUnauthorized, err.Error())
		return
	}

	if err := CheckPermission(userID, "superuser", "admin"); err != nil {
		postLog.Error(fmt.Sprintf("[ModifyInstanceHandler] Failed to check permission: %v", err))
		SendErrorResponse(w, http.StatusForbidden, err.Error())
		return
	}

	user, err := GetUserByID(userID)
	if err != nil {
		postLog.Error(fmt.Sprintf("[ModifyInstanceHandler] Failed to get user info: %v", err))
		SendErrorResponse(w, http.StatusInternalServerError, "Failed to get user info")
		return
	}

	instance, err := DBQueryFrpcInstance(userID, instanceName)
	if err == sql.ErrNoRows {
		postLog.Error(fmt.Sprintf("[ModifyInstanceHandler] User %d tried to modify a not existed instance: %s", userID, instanceName))
		SendErrorResponse(w, http.StatusNotFound, "Instance not found")
		return
	}
	if err != nil {
		postLog.Error(fmt.Sprintf("[ModifyInstanceHandler] Failed to query instance: %v", err))
		SendErrorResponse(w, http.StatusInternalServerError, "Failed to query instance")
		return
	}

	// 验证 instanceID 是否匹配
	if fmt.Sprintf("%d", instance.ID) != instanceID {
		SendErrorResponse(w, http.StatusBadRequest, "instanceID does not match instanceName")
		return
	}

	if modifyType == "configFile" {
		handleConfigFileModify(w, instance, modifiedData, user.Username)
	} else {
		handleSystemConfigModify(w, r, instance, modifiedData, user)
	}
}

func handleConfigFileModify(w http.ResponseWriter, instance FrpcInstance, modifiedData map[string]interface{}, username string) {
	configPath := instance.ConfigPath

	// Read current config file content
	configContent, err := os.ReadFile(configPath)
	if err != nil {
		postLog.Error(fmt.Sprintf("[handleConfigFileModify] Failed to read config file %s: %v", configPath, err))
		SendErrorResponse(w, http.StatusInternalServerError, "Failed to read config file")
		return
	}

	// Parse config file content
	updatedConfig, err := updateCommonSection(string(configContent), modifiedData)
	if err != nil {
		postLog.Error(fmt.Sprintf("[handleConfigFileModify] Failed to update common section: %v", err))
		SendErrorResponse(w, http.StatusInternalServerError, "Failed to update config file")
		return
	}

	// Write updated config file content back to file
	if err := os.WriteFile(configPath, []byte(updatedConfig), 0644); err != nil {
		postLog.Error(fmt.Sprintf("[handleConfigFileModify] Failed to write config file %s: %v", configPath, err))
		SendErrorResponse(w, http.StatusInternalServerError, "Failed to write config file")
		return
	}

	// Update instance fields in database
	if v, ok := modifiedData["server_addr"].(string); ok && v != "" {
		instance.ServerAddr = v
	}
	if v, ok := modifiedData["server_port"].(string); ok && v != "" {
		instance.ServerPort = v
	}
	if v, ok := modifiedData["auth_method"].(string); ok && v != "" {
		instance.AuthMethod = v
	}

	if err := DBUpdateFrpcInstance(instance); err != nil {
		postLog.Error(fmt.Sprintf("[handleConfigFileModify] Failed to update instance in database: %v", err))
		SendErrorResponse(w, http.StatusInternalServerError, "Failed to update instance in database")
		return
	}

	SendSuccessResponse(w, "Config file modified successfully", map[string]interface{}{
		"instanceName": instance.Name,
		"instanceID":   instance.ID,
		"configPath":   configPath,
	})
	postLog.Info(fmt.Sprintf("[handleConfigFileModify] Config file for instance %s modified successfully", instance.Name))
}

func updateCommonSection(configContent string, modifiedData map[string]interface{}) (string, error) {
	cfg, err := ini.Load([]byte(configContent))
	if err != nil {
		return "", fmt.Errorf("failed to parse config: %w", err)
	}

	commonSection := cfg.Section("common")
	if commonSection == nil {
		return "", fmt.Errorf("common section not found")
	}

	for key, value := range modifiedData {
		commonSection.Key(key).SetValue(formatConfigValue(value))
	}

	var buf strings.Builder
	if _, err := cfg.WriteTo(&buf); err != nil {
		return "", fmt.Errorf("failed to write config: %w", err)
	}

	return buf.String(), nil
}

func formatConfigValue(value interface{}) string {
	switch v := value.(type) {
	case string:
		return v
	case bool:
		return fmt.Sprintf("%t", v)
	case float64:
		if v == float64(int64(v)) {
			return fmt.Sprintf("%d", int64(v))
		}
		return fmt.Sprintf("%f", v)
	default:
		return fmt.Sprintf("%v", v)
	}
}

func handleSystemConfigModify(w http.ResponseWriter, r *http.Request, instance FrpcInstance, modifiedData map[string]interface{}, user *User) {
	newName := instance.Name
	newRunUser := instance.RunUser
	newBootAtStart := instance.BootAtStart
	oldBootAtStart := instance.BootAtStart
	var bootServiceError string

	if v, ok := modifiedData["name"].(string); ok && v != "" {
		newName = v
	}
	if v, ok := modifiedData["runUser"].(string); ok {
		newRunUser = v
	}
	if v, ok := modifiedData["bootAtStart"].(bool); ok {
		newBootAtStart = v
	}

	oldConfigPath := instance.ConfigPath
	var newConfigPath string

	// If instance name or run user changed, need to rename config file
	if newName != instance.Name || newRunUser != instance.RunUser {
		configDir, err := GetConfigDir()
		if err != nil {
			postLog.Error(fmt.Sprintf("[handleSystemConfigModify] Failed to get config directory: %v", err))
			SendErrorResponse(w, http.StatusInternalServerError, "Failed to get config directory")
			return
		}

		newConfigFileName := fmt.Sprintf("superfrpc_%s_%s.toml", user.Username, newName)
		newConfigPath = filepath.Join(configDir, newConfigFileName)

		if oldConfigPath != newConfigPath {
			if _, err := os.Stat(oldConfigPath); err == nil {
				if err := os.Rename(oldConfigPath, newConfigPath); err != nil {
					postLog.Error(fmt.Sprintf("[handleSystemConfigModify] Failed to rename config file %s to %s: %v", oldConfigPath, newConfigPath, err))
					SendErrorResponse(w, http.StatusInternalServerError, "Failed to rename config file")
					return
				}
			}
		}
	} else {
		newConfigPath = oldConfigPath
	}

	// Update instance fields in database
	instance.Name = newName
	instance.RunUser = newRunUser
	instance.BootAtStart = newBootAtStart
	instance.ConfigPath = newConfigPath

	if err := DBUpdateFrpcInstance(instance); err != nil {
		postLog.Error(fmt.Sprintf("[handleSystemConfigModify] Failed to update instance in database: %v", err))
		SendErrorResponse(w, http.StatusInternalServerError, "Failed to update instance in database")
		return
	}

	// Handle boot service creation and removal
	if oldBootAtStart && !newBootAtStart {
		if err := removeBootService(user.Username, instance.Name); err != nil {
			postLog.Error(fmt.Sprintf("[handleSystemConfigModify] Failed to remove boot service: %v", err))
			bootServiceError = fmt.Sprintf("Failed to remove boot service: %v", err)
		}
	} else if !oldBootAtStart && newBootAtStart {
		if err := createBootService(user.Username, newName, newConfigPath, newRunUser); err != nil {
			postLog.Error(fmt.Sprintf("[handleSystemConfigModify] Failed to create boot service: %v", err))
			bootServiceError = fmt.Sprintf("Failed to create boot service: %v", err)
		}
	} else if oldBootAtStart && newBootAtStart && (instance.Name != newName || instance.RunUser != newRunUser) {
		if err := removeBootService(user.Username, instance.Name); err != nil {
			postLog.Error(fmt.Sprintf("[handleSystemConfigModify] Failed to remove old boot service: %v", err))
			bootServiceError = fmt.Sprintf("Failed to remove old boot service: %v", err)
		}
		if err := createBootService(user.Username, newName, newConfigPath, newRunUser); err != nil {
			postLog.Error(fmt.Sprintf("[handleSystemConfigModify] Failed to create new boot service: %v", err))
			if bootServiceError != "" {
				bootServiceError += "; "
			}
			bootServiceError += fmt.Sprintf("Failed to create new boot service: %v", err)
		}
	}

	data := map[string]interface{}{
		"instanceName": newName,
		"instanceID":   instance.ID,
		"configPath":   newConfigPath,
		"bootAtStart":  newBootAtStart,
		"runUser":      newRunUser,
	}
	if bootServiceError != "" {
		data["bootServiceError"] = bootServiceError
	}
	SendSuccessResponse(w, "System config modified successfully", data)
	postLog.Info(fmt.Sprintf("[handleSystemConfigModify] System config for instance %s modified successfully: bootAtStart=%v, runUser=%s", newName, newBootAtStart, newRunUser))
}

func ListInstancesHandler(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodGet {
		SendErrorResponse(w, http.StatusMethodNotAllowed, "Invalid request method")
		return
	}

	userID, _, err := ValidateRequestWithHeader(w, r)
	if err != nil {
		postLog.Error(fmt.Sprintf("[ListInstancesHandler] Failed to validate request: %v", err))
		SendErrorResponse(w, http.StatusUnauthorized, "Failed to validate request")
		return
	}

	userType, err := GetUserType(userID)
	if err != nil {
		postLog.Error(fmt.Sprintf("[ListInstancesHandler] Failed to get user type: %v", err))
		SendErrorResponse(w, http.StatusInternalServerError, "Failed to get user type")
		return
	}

	// rows, err := frpcDB.Query(`
	// 	SELECT id, userID, name, serverAddr, serverPort, auth_method, bootAtStart, runUser, configPath, createdAt
	// 	FROM frpcInstances WHERE userID = ?
	// `, userID)
	instanceList, err := DBListFrpcInstances(userID)
	if err != nil {
		postLog.Error(fmt.Sprintf("[ListInstancesHandler] Failed to query instances: %v", err))
		SendErrorResponse(w, http.StatusInternalServerError, "Failed to query instances")
		return
	}

	var responseInstances []map[string]interface{}
	for _, instance := range instanceList {
		instanceData := map[string]interface{}{
			"instanceID":  instance.ID,
			"name":        instance.Name,
			"serverAddr":  instance.ServerAddr,
			"serverPort":  instance.ServerPort,
			"auth_method": instance.AuthMethod,
			"bootAtStart": instance.BootAtStart,
			"runUser":     instance.RunUser,
			"configPath":  instance.ConfigPath,
			"createdAt":   instance.CreatedAt,
		}

		if userType == "visitor" {
			delete(instanceData, "serverAddr")
			delete(instanceData, "serverPort")
			delete(instanceData, "auth_method")
		}

		responseInstances = append(responseInstances, instanceData)
	}

	if responseInstances == nil {
		responseInstances = []map[string]interface{}{}
	}

	SendSuccessResponse(w, "Instances retrieved successfully", responseInstances)
}

func generateFrpcConfig(info InstanceInfo) string {
	var sb strings.Builder
	sb.WriteString("[common]\n")
	sb.WriteString(fmt.Sprintf("server_addr = %s\n", info.ServerAddr))
	sb.WriteString(fmt.Sprintf("server_port = %s\n", info.ServerPort))
	sb.WriteString(fmt.Sprintf("auth_method = %s\n", info.AuthMethod))

	for key, value := range info.Additional {
		sb.WriteString(fmt.Sprintf("%s = %v\n", key, value))
	}

	return sb.String()
}

func addFrpcProxy(info FrpcProxyInfo) string {
	var sb strings.Builder
	sb.WriteString("[[proxies]]\n")
	sb.WriteString(fmt.Sprintf("name = %s\n", info.Name))
	sb.WriteString(fmt.Sprintf("type = %s\n", info.Type))
	sb.WriteString(fmt.Sprintf("local_ip = %s\n", info.LocalIP))
	sb.WriteString(fmt.Sprintf("local_port = %s\n", info.LocalPort))
	sb.WriteString(fmt.Sprintf("remote_port = %s\n", info.RemotePort))

	return sb.String()
}

func GetConfigDir() (string, error) {
	config, err := GetConfig()
	if err != nil {
		postLog.Error(fmt.Sprintf("[GetConfigDir] Failed to get config: %v", err))
		return "", err
	}
	return config.InstancePath, nil
}

func GetFrpcPath() (string, error) {
	config, err := GetConfig()
	if err != nil {
		postLog.Error(fmt.Sprintf("[GetFrpcPath] Failed to get config: %v", err))
		return "", err
	}
	return config.FrpcPath, nil
}

func detectInitSystem() string {
	if _, err := os.Stat("/run/systemd/system"); err == nil {
		return "systemd"
	}
	if _, err := os.Stat("/etc/init.d"); err == nil {
		return "init.d"
	}
	return "unknown"
}

func createBootService(username, instanceName, configPath, runUser string) error {
	initSystem := detectInitSystem()

	switch initSystem {
	case "systemd":
		return createSystemdService(username, instanceName, configPath, runUser)
	case "init.d":
		return createInitDService(username, instanceName, configPath, runUser)
	default:
		return errors.New("unsupported init system")
	}
}

func createSystemdService(username, instanceName, configPath, runUser string) error {
	frpcPath, err := GetFrpcPath()
	if err != nil {
		return err
	}

	serviceName := fmt.Sprintf("superfrpc_%s_%s", username, instanceName)
	serviceContent := fmt.Sprintf(`[Unit]
Description=superfrpc_%s_%s
After=network.target

[Service]
Type=simple
ExecStart=%s -c %s
User=%s
Restart=on-failure
RestartSec=5

[Install]
WantedBy=multi-user.target
`, username, instanceName, frpcPath, configPath, runUser)

	servicePath := filepath.Join("/etc/systemd/system", serviceName+".service")
	if err := os.WriteFile(servicePath, []byte(serviceContent), 0644); err != nil {
		return fmt.Errorf("failed to create systemd service file: %w", err)
	}

	cmd := exec.Command("systemctl", "enable", serviceName)
	if output, err := cmd.CombinedOutput(); err != nil {
		os.Remove(servicePath)
		return fmt.Errorf("failed to enable service: %s, output: %s", err, output)
	}

	cmd = exec.Command("systemctl", "daemon-reload")
	if output, err := cmd.CombinedOutput(); err != nil {
		return fmt.Errorf("failed to reload daemon: %s, output: %s", err, output)
	}

	return nil
}

func createInitDService(username, instanceName, configPath, runUser string) error {
	frpcPath, err := GetFrpcPath()
	if err != nil {
		return err
	}

	serviceName := fmt.Sprintf("superfrpc_%s_%s", username, instanceName)

	var serviceContent string
	runUserArg := ""
	if runUser != "" && runUser != "root" {
		runUserArg = runUser
		serviceContent = fmt.Sprintf(`#!/bin/sh

### BEGIN INIT INFO
# Provides:          %s
# Required-Start:    $network $remote_fs $syslog
# Required-Stop:     $network $remote_fs $syslog
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Description:       superfrpc %s %s
### END INIT INFO

NAME="%s"
PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
DAEMON=%s
DAEMON_ARGS="-c %s"
SCRIPTNAME=/etc/init.d/$NAME
USER=%s

[ -x "$DAEMON" ] || exit 0

case "$1" in
  start)
        echo -n "Starting $NAME: "
        start-stop-daemon -S -c $USER -b -m -p /var/run/$NAME.pid --start --exec $DAEMON -- $DAEMON_ARGS
        echo "$NAME."
        ;;
  stop)
        echo -n "Stopping $NAME: "
        start-stop-daemon -K -p /var/run/$NAME.pid
        rm -f /var/run/$NAME.pid
        echo "$NAME."
        ;;
  restart)
        $0 stop
        $0 start
        ;;
  status)
        if [ -f /var/run/$NAME.pid ]; then
            echo "$NAME is running (pid $(cat /var/run/$NAME.pid))"
        else
            echo "$NAME is not running"
        fi
        ;;
  *)
        echo "Usage: $SCRIPTNAME {start|stop|restart|status}"
        exit 1
        ;;
esac

exit 0
`, serviceName, username, instanceName, serviceName, frpcPath, configPath, runUserArg)
	} else {
		serviceContent = fmt.Sprintf(`#!/bin/sh

### BEGIN INIT INFO
# Provides:          %s
# Required-Start:    $network $remote_fs $syslog
# Required-Stop:     $network $remote_fs $syslog
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Description:       superfrpc %s %s
### END INIT INFO

NAME="%s"
PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
DAEMON=%s
DAEMON_ARGS="-c %s"
SCRIPTNAME=/etc/init.d/$NAME

[ -x "$DAEMON" ] || exit 0

case "$1" in
  start)
        echo -n "Starting $NAME: "
        start-stop-daemon -S -b -m -p /var/run/$NAME.pid --start --exec $DAEMON -- $DAEMON_ARGS
        echo "$NAME."
        ;;
  stop)
        echo -n "Stopping $NAME: "
        start-stop-daemon -K -p /var/run/$NAME.pid
        rm -f /var/run/$NAME.pid
        echo "$NAME."
        ;;
  restart)
        $0 stop
        $0 start
        ;;
  status)
        if [ -f /var/run/$NAME.pid ]; then
            echo "$NAME is running (pid $(cat /var/run/$NAME.pid))"
        else
            echo "$NAME is not running"
        fi
        ;;
  *)
        echo "Usage: $SCRIPTNAME {start|stop|restart|status}"
        exit 1
        ;;
esac

exit 0
`, serviceName, username, instanceName, serviceName, frpcPath, configPath)
	}

	servicePath := filepath.Join("/etc/init.d", serviceName)
	if err := os.WriteFile(servicePath, []byte(serviceContent), 0755); err != nil {
		return fmt.Errorf("failed to create init.d service file: %w", err)
	}

	cmd := exec.Command("/etc/init.d", serviceName, "enable")
	if output, err := cmd.CombinedOutput(); err != nil {
		os.Remove(servicePath)
		return fmt.Errorf("failed to enable service: %s, output: %s", err, output)
	}

	return nil
}

func removeBootService(username, instanceName string) error {
	initSystem := detectInitSystem()

	serviceName := fmt.Sprintf("superfrpc_%s_%s", username, instanceName)

	switch initSystem {
	case "systemd":
		cmd := exec.Command("systemctl", "disable", serviceName)
		cmd.CombinedOutput()

		servicePath := filepath.Join("/etc/systemd/system", serviceName+".service")
		os.Remove(servicePath)

		cmd = exec.Command("systemctl", "daemon-reload")
		cmd.CombinedOutput()

	case "init.d":
		cmd := exec.Command("/etc/init.d", serviceName, "disable")
		cmd.CombinedOutput()

		servicePath := filepath.Join("/etc/init.d", serviceName)
		os.Remove(servicePath)
	}

	return nil
}

func GetUserInstances(userID int) ([]FrpcInstance, error) {
	rows, err := frpcDB.Query(`
		SELECT id, userID, name, serverAddr, serverPort, auth_method, bootAtStart, runUser, configPath, createdAt
		FROM frpcInstances WHERE userID = ?
	`, userID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()

	var instances []FrpcInstance
	for rows.Next() {
		var instance FrpcInstance
		var createdAtStr string
		if err := rows.Scan(
			&instance.ID, &instance.UserID, &instance.Name, &instance.ServerAddr, &instance.ServerPort,
			&instance.AuthMethod, &instance.BootAtStart, &instance.RunUser, &instance.ConfigPath, &createdAtStr,
		); err != nil {
			return nil, err
		}
		instance.CreatedAt, _ = time.Parse(time.RFC3339, createdAtStr)
		instances = append(instances, instance)
	}

	return instances, nil
}

func getStringFromMap(m map[string]interface{}, key string) string {
	if v, ok := m[key].(string); ok {
		return v
	}
	return ""
}