hehehe

[imapper-go.git] / imapper.go

package main

import (
	"bufio"
	"crypto/tls"
	"fmt"
	"net"
	"regexp"
	"strings"
)

func main() {
	// Replace with your server details and credentials
	server := "mail.fluffbu.de:993"
	username := "kek@fluffbu.de"
	password := ""
	mailbox := "sorter"
	moveToFolder := "Archive"

	// Create TLS connection
	conn, err := tls.Dial("tcp", server, &tls.Config{})
	if err != nil {
		fmt.Println("Error connecting:", err)
		return
	}
	defer conn.Close()

	reader := bufio.NewReader(conn)

	// Read server greeting
	initialResponse(reader)

	// Login to the server
	writeAndRead(reader, conn, "a1 LOGIN "+username+" "+password)

	// Select the mailbox
	writeAndRead(reader, conn, "a1 SELECT "+mailbox)

	// Fetch email IDs (UIDs)
	messageUIDs := fetchMessageIDs(reader, conn)

	// Move the emails to the target folder
	moveEmails(reader, conn, messageUIDs, moveToFolder)

	// Expunge deleted messages and logout
	writeAndRead(reader, conn, "a1 EXPUNGE + LOGOUT")
}

// initialResponse handles the server greeting
func initialResponse(reader *bufio.Reader) {
greetingloop:
	for {
		line, err := reader.ReadString('\n')
		if err != nil {
			fmt.Println("Error reading greeting:", err)
			return
		}
		fmt.Print("Server Greeting: " + line)

		// Exit loop when server is ready (usually contains "OK")
		if strings.Contains(line, "OK") {
			break greetingloop
		}
	}
}

// fetchMessageIDs fetches the UID of all messages in the mailbox and returns them as a slice of UIDs
func fetchMessageIDs(reader *bufio.Reader, conn net.Conn) []string {
	// Fetch UIDs for all messages (1:*)
	fmt.Println("Fetching message UIDs:")
	// writeAndRead(reader, conn, "a1 UID FETCH 1:* (UID)")
	fmt.Fprintf(conn, "a1 UID FETCH 1:* (UID)"+"\r\n")

	var uids []string
	re := regexp.MustCompile(`UID\s+(\d+)`)
	readingUIDs := false

stringread:
	for {
		line, err := reader.ReadString('\n')
		if err != nil {
			fmt.Println("Error reading:", err)
			break stringread
		}

		// Start reading UIDs when we see the first UID line
		if strings.Contains(line, "FETCH (UID") {
			readingUIDs = true
		}

		// Parse UID and collect it in the slice
		if readingUIDs {
			match := re.FindStringSubmatch(line)
			if len(match) > 1 {
				uid := match[1]
				fmt.Println("Message UID:", uid)
				uids = append(uids, uid)
			}
		}

		// Stop reading when we get an "OK", "NO", or "BAD" response
		if strings.HasPrefix(line, "a1 OK") || strings.HasPrefix(line, "NO") || strings.HasPrefix(line, "BAD") {
			break stringread
		}
	}

	return uids
}

// moveEmails moves emails with the given UIDs to the target folder and marks them for deletion in the original folder
func moveEmails(reader *bufio.Reader, conn net.Conn, uids []string, moveToFolder string) {
	if len(uids) == 0 {
		fmt.Println("No messages to move.")
		return
	}

	// Combine UIDs into a single string
	uidList := strings.Join(uids, ",")

	// Copy the messages to the target folder
	fmt.Println("Moving messages to folder:", moveToFolder)
	writeAndRead(reader, conn, "a1 UID COPY "+uidList+" "+moveToFolder)

	// Mark the messages as deleted in the original folder
	writeAndRead(reader, conn, "a1 UID STORE "+uidList+" +FLAGS.SILENT (\\Deleted)")
}

func writeAndRead(reader *bufio.Reader, conn net.Conn, command string) error {
	// Write the command to the IMAP server
	fmt.Println("C: " + command)
	fmt.Fprintf(conn, command+"\r\n")

	// Read the response
responseloop:
	for {
		line, err := reader.ReadString('\n')
		if err != nil {
			fmt.Println("Error reading:", err)
			return err
		}

		// Print the server's response line
		fmt.Print("S: " + line)

		// Stop reading when we get an "OK", "NO", or "BAD" response
		if strings.Contains(line, "a1 OK") || strings.Contains(line, "a1 NO") || strings.Contains(line, "BAD") {
			break responseloop
		}
	}

	return nil
}