chat/cmd/chat-cli/main.go

// Package main implements chat-cli, an IRC-style terminal client.
package main

import (
	"fmt"
	"os"
	"strconv"
	"strings"
	"sync"
	"time"

	api "git.eeqj.de/sneak/chat/cmd/chat-cli/api"
)

const (
	pollTimeoutSec = 15
	retryDelay     = 2 * time.Second
	maxNickLength  = 32
)

// App holds the application state.
type App struct {
	ui     *UI
	client *api.Client

	mu        sync.Mutex
	nick      string
	target    string // current target (#channel or nick for DM)
	connected bool
	lastMsgID string
	stopPoll  chan struct{}
}

func main() {
	app := &App{
		ui:   NewUI(),
		nick: "guest",
	}

	app.ui.OnInput(app.handleInput)
	app.ui.SetStatus(app.nick, "", "disconnected")

	app.ui.AddStatus(
		"Welcome to chat-cli \u2014 an IRC-style client",
	)
	app.ui.AddStatus(
		"Type [yellow]/connect <server-url>[white] " +
			"to begin, or [yellow]/help[white] for commands",
	)

	err := app.ui.Run()
	if err != nil {
		_, _ = fmt.Fprintf(os.Stderr, "Error: %v\n", err)

		os.Exit(1)
	}
}

func (a *App) handleInput(text string) {
	if strings.HasPrefix(text, "/") {
		a.handleCommand(text)

		return
	}

	a.sendPlainText(text)
}

func (a *App) sendPlainText(text string) {
	a.mu.Lock()
	target := a.target
	connected := a.connected
	nick := a.nick
	a.mu.Unlock()

	if !connected {
		a.ui.AddStatus(
			"[red]Not connected. Use /connect <url>",
		)

		return
	}

	if target == "" {
		a.ui.AddStatus(
			"[red]No target. " +
				"Use /join #channel or /query nick",
		)

		return
	}

	err := a.client.SendMessage(&api.Message{
		Command: "PRIVMSG",
		To:      target,
		Body:    []string{text},
	})
	if err != nil {
		a.ui.AddStatus(
			fmt.Sprintf("[red]Send error: %v", err),
		)

		return
	}

	ts := time.Now().Format("15:04")

	a.ui.AddLine(
		target,
		fmt.Sprintf(
			"[gray]%s [green]<%s>[white] %s",
			ts, nick, text,
		),
	)
}

func (a *App) handleCommand(text string) { //nolint:cyclop // command dispatch
	parts := strings.SplitN(text, " ", 2) //nolint:mnd // split into cmd+args
	cmd := strings.ToLower(parts[0])

	args := ""
	if len(parts) > 1 {
		args = parts[1]
	}

	switch cmd {
	case "/connect":
		a.cmdConnect(args)
	case "/nick":
		a.cmdNick(args)
	case "/join":
		a.cmdJoin(args)
	case "/part":
		a.cmdPart(args)
	case "/msg":
		a.cmdMsg(args)
	case "/query":
		a.cmdQuery(args)
	case "/topic":
		a.cmdTopic(args)
	case "/names":
		a.cmdNames()
	case "/list":
		a.cmdList()
	case "/window", "/w":
		a.cmdWindow(args)
	case "/quit":
		a.cmdQuit()
	case "/help":
		a.cmdHelp()
	default:
		a.ui.AddStatus(
			"[red]Unknown command: " + cmd,
		)
	}
}

func (a *App) cmdConnect(serverURL string) {
	if serverURL == "" {
		a.ui.AddStatus(
			"[red]Usage: /connect <server-url>",
		)

		return
	}

	serverURL = strings.TrimRight(serverURL, "/")

	a.ui.AddStatus(
		fmt.Sprintf("Connecting to %s...", serverURL),
	)

	a.mu.Lock()
	nick := a.nick
	a.mu.Unlock()

	client := api.NewClient(serverURL)

	resp, err := client.CreateSession(nick)
	if err != nil {
		a.ui.AddStatus(
			fmt.Sprintf(
				"[red]Connection failed: %v", err,
			),
		)

		return
	}

	a.mu.Lock()
	a.client = client
	a.nick = resp.Nick
	a.connected = true
	a.lastMsgID = ""
	a.mu.Unlock()

	a.ui.AddStatus(
		fmt.Sprintf(
			"[green]Connected! Nick: %s, Session: %s",
			resp.Nick, resp.SessionID,
		),
	)
	a.ui.SetStatus(resp.Nick, "", "connected")

	a.stopPoll = make(chan struct{})

	go a.pollLoop()
}

func (a *App) cmdNick(nick string) {
	if nick == "" {
		a.ui.AddStatus("[red]Usage: /nick <name>")

		return
	}

	a.mu.Lock()
	connected := a.connected
	a.mu.Unlock()

	if !connected {
		a.mu.Lock()
		a.nick = nick
		a.mu.Unlock()

		a.ui.AddStatus(
			fmt.Sprintf(
				"Nick set to %s (will be used on connect)",
				nick,
			),
		)

		return
	}

	err := a.client.SendMessage(&api.Message{
		Command: "NICK",
		Body:    []string{nick},
	})
	if err != nil {
		a.ui.AddStatus(
			fmt.Sprintf(
				"[red]Nick change failed: %v", err,
			),
		)

		return
	}

	a.mu.Lock()
	a.nick = nick
	target := a.target
	a.mu.Unlock()

	a.ui.SetStatus(nick, target, "connected")
	a.ui.AddStatus(
		"Nick changed to " + nick,
	)
}

func (a *App) cmdJoin(channel string) {
	if channel == "" {
		a.ui.AddStatus("[red]Usage: /join #channel")

		return
	}

	if !strings.HasPrefix(channel, "#") {
		channel = "#" + channel
	}

	a.mu.Lock()
	connected := a.connected
	a.mu.Unlock()

	if !connected {
		a.ui.AddStatus("[red]Not connected")

		return
	}

	err := a.client.JoinChannel(channel)
	if err != nil {
		a.ui.AddStatus(
			fmt.Sprintf("[red]Join failed: %v", err),
		)

		return
	}

	a.mu.Lock()
	a.target = channel
	nick := a.nick
	a.mu.Unlock()

	a.ui.SwitchToBuffer(channel)
	a.ui.AddLine(
		channel,
		"[yellow]*** Joined "+channel,
	)
	a.ui.SetStatus(nick, channel, "connected")
}

func (a *App) cmdPart(channel string) {
	a.mu.Lock()

	if channel == "" {
		channel = a.target
	}

	connected := a.connected
	a.mu.Unlock()

	if channel == "" || !strings.HasPrefix(channel, "#") {
		a.ui.AddStatus("[red]No channel to part")

		return
	}

	if !connected {
		a.ui.AddStatus("[red]Not connected")

		return
	}

	err := a.client.PartChannel(channel)
	if err != nil {
		a.ui.AddStatus(
			fmt.Sprintf("[red]Part failed: %v", err),
		)

		return
	}

	a.ui.AddLine(
		channel,
		"[yellow]*** Left "+channel,
	)

	a.mu.Lock()

	if a.target == channel {
		a.target = ""
	}

	nick := a.nick
	a.mu.Unlock()

	a.ui.SwitchBuffer(0)
	a.ui.SetStatus(nick, "", "connected")
}

func (a *App) cmdMsg(args string) {
	parts := strings.SplitN(args, " ", 2) //nolint:mnd // split into target+text
	if len(parts) < 2 {                   //nolint:mnd // min args
		a.ui.AddStatus("[red]Usage: /msg <nick> <text>")

		return
	}

	target, text := parts[0], parts[1]

	a.mu.Lock()
	connected := a.connected
	nick := a.nick
	a.mu.Unlock()

	if !connected {
		a.ui.AddStatus("[red]Not connected")

		return
	}

	err := a.client.SendMessage(&api.Message{
		Command: "PRIVMSG",
		To:      target,
		Body:    []string{text},
	})
	if err != nil {
		a.ui.AddStatus(
			fmt.Sprintf("[red]Send failed: %v", err),
		)

		return
	}

	ts := time.Now().Format("15:04")

	a.ui.AddLine(
		target,
		fmt.Sprintf(
			"[gray]%s [green]<%s>[white] %s",
			ts, nick, text,
		),
	)
}

func (a *App) cmdQuery(nick string) {
	if nick == "" {
		a.ui.AddStatus("[red]Usage: /query <nick>")

		return
	}

	a.mu.Lock()
	a.target = nick
	myNick := a.nick
	a.mu.Unlock()

	a.ui.SwitchToBuffer(nick)
	a.ui.SetStatus(myNick, nick, "connected")
}

func (a *App) cmdTopic(args string) {
	a.mu.Lock()
	target := a.target
	connected := a.connected
	a.mu.Unlock()

	if !connected {
		a.ui.AddStatus("[red]Not connected")

		return
	}

	if !strings.HasPrefix(target, "#") {
		a.ui.AddStatus("[red]Not in a channel")

		return
	}

	if args == "" {
		err := a.client.SendMessage(&api.Message{
			Command: "TOPIC",
			To:      target,
		})
		if err != nil {
			a.ui.AddStatus(
				fmt.Sprintf(
					"[red]Topic query failed: %v", err,
				),
			)
		}

		return
	}

	err := a.client.SendMessage(&api.Message{
		Command: "TOPIC",
		To:      target,
		Body:    []string{args},
	})
	if err != nil {
		a.ui.AddStatus(
			fmt.Sprintf(
				"[red]Topic set failed: %v", err,
			),
		)
	}
}

func (a *App) cmdNames() {
	a.mu.Lock()
	target := a.target
	connected := a.connected
	a.mu.Unlock()

	if !connected {
		a.ui.AddStatus("[red]Not connected")

		return
	}

	if !strings.HasPrefix(target, "#") {
		a.ui.AddStatus("[red]Not in a channel")

		return
	}

	members, err := a.client.GetMembers(target)
	if err != nil {
		a.ui.AddStatus(
			fmt.Sprintf("[red]Names failed: %v", err),
		)

		return
	}

	a.ui.AddLine(
		target,
		fmt.Sprintf(
			"[cyan]*** Members of %s: %s",
			target, strings.Join(members, " "),
		),
	)
}

func (a *App) cmdList() {
	a.mu.Lock()
	connected := a.connected
	a.mu.Unlock()

	if !connected {
		a.ui.AddStatus("[red]Not connected")

		return
	}

	channels, err := a.client.ListChannels()
	if err != nil {
		a.ui.AddStatus(
			fmt.Sprintf("[red]List failed: %v", err),
		)

		return
	}

	a.ui.AddStatus("[cyan]*** Channel list:")

	for _, ch := range channels {
		a.ui.AddStatus(
			fmt.Sprintf(
				"  %s (%d members) %s",
				ch.Name, ch.Members, ch.Topic,
			),
		)
	}

	a.ui.AddStatus("[cyan]*** End of channel list")
}

func (a *App) cmdWindow(args string) {
	if args == "" {
		a.ui.AddStatus("[red]Usage: /window <number>")

		return
	}

	n, _ := strconv.Atoi(args)
	a.ui.SwitchBuffer(n)

	a.mu.Lock()
	nick := a.nick
	a.mu.Unlock()

	if n >= 0 && n < a.ui.BufferCount() {
		buf := a.ui.buffers[n]

		if buf.Name != "(status)" {
			a.mu.Lock()
			a.target = buf.Name
			a.mu.Unlock()

			a.ui.SetStatus(nick, buf.Name, "connected")
		} else {
			a.ui.SetStatus(nick, "", "connected")
		}
	}
}

func (a *App) cmdQuit() {
	a.mu.Lock()

	if a.connected && a.client != nil {
		_ = a.client.SendMessage(
			&api.Message{Command: "QUIT"},
		)
	}

	if a.stopPoll != nil {
		close(a.stopPoll)
	}

	a.mu.Unlock()
	a.ui.Stop()
}

func (a *App) cmdHelp() {
	help := []string{
		"[cyan]*** chat-cli commands:",
		"  /connect <url>  \u2014 Connect to server",
		"  /nick <name>    \u2014 Change nickname",
		"  /join #channel  \u2014 Join channel",
		"  /part [#chan]    \u2014 Leave channel",
		"  /msg <nick> <text> \u2014 Send DM",
		"  /query <nick>   \u2014 Open DM window",
		"  /topic [text]   \u2014 View/set topic",
		"  /names          \u2014 List channel members",
		"  /list           \u2014 List channels",
		"  /window <n>     \u2014 Switch buffer (Alt+0-9)",
		"  /quit           \u2014 Disconnect and exit",
		"  /help           \u2014 This help",
		"  Plain text sends to current target.",
	}

	for _, line := range help {
		a.ui.AddStatus(line)
	}
}

// pollLoop long-polls for messages in the background.
func (a *App) pollLoop() {
	for {
		select {
		case <-a.stopPoll:
			return
		default:
		}

		a.mu.Lock()
		client := a.client
		lastID := a.lastMsgID
		a.mu.Unlock()

		if client == nil {
			return
		}

		msgs, err := client.PollMessages(
			lastID, pollTimeoutSec,
		)
		if err != nil {
			time.Sleep(retryDelay)

			continue
		}

		for i := range msgs {
			a.handleServerMessage(&msgs[i])

			if msgs[i].ID != "" {
				a.mu.Lock()
				a.lastMsgID = msgs[i].ID
				a.mu.Unlock()
			}
		}
	}
}

func (a *App) handleServerMessage(
	msg *api.Message,
) {
	ts := a.parseMessageTS(msg)

	a.mu.Lock()
	myNick := a.nick
	a.mu.Unlock()

	switch msg.Command {
	case "PRIVMSG":
		a.handlePrivmsgMsg(msg, ts, myNick)
	case "JOIN":
		a.handleJoinMsg(msg, ts)
	case "PART":
		a.handlePartMsg(msg, ts)
	case "QUIT":
		a.handleQuitMsg(msg, ts)
	case "NICK":
		a.handleNickMsg(msg, ts, myNick)
	case "NOTICE":
		a.handleNoticeMsg(msg, ts)
	case "TOPIC":
		a.handleTopicMsg(msg, ts)
	default:
		a.handleDefaultMsg(msg, ts)
	}
}

func (a *App) parseMessageTS(msg *api.Message) string {
	if msg.TS != "" {
		t := msg.ParseTS()

		return t.In(time.Local).Format("15:04") //nolint:gosmopolitan // CLI uses local time
	}

	return time.Now().Format("15:04")
}

func (a *App) handlePrivmsgMsg(
	msg *api.Message,
	ts, myNick string,
) {
	lines := msg.BodyLines()
	text := strings.Join(lines, " ")

	if msg.From == myNick {
		return
	}

	target := msg.To
	if !strings.HasPrefix(target, "#") {
		target = msg.From
	}

	a.ui.AddLine(
		target,
		fmt.Sprintf(
			"[gray]%s [green]<%s>[white] %s",
			ts, msg.From, text,
		),
	)
}

func (a *App) handleJoinMsg(
	msg *api.Message, ts string,
) {
	target := msg.To
	if target == "" {
		return
	}

	a.ui.AddLine(
		target,
		fmt.Sprintf(
			"[gray]%s [yellow]*** %s has joined %s",
			ts, msg.From, target,
		),
	)
}

func (a *App) handlePartMsg(
	msg *api.Message, ts string,
) {
	target := msg.To
	if target == "" {
		return
	}

	lines := msg.BodyLines()
	reason := strings.Join(lines, " ")

	if reason != "" {
		a.ui.AddLine(
			target,
			fmt.Sprintf(
				"[gray]%s [yellow]*** %s has left %s (%s)",
				ts, msg.From, target, reason,
			),
		)
	} else {
		a.ui.AddLine(
			target,
			fmt.Sprintf(
				"[gray]%s [yellow]*** %s has left %s",
				ts, msg.From, target,
			),
		)
	}
}

func (a *App) handleQuitMsg(
	msg *api.Message, ts string,
) {
	lines := msg.BodyLines()
	reason := strings.Join(lines, " ")

	if reason != "" {
		a.ui.AddStatus(
			fmt.Sprintf(
				"[gray]%s [yellow]*** %s has quit (%s)",
				ts, msg.From, reason,
			),
		)
	} else {
		a.ui.AddStatus(
			fmt.Sprintf(
				"[gray]%s [yellow]*** %s has quit",
				ts, msg.From,
			),
		)
	}
}

func (a *App) handleNickMsg(
	msg *api.Message, ts, myNick string,
) {
	lines := msg.BodyLines()

	newNick := ""
	if len(lines) > 0 {
		newNick = lines[0]
	}

	if msg.From == myNick && newNick != "" {
		a.mu.Lock()
		a.nick = newNick
		target := a.target
		a.mu.Unlock()

		a.ui.SetStatus(newNick, target, "connected")
	}

	a.ui.AddStatus(
		fmt.Sprintf(
			"[gray]%s [yellow]*** %s is now known as %s",
			ts, msg.From, newNick,
		),
	)
}

func (a *App) handleNoticeMsg(
	msg *api.Message, ts string,
) {
	lines := msg.BodyLines()
	text := strings.Join(lines, " ")

	a.ui.AddStatus(
		fmt.Sprintf(
			"[gray]%s [magenta]--%s-- %s",
			ts, msg.From, text,
		),
	)
}

func (a *App) handleTopicMsg(
	msg *api.Message, ts string,
) {
	if msg.To == "" {
		return
	}

	lines := msg.BodyLines()
	text := strings.Join(lines, " ")

	a.ui.AddLine(
		msg.To,
		fmt.Sprintf(
			"[gray]%s [cyan]*** %s set topic: %s",
			ts, msg.From, text,
		),
	)
}

func (a *App) handleDefaultMsg(
	msg *api.Message, ts string,
) {
	lines := msg.BodyLines()
	text := strings.Join(lines, " ")

	if text == "" {
		return
	}

	a.ui.AddStatus(
		fmt.Sprintf(
			"[gray]%s [white][%s] %s",
			ts, msg.Command, text,
		),
	)
}