Refactor

1 files changed, 170 insertions, 0 deletions

diff --git a/forged/internal/ipc/irc/bot.go b/forged/internal/ipc/irc/bot.go
new file mode 100644
index 0000000..07008ae
--- /dev/null
+++ b/forged/internal/ipc/irc/bot.go
@@ -0,0 +1,170 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// SPDX-FileCopyrightText: Copyright (c) 2025 Runxi Yu <https://runxiyu.org>
+
+package irc
+
+import (
+	"context"
+	"crypto/tls"
+	"fmt"
+	"log/slog"
+	"net"
+
+	"go.lindenii.runxiyu.org/forge/forged/internal/common/misc"
+)
+
+// Bot represents an IRC bot client that handles events and allows for sending messages.
+type Bot struct {
+	// TODO: Use each config field instead of embedding Config here.
+	config            *Config
+	ircSendBuffered   chan string
+	ircSendDirectChan chan misc.ErrorBack[string]
+}
+
+// NewBot creates a new Bot instance using the provided configuration.
+func NewBot(c *Config) (b *Bot) {
+	b = &Bot{
+		config: c,
+	} //exhaustruct:ignore
+	return
+}
+
+// Connect establishes a new IRC session and starts handling incoming and outgoing messages.
+// This method blocks until an error occurs or the connection is closed.
+func (b *Bot) Connect(ctx context.Context) error {
+	var err error
+	var underlyingConn net.Conn
+	if b.config.TLS {
+		dialer := tls.Dialer{} //exhaustruct:ignore
+		underlyingConn, err = dialer.DialContext(ctx, b.config.Net, b.config.Addr)
+	} else {
+		dialer := net.Dialer{} //exhaustruct:ignore
+		underlyingConn, err = dialer.DialContext(ctx, b.config.Net, b.config.Addr)
+	}
+	if err != nil {
+		return fmt.Errorf("dialing irc: %w", err)
+	}
+	defer func() {
+		_ = underlyingConn.Close()
+	}()
+
+	conn := NewConn(underlyingConn)
+
+	logAndWriteLn := func(s string) (n int, err error) {
+		slog.Debug("irc tx", "line", s)
+		return conn.WriteString(s + "\r\n")
+	}
+
+	_, err = logAndWriteLn("NICK " + b.config.Nick)
+	if err != nil {
+		return err
+	}
+	_, err = logAndWriteLn("USER " + b.config.User + " 0 * :" + b.config.Gecos)
+	if err != nil {
+		return err
+	}
+
+	readLoopError := make(chan error)
+	writeLoopAbort := make(chan struct{})
+	go func() {
+		for {
+			select {
+			case <-writeLoopAbort:
+				return
+			default:
+			}
+
+			msg, line, err := conn.ReadMessage()
+			if err != nil {
+				readLoopError <- err
+				return
+			}
+
+			slog.Debug("irc rx", "line", line)
+
+			switch msg.Command {
+			case "001":
+				_, err = logAndWriteLn("JOIN #chat")
+				if err != nil {
+					readLoopError <- err
+					return
+				}
+			case "PING":
+				_, err = logAndWriteLn("PONG :" + msg.Args[0])
+				if err != nil {
+					readLoopError <- err
+					return
+				}
+			case "JOIN":
+				c, ok := msg.Source.(Client)
+				if !ok {
+					slog.Error("unable to convert source of JOIN to client")
+				}
+				if c.Nick != b.config.Nick {
+					continue
+				}
+			default:
+			}
+		}
+	}()
+
+	for {
+		select {
+		case err = <-readLoopError:
+			return err
+		case line := <-b.ircSendBuffered:
+			_, err = logAndWriteLn(line)
+			if err != nil {
+				select {
+				case b.ircSendBuffered <- line:
+				default:
+					slog.Error("unable to requeue message", "line", line)
+				}
+				writeLoopAbort <- struct{}{}
+				return err
+			}
+		case lineErrorBack := <-b.ircSendDirectChan:
+			_, err = logAndWriteLn(lineErrorBack.Content)
+			lineErrorBack.ErrorChan <- err
+			if err != nil {
+				writeLoopAbort <- struct{}{}
+				return err
+			}
+		}
+	}
+}
+
+// SendDirect sends an IRC message directly to the connection and bypasses
+// the buffering system.
+func (b *Bot) SendDirect(line string) error {
+	ech := make(chan error, 1)
+
+	b.ircSendDirectChan <- misc.ErrorBack[string]{
+		Content:   line,
+		ErrorChan: ech,
+	}
+
+	return <-ech
+}
+
+// Send queues a message to be sent asynchronously via the buffered send queue.
+// If the queue is full, the message is dropped and an error is logged.
+func (b *Bot) Send(line string) {
+	select {
+	case b.ircSendBuffered <- line:
+	default:
+		slog.Error("irc sendq full", "line", line)
+	}
+}
+
+// ConnectLoop continuously attempts to maintain an IRC session.
+// If the connection drops, it automatically retries with no delay.
+func (b *Bot) ConnectLoop(ctx context.Context) {
+	b.ircSendBuffered = make(chan string, b.config.SendQ)
+	b.ircSendDirectChan = make(chan misc.ErrorBack[string])
+
+	for {
+		err := b.Connect(ctx)
+		slog.Error("irc session error", "error", err)
+	}
+}