// Output 输出结果（根据配置选择 JSON 或文本模式）
func Output(data interface{}) error {
    if config.Get().JSON {
        return OutputJSON(data)
    }
    return nil
}

// OutputJSON 以 JSON 格式输出
func OutputJSON(data interface{}) error {
    encoder := json.NewEncoder(os.Stdout)
    encoder.SetIndent("", "  ")
    return encoder.Encode(data)
}

// OutputText 以文本格式输出
func OutputText(format string, args ...interface{}) {
    if !config.Get().JSON {
        fmt.Printf(format, args...)
    }
}

// OutputLine 输出一行文本
func OutputLine(line string) {
    if !config.Get().JSON {
        fmt.Println(line)
    }
}

// OutputTable 输出表格（自动计算列宽）
func OutputTable(headers []string, rows [][]string) {
    if config.Get().JSON {
        // JSON 模式：转换为 map 数组
        data := make([]map[string]string, len(rows))
        // ... 转换逻辑
        _ = OutputJSON(data)
        return
    }

    // 文本模式：计算列宽并对齐
    colWidths := make([]int, len(headers))
    for i, h := range headers {
        colWidths[i] = len(h)
    }
    // ... 计算每列最大宽度

    // 输出表头
    headerLine := ""
    for i, h := range headers {
        headerLine += fmt.Sprintf("%-*s ", colWidths[i], h)
    }
    fmt.Println(headerLine)
    fmt.Println(strings.Repeat("-", len(headerLine)))

    // 输出数据行
    for _, row := range rows {
        rowLine := ""
        for i, cell := range row {
            if i < len(colWidths) {
                rowLine += fmt.Sprintf("%-*s ", colWidths[i], cell)
            }
        }
        fmt.Println(rowLine)
    }
}

# 文本模式
$ oho formatter status
格式化器状态:
✅ prettier (状态：running)
❌ eslint (状态：stopped)

# JSON 模式
$ oho formatter status -j
[
  {
    "name": "prettier",
    "status": "running"
  },
  {
    "name": "eslint", 
    "status": "stopped"
  }
]

// cmd/formatter/formatter.go
icon := "❌"
if s.Status == "running" {
    icon = "✅"
}
fmt.Printf("%s %s (状态：%s)\n", icon, s.Name, s.Status)

// cmd/session/session.go - statusCmd
fmt.Printf("%s: %s (就绪：%v, 工作中：%v)\n", 
    id, s.Status, s.IsReady, s.IsWorking)

// cmd/session/session.go - todoCmd
for _, todo := range todos {
    status := "☐"
    if todo.Status == "completed" {
        status = "☑"
    }
    fmt.Printf("%s %s\n", status, todo.Content)
}

// internal/client/client.go
// 1. 超时错误（用户友好建议）
if strings.Contains(err.Error(), "context deadline exceeded") {
    return nil, fmt.Errorf("请求超时（%d 秒）\n\n建议:\n  1. 使用 --no-reply 参数避免等待\n  2. 设置环境变量增加超时：export OPENCODE_CLIENT_TIMEOUT=600\n  3. 使用异步命令：oho message prompt-async -s <session-id> \"任务\"", c.timeoutSec)
}

// 2. 认证错误（详细配置指导）
if resp.StatusCode == 401 {
    return nil, fmt.Errorf("认证失败 [401]: 用户名或密码错误\n\n请配置认证信息，选择以下任一方式:\n  1. 环境变量 (推荐):\n     export OPENCODE_SERVER_HOST=127.0.0.1\n     export OPENCODE_SERVER_PORT=4096\n     export OPENCODE_SERVER_USERNAME=opencode\n     export OPENCODE_SERVER_PASSWORD=your-password\n  ...")
}

// 3. 通用 API 错误
return nil, fmt.Errorf("API 错误 [%d]: %s", resp.StatusCode, string(respBody))

// cmd/main.go
if err := config.Init(); err != nil {
    fmt.Fprintf(os.Stderr, "警告：配置初始化失败：%v\n", err)
}

// internal/client/client.go
// SSEStream 服务器发送事件流
func (c *Client) SSEStream(ctx context.Context, path string) (<-chan []byte, <-chan error, error) {
    req, err := http.NewRequestWithContext(ctx, http.MethodGet, c.baseURL+path, nil)
    // ... 认证和请求头设置
    req.Header.Set("Accept", "text/event-stream")
    req.Header.Set("Cache-Control", "no-cache")

    resp, err := c.httpClient.Do(req)
    // ... 错误处理

    eventChan := make(chan []byte)
    errChan := make(chan error, 1)

    go func() {
        defer close(eventChan)
        defer close(errChan)
        defer resp.Body.Close()

        buf := make([]byte, 4096)
        for {
            select {
            case <-ctx.Done():
                return
            default:
                n, err := resp.Body.Read(buf)
                if n > 0 {
                    data := make([]byte, n)
                    copy(data, buf[:n])
                    eventChan <- data
                }
                if err != nil {
                    if err != io.EOF {
                        errChan <- err
                    }
                    return
                }
            }
        }
    }()

    return eventChan, errChan, nil
}

// cmd/global/global.go
var eventCmd = &cobra.Command{
    Use:   "event",
    Short: "监听全局事件流 (SSE)",
    RunE: func(cmd *cobra.Command, args []string) error {
        c := client.NewClient()
        ctx := context.Background()

        eventChan, errChan, err := c.SSEStream(ctx, "/global/event")
        if err != nil {
            return err
        }

        fmt.Println("正在监听全局事件... (Ctrl+C 停止)")

        for {
            select {
            case event, ok := <-eventChan:
                if !ok {
                    return nil
                }
                fmt.Printf("%s", event)
            case err, ok := <-errChan:
                if ok && err != nil {
                    return err
                }
            case <-ctx.Done():
                return nil
            }
        }
    },
}

// 格式化动词
fmt.Printf("会话 ID: %s\n", session.ID)
fmt.Printf("状态：%s (就绪：%v, 工作中：%v)\n", status, isReady, isWorking)
fmt.Printf("共 %d 个会话:\n\n", len(sessions))

// 表格对齐
fmt.Sprintf("%-*s ", colWidths[i], header)  // 左对齐，宽度固定
fmt.Sprintf("%-*s ", colWidths[i], cell)

// internal/util/output.go
func Truncate(s string, maxLen int) string {
    if len(s) <= maxLen {
        return s
    }
    return s[:maxLen-3] + "..."
}

// internal/util/output.go
func Pluralize(count int, singular, plural string) string {
    if count == 1 {
        return singular
    }
    return plural
}

// cmd/tui/tui.go
var Cmd = &cobra.Command{
    Use:   "tui",
    Short: "TUI 控制命令",
    Long:  "控制 TUI 界面行为",
}

// types.TUIToastRequest
type TUIToastRequest struct {
    Title   string `json:"title,omitempty"`
    Message string `json:"message"`
    Variant string `json:"variant"`  // "info"/"warning"/"error"/"success"
}

// showToastCmd 示例
// oho tui show-toast --title "提示" --message "操作成功" --variant success

// internal/util/output.go
func Confirm(prompt string) bool {
    if config.Get().JSON {
        return true  // JSON 模式跳过确认
    }

    fmt.Printf("%s [y/N]: ", prompt)
    var response string
    _, _ = fmt.Scanln(&response)
    return strings.ToLower(response) == "y" || strings.ToLower(response) == "yes"
}

// cmd/message/message.go
for _, msg := range messages {
    fmt.Printf("\n[%s] %s\n", msg.Info.Role, msg.Info.ID)
    if msg.Info.Content != "" {
        fmt.Printf("%s\n", msg.Info.Content)
    }
    for _, part := range msg.Parts {
        fmt.Printf("  └─ 部分类型：%s\n", part.Type)
    }
    fmt.Println("---")
}

fmt.Printf("消息详情:\n")
fmt.Printf("  ID: %s\n", result.Info.ID)
fmt.Printf("  会话：%s\n", result.Info.SessionID)
fmt.Printf("  角色：%s\n", result.Info.Role)
fmt.Printf("  时间：%d\n", result.Info.CreatedAt)

if result.Info.Content != "" {
    fmt.Printf("\n内容:\n%s\n", result.Info.Content)
}

fmt.Printf("\n部分 (%d 个):\n", len(result.Parts))
for i, part := range result.Parts {
    fmt.Printf("  %d. 类型：%s\n", i+1, part.Type)
}

// internal/config/config.go
func Init() error {
    // 1. 默认值（最低优先级）
    cfg = &Config{
        Host:     "127.0.0.1",
        Port:     4096,
        Username: "opencode",
        Password: "",
        JSON:     false,
    }

    // 2. 配置文件（中等优先级）
    // 3. 环境变量（高优先级）
    // 4. 命令行标志（最高优先级）
}

// cmd/main.go
rootCmd.PersistentFlags().BoolP("json", "j", false, "以 JSON 格式输出")

// 使用示例
oho session list -j                    # JSON 输出
oho session list --json               # JSON 输出
oho session list                       # 文本输出（默认）