// cmd/slack-cli/main.go
package main

import (
    "fmt"
    "os"
    
    "github.com/piekstra/slack-cli/internal/cmd/root"
)

func main() {
    cmd := root.NewCmdRoot()
    if err := cmd.Execute(); err != nil {
        fmt.Fprintf(os.Stderr, "Error: %s\n", err)
        os.Exit(1)
    }
}

var listCmd = &cobra.Command{
    Use: "list",
    RunE: func(cmd *cobra.Command, args []string) error {
        types, _ := cmd.Flags().GetString("types")
        // ... inline logic
    },
}

func init() {
    channelsCmd.AddCommand(listCmd)
    listCmd.Flags().String("types", "", "...")
}

type listOptions struct {
    types           string
    excludeArchived bool
    limit           int
    output          string
    noColor         bool
}

func NewCmdList() *cobra.Command {
    opts := &listOptions{}
    
    cmd := &cobra.Command{
        Use:   "list",
        Short: "List all channels",
        Long:  `List all channels in the workspace with optional filtering.`,
        Example: `  # List all public channels
  slack-cli channels list
  
  # List only private channels
  slack-cli channels list --types=private_channel
  
  # Output as JSON for scripting
  slack-cli channels list -o json | jq '.[].name'`,
        RunE: func(cmd *cobra.Command, args []string) error {
            opts.output, _ = cmd.Flags().GetString("output")
            opts.noColor, _ = cmd.Flags().GetBool("no-color")
            return runList(opts, nil)
        },
    }
    
    cmd.Flags().StringVar(&opts.types, "types", "", "Channel types: public_channel,private_channel,mpim,im")
    cmd.Flags().BoolVar(&opts.excludeArchived, "exclude-archived", true, "Exclude archived channels")
    cmd.Flags().IntVar(&opts.limit, "limit", 100, "Maximum channels to return")
    
    return cmd
}

func runList(opts *listOptions, c *client.Client) error {
    // Create client if not injected (for testing)
    if c == nil {
        var err error
        c, err = client.New()
        if err != nil {
            return err
        }
    }
    
    channels, err := c.ListChannels(opts.types, opts.excludeArchived, opts.limit)
    if err != nil {
        return fmt.Errorf("failed to list channels: %w", err)
    }
    
    renderer := view.NewRenderer(view.Format(opts.output), opts.noColor)
    // ... render output
}

// internal/config/config.go
package config

import (
    "errors"
    "fmt"
    "os"
    "path/filepath"
    
    "gopkg.in/yaml.v3"
)

type Config struct {
    APIToken       string `yaml:"api_token,omitempty"`
    DefaultChannel string `yaml:"default_channel,omitempty"`
    OutputFormat   string `yaml:"output_format,omitempty"` // table, json, plain
    NoColor        bool   `yaml:"no_color,omitempty"`
}

func (c *Config) Validate() error {
    // Token can come from keychain or env, so not required in file
    return nil
}

func (c *Config) LoadFromEnv() {
    if token := os.Getenv("SLACK_API_TOKEN"); token != "" {
        c.APIToken = token
    }
    if os.Getenv("NO_COLOR") != "" {
        c.NoColor = true
    }
}

func DefaultConfigPath() string {
    if xdgConfig := os.Getenv("XDG_CONFIG_HOME"); xdgConfig != "" {
        return filepath.Join(xdgConfig, "slack-cli", "config.yml")
    }
    home, _ := os.UserHomeDir()
    return filepath.Join(home, ".config", "slack-cli", "config.yml")
}

func Load(path string) (*Config, error) {
    data, err := os.ReadFile(path)
    if err != nil {
        if os.IsNotExist(err) {
            return &Config{}, nil // Return empty config if file doesn't exist
        }
        return nil, fmt.Errorf("failed to read config: %w", err)
    }
    
    var cfg Config
    if err := yaml.Unmarshal(data, &cfg); err != nil {
        return nil, fmt.Errorf("failed to parse config: %w", err)
    }
    return &cfg, nil
}

func (c *Config) Save(path string) error {
    dir := filepath.Dir(path)
    if err := os.MkdirAll(dir, 0755); err != nil {
        return fmt.Errorf("failed to create config directory: %w", err)
    }
    
    data, err := yaml.Marshal(c)
    if err != nil {
        return fmt.Errorf("failed to marshal config: %w", err)
    }
    
    if err := os.WriteFile(path, data, 0600); err != nil {
        return fmt.Errorf("failed to write config: %w", err)
    }
    return nil
}

func LoadWithEnv(path string) (*Config, error) {
    cfg, err := Load(path)
    if err != nil {
        return nil, err
    }
    cfg.LoadFromEnv()
    return cfg, nil
}