ygggo/internal/storage/remote/mail.go

/*
 *  Copyright (c) 2026 Kaiy Ragur
 *
 *  This Source Code Form is subject to the terms of the Mozilla Public
 *  License, v. 2.0. If a copy of the MPL was not distributed with this
 *  file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
package remote

import (
	"fmt"
	"io"
	"time"

	pb "github.com/neilalexander/yggmail/internal/remote/types"
	"github.com/neilalexander/yggmail/internal/storage/types"
	"github.com/neilalexander/yggmail/internal/utils"
)

// Helpers

func (s *RemoteStorage) getStatus(pk, mailbox string) (*pb.MailboxStatus, error) {
	resp, _, err := s.Call(&pb.Request{
		Call: &pb.Request_MboxStatus{
			MboxStatus: &pb.MailboxStatusRequest{Name: mailbox},
		},
	}, nil, 0) // No payload for status
	if err != nil {
		return nil, err
	}
	if !resp.Success {
		return nil, fmt.Errorf(resp.Error)
	}
	return resp.GetMboxStatus(), nil
}

// Mail Read

func (s *RemoteStorage) MailCount(pk string, mailbox string) (int, error) {
	st, err := s.getStatus(pk, mailbox)
	if err != nil {
		return 0, err
	}
	return int(st.MessagesCount), nil
}

func (s *RemoteStorage) MailUnseen(pk string, mailbox string) (int, error) {
	st, err := s.getStatus(pk, mailbox)
	if err != nil {
		return 0, err
	}
	return int(st.UnseenCount), nil
}

func (s *RemoteStorage) MailNextID(pk string, mailbox string) (int, error) {
	st, err := s.getStatus(pk, mailbox)
	if err != nil {
		return 0, err
	}
	return int(st.UidNext), nil
}

func (s *RemoteStorage) MailSelect(pk string, mailbox string, id int) (int, *types.Mail, error) {
	resp, payload, err := s.Client.Call(s.targetNode, &pb.Request{
		Call: &pb.Request_MailFetch{
			MailFetch: &pb.MailFetchRequest{
				Mailbox: mailbox,
				Ids:     []uint32{uint32(id)},
			},
		},
	}, nil, 0)

	if err != nil {
		return 0, nil, fmt.Errorf("rpc select failed: %w", err)
	}
	if !resp.Success || len(resp.GetMailList().Items) == 0 {
		return 0, nil, fmt.Errorf("message not found")
	}

	m := resp.GetMailList().Items[0]

	mail := &types.Mail{
		ID:       int(m.Id),
		Size:     m.Size,
		Date:     time.Unix(m.Date, 0),
		Seen:     m.Seen,
		Answered: m.Answered,
		Flagged:  m.Flagged,
		Deleted:  m.Deleted,
	}

	if payload != nil {
		mail.Body = payload.R
	}

	return int(m.Seq), mail, nil
}

// Mail Create

func (s *RemoteStorage) MailCreate(pk string, mailbox string, content io.Reader, size int) (int, error) {
	addr := fmt.Sprintf("%s@%s", pk, utils.EncodeString(s.targetNode))

	resp, _, err := s.Client.Call(s.targetNode, &pb.Request{
		Call: &pb.Request_MailPush{
			MailPush: &pb.MailPushRequest{
				From:    addr,
				To:      addr,
				Mailbox: mailbox,
			},
		},
	}, io.NopCloser(content), uint32(size))

	if err != nil {
		return 0, fmt.Errorf("rpc push failed: %w", err)
	}
	if !resp.Success {
		return 0, fmt.Errorf("remote storage error: %s", resp.Error)
	}

	return int(resp.GetIdResult()), nil
}

func (s *RemoteStorage) MailUpdateFlags(pk string, mailbox string, id int, seen, answered, flagged, deleted bool) error {
	resp, _, err := s.Call(&pb.Request{
		Call: &pb.Request_MailFlags{
			MailFlags: &pb.MailUpdateFlagsRequest{
				Mailbox: mailbox, Id: uint32(id),
				Seen: seen, Answered: answered, Flagged: flagged, Deleted: deleted,
			},
		},
	}, nil, 0)
	if err != nil {
		return err
	}
	if !resp.Success {
		return fmt.Errorf(resp.Error)
	}
	return nil
}

// Managements

func (s *RemoteStorage) MailDelete(pk string, mailbox string, id int) error {
	_, _, err := s.Call(&pb.Request{
		Call: &pb.Request_MailDel{
			MailDel: &pb.MailDeleteRequest{Mailbox: mailbox, Id: uint32(id)},
		},
	}, nil, 0)
	return err
}

func (s *RemoteStorage) MailMove(pk string, mailbox string, id int, dest string) (int, error) {
	_, _, err := s.Call(&pb.Request{
		Call: &pb.Request_MailMove{
			MailMove: &pb.MailMoveRequest{
				Mailbox:            mailbox,
				Id:                 uint32(id),
				DestinationMailbox: dest,
			},
		},
	}, nil, 0)
	return 0, err
}

func (s *RemoteStorage) MailExpunge(pk string, mailbox string) error {
	_, _, err := s.Call(&pb.Request{
		Call: &pb.Request_MailExpunge{
			MailExpunge: &pb.MailExpungeRequest{Mailbox: mailbox},
		},
	}, nil, 0)
	return err
}

func (s *RemoteStorage) MailIDForSeq(pk string, mailbox string, seq int) (int, error) {
	resp, _, err := s.Call(&pb.Request{
		Call: &pb.Request_MailIdForSeq{
			MailIdForSeq: &pb.MailIdForSeqRequest{
				Mailbox: mailbox,
				Seq:     uint32(seq),
			},
		},
	}, nil, 0)
	if err != nil {
		return 0, err
	}
	if !resp.Success {
		return 0, fmt.Errorf("remote error: %s", resp.Error)
	}
	return int(resp.GetIdResult()), nil
}

func (s *RemoteStorage) MailSearch(pk string, mailbox string) ([]uint32, error) {
	resp, _, err := s.Call(&pb.Request{
		Call: &pb.Request_MailSearch{
			MailSearch: &pb.MailSearchRequest{Mailbox: mailbox},
		},
	}, nil, 0)
	if err != nil {
		return nil, err
	}
	if !resp.Success {
		return nil, fmt.Errorf("remote error: %s", resp.Error)
	}

	var ids []uint32
	for _, item := range resp.GetMailList().Items {
		ids = append(ids, item.Id)
	}
	return ids, nil
}