// internal/view/view.go
package view

import (
    "encoding/json"
    "fmt"
    "io"
    "os"
    "strings"
    
    "github.com/fatih/color"
)

type Format string

const (
    FormatTable Format = "table"
    FormatJSON  Format = "json"
    FormatPlain Format = "plain"
)

func ValidateFormat(format string) error {
    switch format {
    case "", string(FormatTable), string(FormatJSON), string(FormatPlain):
        return nil
    default:
        return fmt.Errorf("invalid output format: %q (valid: table, json, plain)", format)
    }
}

type Renderer struct {
    format  Format
    writer  io.Writer
    noColor bool
}

func NewRenderer(format Format, noColor bool) *Renderer {
    if noColor {
        color.NoColor = true
    }
    if format == "" {
        format = FormatTable
    }
    return &Renderer{
        format:  format,
        writer:  os.Stdout,
        noColor: noColor,
    }
}

func (r *Renderer) SetWriter(w io.Writer) {
    r.writer = w
}

func (r *Renderer) RenderTable(headers []string, rows [][]string) {
    switch r.format {
    case FormatJSON:
        r.renderTableAsJSON(headers, rows)
    case FormatPlain:
        r.renderTableAsPlain(rows)
    default:
        r.renderTableAsTable(headers, rows)
    }
}

func (r *Renderer) renderTableAsTable(headers []string, rows [][]string) {
    // Calculate column widths
    widths := make([]int, len(headers))
    for i, h := range headers {
        widths[i] = len(h)
    }
    for _, row := range rows {
        for i, cell := range row {
            if i < len(widths) && len(cell) > widths[i] {
                widths[i] = len(cell)
            }
        }
    }
    
    // Print headers
    for i, h := range headers {
        fmt.Fprintf(r.writer, "%-*s  ", widths[i], h)
    }
    fmt.Fprintln(r.writer)
    
    // Print separator
    for i, w := range widths {
        fmt.Fprintf(r.writer, "%s", strings.Repeat("-", w))
        if i < len(widths)-1 {
            fmt.Fprint(r.writer, "  ")
        }
    }
    fmt.Fprintln(r.writer)
    
    // Print rows
    for _, row := range rows {
        for i, cell := range row {
            if i < len(widths) {
                fmt.Fprintf(r.writer, "%-*s  ", widths[i], cell)
            }
        }
        fmt.Fprintln(r.writer)
    }
}

// Design decision: Plain format uses tabs for easy parsing with cut/awk
func (r *Renderer) renderTableAsPlain(rows [][]string) {
    for _, row := range rows {
        fmt.Fprintln(r.writer, strings.Join(row, "\t"))
    }
}

func (r *Renderer) renderTableAsJSON(headers []string, rows [][]string) {
    result := make([]map[string]string, len(rows))
    for i, row := range rows {
        item := make(map[string]string)
        for j, cell := range row {
            if j < len(headers) {
                item[strings.ToLower(headers[j])] = cell
            }
        }
        result[i] = item
    }
    r.RenderJSON(result)
}

func (r *Renderer) RenderJSON(v interface{}) error {
    data, err := json.MarshalIndent(v, "", "  ")
    if err != nil {
        return err
    }
    fmt.Fprintln(r.writer, string(data))
    return nil
}

func (r *Renderer) Success(msg string) {
    green := color.New(color.FgGreen)
    green.Fprintln(r.writer, "✓ "+msg)
}

func (r *Renderer) Error(msg string) {
    red := color.New(color.FgRed)
    red.Fprintln(r.writer, "✗ "+msg)
}

func (r *Renderer) Info(msg string) {
    fmt.Fprintln(r.writer, msg)
}

// internal/cmd/root/root.go
func NewCmdRoot() *cobra.Command {
    cmd := &cobra.Command{...}
    
    // Global flags
    cmd.PersistentFlags().StringP("output", "o", "table", "Output format: table, json, plain")
    cmd.PersistentFlags().Bool("no-color", false, "Disable colored output")
    cmd.PersistentFlags().StringP("config", "c", "", "Config file (default: ~/.config/slack-cli/config.yml)")
    
    return cmd
}

func runArchive(channelID string, opts *archiveOptions, c *client.Client) error {
    if err := c.ArchiveChannel(channelID); err != nil {
        return fmt.Errorf("failed to archive channel: %w", err)
    }
    
    renderer := view.NewRenderer(view.Format(opts.output), opts.noColor)
    
    if opts.output == "json" {
        return renderer.RenderJSON(map[string]string{
            "status":     "archived",
            "channel_id": channelID,
        })
    }
    
    renderer.Success(fmt.Sprintf("Archived channel: %s", channelID))
    return nil
}

func runList(opts *listOptions, c *client.Client) error {
    noColor := opts.noColor
    if os.Getenv("NO_COLOR") != "" {
        noColor = true
    }
    
    renderer := view.NewRenderer(view.Format(opts.output), noColor)
    // ...
}