system

var HighlightCode = func(language string, code string) (string, error) {

	lexer := lexers.Get(language)
	if lexer == nil {
		lexer = lexers.Analyse(code)
		if lexer == nil {
			lexer = lexers.Fallback
		}
	}

	style := styles.Get("monokai")
	if style == nil {
		style = styles.Fallback
	}

	formatter := formatters.Get("terminal256")
	if formatter == nil {
		formatter = formatters.Fallback
	}

	iterator, err := lexer.Tokenise(nil, code)
	if err != nil {
		return "", fmt.Errorf("error tokenizing code: %w", err)
	}

	// Format the code into a string buffer
	var buf bytes.Buffer
	err = formatter.Format(&buf, style, iterator)
	if err != nil {
		return "", fmt.Errorf("error formatting code: %w", err)
	}

	return buf.String(), nil
}

var TmuxCapturePane = func(paneId string, maxLines int) (string, error) {
	cmd := exec.Command("tmux", "capture-pane", "-p", "-t", paneId, "-S", fmt.Sprintf("-%d", maxLines))
	var stdout, stderr bytes.Buffer
	cmd.Stdout = &stdout
	cmd.Stderr = &stderr

	err := cmd.Run()
	if err != nil {
		logger.Error("Failed to capture pane content from %s: %v, stderr: %s", paneId, err, stderr.String())
		return "", err
	}

	content := strings.TrimSpace(stdout.String())
	return content, nil
}

var TmuxCurrentPaneId = func() (string, error) {
	tmuxPane := os.Getenv("TMUX_PANE")
	if tmuxPane == "" {
		return "", fmt.Errorf("TMUX_PANE environment variable not set")
	}

	return tmuxPane, nil
}

var TmuxPanesDetails = func(target string) ([]TmuxPaneDetails, error) {
	cmd := exec.Command("tmux", "list-panes", "-t", target, "-F", "#{pane_id},#{pane_active},#{pane_pid},#{pane_current_command},#{history_size},#{history_limit}")
	var stdout, stderr bytes.Buffer
	cmd.Stdout = &stdout
	cmd.Stderr = &stderr

	err := cmd.Run()
	if err != nil {
		logger.Error("Failed to get tmux pane details for target %s %v, stderr: %s", target, err, stderr.String())
		return nil, err
	}

	output := strings.TrimSpace(stdout.String())
	if output == "" {
		return nil, fmt.Errorf("no pane details found for target %s", target)
	}

	lines := strings.Split(output, "\n")
	paneDetails := make([]TmuxPaneDetails, 0, len(lines))

	for _, line := range lines {
		line = strings.TrimSpace(line)
		if line == "" {
			continue
		}

		parts := strings.SplitN(line, ",", 6)
		if len(parts) < 5 {
			logger.Error("Invalid pane details format for line: %s", line)
			continue
		}

		id := parts[0]

		if strings.HasPrefix(target, "%") && id != target {
			continue
		}

		active, _ := strconv.Atoi(parts[1])
		pid, _ := strconv.Atoi(parts[2])
		historySize, _ := strconv.Atoi(parts[4])
		historyLimit, _ := strconv.Atoi(parts[5])
		currentCommandArgs := GetProcessArgs(pid)
		isSubShell := IsSubShell(parts[3])

		paneDetail := TmuxPaneDetails{
			Id:                 id,
			IsActive:           active,
			CurrentPid:         pid,
			CurrentCommand:     parts[3],
			CurrentCommandArgs: currentCommandArgs,
			HistorySize:        historySize,
			HistoryLimit:       historyLimit,
			IsSubShell:         isSubShell,
		}

		paneDetails = append(paneDetails, paneDetail)
	}

	return paneDetails, nil
}

var TmuxSendCommandToPane = func(paneId string, command string, autoenter bool) error {
	lines := strings.Split(command, "\n")
	for i, line := range lines {

		if line != "" {
			if !containsSpecialKey(line) {

				if strings.HasSuffix(line, ";") {
					line = line[:len(line)-1] + "\\;"
				}
				cmd := exec.Command("tmux", "send-keys", "-t", paneId, "-l", line)
				var stderr bytes.Buffer
				cmd.Stderr = &stderr
				err := cmd.Run()
				if err != nil {
					logger.Error("Failed to send command to pane %s: %v, stderr: %s", paneId, err, stderr.String())
					return fmt.Errorf("failed to send command to pane: %w", err)
				}

			} else {
				args := []string{"send-keys", "-t", paneId}
				processed := processLineWithSpecialKeys(line)
				args = append(args, processed...)
				cmd := exec.Command("tmux", args...)
				var stderr bytes.Buffer
				cmd.Stderr = &stderr
				err := cmd.Run()
				if err != nil {
					logger.Error("Failed to send command with special keys to pane %s: %v, stderr: %s", paneId, err, stderr.String())
					return fmt.Errorf("failed to send command with special keys to pane: %w", err)
				}
			}
		}

		if autoenter {
			if i < len(lines)-1 || (i == len(lines)-1 && line != "") {
				enterCmd := exec.Command("tmux", "send-keys", "-t", paneId, "Enter")
				err := enterCmd.Run()
				if err != nil {
					logger.Error("Failed to send Enter key to pane %s: %v", paneId, err)
					return fmt.Errorf("failed to send Enter key to pane: %w", err)
				}
			}
		}
	}
	return nil
}