mailbox.go

package sbanken

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"net/http"
	"net/url"
	"strconv"
	"time"

	"github.com/engvik/sbanken-go/internal/transport"
	"github.com/engvik/sbanken-go/internal/unmarshal"
)

var (
	ErrMailboxMessageUnmarshal = errors.New("error unmarshaling json")
)

// MailboxMessage represents a mailbox message.
// Sbanken API documentation: https://publicapi.sbanken.no/openapi/apibeta/index.html?urls.primaryName=API%20Beta%20V2#/Mailbox
type MailboxMessage struct {
	Subject      string `json:"subject"`
	Category     string `json:"category"`
	Source       string `json:"source"`
	Status       string `json:"status"`
	LinkName     string `json:"linkName"`
	LinkURL      string `json:"linkUrl"`
	ReceivedDate string `json:"receivedDate"`
	ID           int    `json:"id"`
	Flag         int    `json:"flag"`
	AttachmentID int    `json:"attachmentId"`
}

// UnmarshalJSON is implemented due to a bug in sbankens API. Category and
// Status should contain strings, but contain ints. The custom unmarshaler
// supports both string and ints for these fields.
func (m *MailboxMessage) UnmarshalJSON(data []byte) error {
	// Temporary internal structs that supports both ints and strings for
	// Category and Status fields.
	tmpMailboxMessage := struct {
		Subject      string      `json:"subject"`
		Source       string      `json:"source"`
		LinkName     string      `json:"linkName"`
		LinkURL      string      `json:"linkUrl"`
		ReceivedDate string      `json:"receivedDate"`
		ID           int         `json:"id"`
		Flag         int         `json:"flag"`
		AttachmentID int         `json:"attachmentId"`
		Category     interface{} `json:"category"`
		Status       interface{} `json:"status"`
	}{}

	if err := json.Unmarshal(data, &tmpMailboxMessage); err != nil {
		return err
	}

	// Get and set proper category value.
	categoryString, categoryInt, err := unmarshal.GetIntStringField(tmpMailboxMessage.Category)
	if err != nil {
		return err
	}

	if categoryString != "" {
		m.Category = categoryString
	} else {
		if categoryInt == 0 {
			m.Category = "General"
		} else if categoryInt == 1 {
			m.Category = "News"
		} else {
			return ErrMailboxMessageUnmarshal
		}
	}

	// Get and set proper status value.
	statusString, statusInt, err := unmarshal.GetIntStringField(tmpMailboxMessage.Status)
	if err != nil {
		return err
	}

	if statusString != "" {
		m.Status = statusString
	} else {
		if statusInt == 0 {
			m.Status = "Unread"
		} else if statusInt == 1 {
			m.Status = "Read"
		} else {
			return ErrMailboxMessageUnmarshal
		}
	}

	// Set fields of correct type
	m.Subject = tmpMailboxMessage.Subject
	m.Source = tmpMailboxMessage.Source
	m.LinkName = tmpMailboxMessage.LinkName
	m.LinkURL = tmpMailboxMessage.LinkURL
	m.ReceivedDate = tmpMailboxMessage.ReceivedDate
	m.ID = tmpMailboxMessage.ID
	m.Flag = tmpMailboxMessage.Flag
	m.AttachmentID = tmpMailboxMessage.AttachmentID

	return nil
}

// MailboxQuery represents query parameteres for querying the mailbox.
type MailboxListQuery struct {
	StartDate time.Time
	EndDate   time.Time
	Status    string
	Index     string
	Length    string
}

func (q *MailboxListQuery) QueryString(u string) (string, error) {
	parsedURL, err := url.Parse(u)
	if err != nil {
		return u, err
	}

	query := parsedURL.Query()

	if !q.StartDate.IsZero() {
		query.Add("startDate", q.StartDate.Format(time.RFC3339))
	}

	if !q.EndDate.IsZero() {
		query.Add("endDate", q.EndDate.Format(time.RFC3339))
	}

	if q.Status != "" {
		query.Add("status", q.Status)
	}

	if q.Index != "" {
		query.Add("index", q.Index)
	}

	if q.Length != "" {
		query.Add("length", q.Length)
	}

	return query.Encode(), nil
}

type MailboxCountQuery struct {
	StartDate time.Time
	EndDate   time.Time
	Status    string
}

func (q *MailboxCountQuery) QueryString(u string) (string, error) {
	parsedURL, err := url.Parse(u)
	if err != nil {
		return u, err
	}

	query := parsedURL.Query()

	if !q.StartDate.IsZero() {
		query.Add("startDate", q.StartDate.Format(time.RFC3339))
	}

	if !q.EndDate.IsZero() {
		query.Add("endDate", q.EndDate.Format(time.RFC3339))
	}

	if q.Status != "" {
		query.Add("status", q.Status)
	}

	return query.Encode(), nil
}

type MailboxAttachment struct {
	ID         int    `json:"attachmentID"`
	Name       string `json:"name"`
	Attachment string `json:"attachment"`
}

func (c *Client) ListArchiveMessages(ctx context.Context, q *MailboxListQuery) ([]MailboxMessage, error) {
	url := fmt.Sprintf("%s/v2/Mailbox/archive", c.bankBaseURL)

	return c.listMessages(ctx, url, q, "ListArchiveMessages")
}

func (c *Client) ListInboxMessages(ctx context.Context, q *MailboxListQuery) ([]MailboxMessage, error) {
	url := fmt.Sprintf("%s/v2/Mailbox/inbox", c.bankBaseURL)

	return c.listMessages(ctx, url, q, "ListInboxMessages")
}

func (c *Client) listMessages(ctx context.Context, url string, q *MailboxListQuery, caller string) ([]MailboxMessage, error) {
	if q != nil {
		qs, err := q.QueryString(url)
		if err != nil {
			return nil, fmt.Errorf("QueryString: %w", err)
		}

		url = fmt.Sprintf("%s?%s", url, qs)
	}

	res, sc, err := c.transport.Request(ctx, &transport.HTTPRequest{
		Method: http.MethodGet,
		URL:    url,
	})
	if err != nil {
		return nil, fmt.Errorf("request: %w", err)
	}

	data := struct {
		Messages []MailboxMessage `json:"items"`
		transport.HTTPResponse
	}{}

	if err := json.Unmarshal(res, &data); err != nil {
		return data.Messages, fmt.Errorf("Unmarshal: %w", err)
	}

	if data.IsError || sc != http.StatusOK {
		return data.Messages, &Error{
			caller,
			data.ErrorType,
			data.ErrorMessage,
			data.ErrorCode,
			sc,
		}
	}

	return data.Messages, nil
}

func (c *Client) ReadArchiveMessage(ctx context.Context, id int) (MailboxMessage, error) {
	url := fmt.Sprintf("%s/v2/Mailbox/archive/%d", c.bankBaseURL, id)

	return c.readMessage(ctx, url, "ReadArchiveMessage")
}

func (c *Client) ReadInboxMessage(ctx context.Context, id int) (MailboxMessage, error) {
	url := fmt.Sprintf("%s/v2/Mailbox/inbox/%d", c.bankBaseURL, id)

	return c.readMessage(ctx, url, "ReadInboxMessage")
}

func (c *Client) readMessage(ctx context.Context, url string, caller string) (MailboxMessage, error) {
	res, sc, err := c.transport.Request(ctx, &transport.HTTPRequest{
		Method: http.MethodGet,
		URL:    url,
	})
	if err != nil {
		return MailboxMessage{}, fmt.Errorf("request: %w", err)
	}

	var data MailboxMessage

	if err := json.Unmarshal(res, &data); err != nil {
		return data, fmt.Errorf("Unmarshal: %w", err)
	}

	if sc != http.StatusOK {
		return data, &Error{
			caller,
			"",
			"",
			0,
			sc,
		}
	}

	return data, nil
}

func (c *Client) DeleteArchiveMessage(ctx context.Context, id int) error {
	url := fmt.Sprintf("%s/v2/Mailbox/archive/%d", c.bankBaseURL, id)
	return c.deleteMessage(ctx, url, "DeleteArchiveMessage")
}

func (c *Client) DeleteInboxMessage(ctx context.Context, id int) error {
	url := fmt.Sprintf("%s/v2/Mailbox/inbox/%d", c.bankBaseURL, id)
	return c.deleteMessage(ctx, url, "DeleteInboxMessage")
}

func (c *Client) deleteMessage(ctx context.Context, url string, caller string) error {
	_, sc, err := c.transport.Request(ctx, &transport.HTTPRequest{
		Method: http.MethodDelete,
		URL:    url,
	})
	if err != nil {
		return fmt.Errorf("request: %w", err)
	}

	if sc != http.StatusNoContent {
		return &Error{
			caller,
			"",
			"",
			0,
			sc,
		}
	}

	return nil
}

func (c *Client) MoveArchiveMessage(ctx context.Context, id int) error {
	url := fmt.Sprintf("%s/v2/Mailbox/archive/%d/move", c.bankBaseURL, id)
	return c.moveMessage(ctx, url, "MoveArchiveMessage")
}

func (c *Client) MoveInboxMessage(ctx context.Context, id int) error {
	url := fmt.Sprintf("%s/v2/Mailbox/inbox/%d/move", c.bankBaseURL, id)
	return c.moveMessage(ctx, url, "MoveInboxMessage")
}

func (c *Client) moveMessage(ctx context.Context, url string, caller string) error {
	_, sc, err := c.transport.Request(ctx, &transport.HTTPRequest{
		Method: http.MethodPut,
		URL:    url,
	})
	if err != nil {
		return fmt.Errorf("request: %w", err)
	}

	if sc != http.StatusOK {
		return &Error{
			caller,
			"",
			"",
			0,
			sc,
		}
	}

	return nil
}

func (c *Client) UpdateArchiveMessageReadStatus(ctx context.Context, id int, read bool) error {
	url := fmt.Sprintf("%s/v2/Mailbox/archive/%d/readstatus", c.bankBaseURL, id)
	return c.updateReadStatus(ctx, url, read, "UpdateArchiveMessageReadStatus")
}

func (c *Client) UpdateInboxMessageReadStatus(ctx context.Context, id int, read bool) error {
	url := fmt.Sprintf("%s/v2/Mailbox/inbox/%d/readstatus", c.bankBaseURL, id)
	return c.updateReadStatus(ctx, url, read, "UpdateInboxMessageReadStatus")
}

func (c *Client) updateReadStatus(ctx context.Context, url string, status bool, caller string) error {
	var readStatus string

	if status {
		readStatus = "Read"
	} else {
		readStatus = "Unread"
	}

	data := struct {
		Status string `json:"value"`
	}{
		Status: readStatus,
	}

	payload, err := json.Marshal(data)
	if err != nil {
		return fmt.Errorf("Marshal: %w", err)
	}

	_, sc, err := c.transport.Request(ctx, &transport.HTTPRequest{
		Method:     http.MethodPut,
		URL:        url,
		PutPayload: payload,
	})
	if err != nil {
		return fmt.Errorf("request: %w", err)
	}

	if sc != http.StatusNoContent {
		return &Error{
			caller,
			"",
			"",
			0,
			sc,
		}
	}

	return nil
}

func (c *Client) GetArchiveMessageCount(ctx context.Context, q *MailboxCountQuery) (int, error) {
	url := fmt.Sprintf("%s/v2/Mailbox/archive/count", c.bankBaseURL)
	return c.getMessageCount(ctx, url, q, "GetArchiveMessageCount")
}

func (c *Client) GetInboxMessageCount(ctx context.Context, q *MailboxCountQuery) (int, error) {
	url := fmt.Sprintf("%s/v2/Mailbox/inbox/count", c.bankBaseURL)
	return c.getMessageCount(ctx, url, q, "GetInboxMessageCount")
}

func (c *Client) getMessageCount(ctx context.Context, url string, q *MailboxCountQuery, caller string) (int, error) {
	if q != nil {
		qs, err := q.QueryString(url)
		if err != nil {
			return 0, fmt.Errorf("QueryString: %w", err)
		}

		url = fmt.Sprintf("%s?%s", url, qs)
	}

	res, sc, err := c.transport.Request(ctx, &transport.HTTPRequest{
		Method: http.MethodGet,
		URL:    url,
	})
	if err != nil {
		return 0, fmt.Errorf("request: %w", err)
	}

	if sc != http.StatusOK {
		return 0, &Error{
			caller,
			"",
			"",
			0,
			sc,
		}
	}

	return strconv.Atoi(string(res))
}

func (c *Client) ReadArchiveAttachment(ctx context.Context, messageID int, attachmentID int) (MailboxAttachment, error) {
	url := fmt.Sprintf("%s/v2/Mailbox/archive/%d/attachment/%d", c.bankBaseURL, messageID, attachmentID)
	return c.readAttachment(ctx, url, "ReadArchiveAttachment")
}

func (c *Client) ReadInboxAttachment(ctx context.Context, messageID int, attachmentID int) (MailboxAttachment, error) {
	url := fmt.Sprintf("%s/v2/Mailbox/inbox/%d/attachment/%d", c.bankBaseURL, messageID, attachmentID)
	return c.readAttachment(ctx, url, "ReadInboxAttachment")
}

func (c *Client) readAttachment(ctx context.Context, url string, caller string) (MailboxAttachment, error) {
	res, sc, err := c.transport.Request(ctx, &transport.HTTPRequest{
		Method: http.MethodGet,
		URL:    url,
	})
	if err != nil {
		return MailboxAttachment{}, fmt.Errorf("request: %w", err)
	}

	var data MailboxAttachment

	if err := json.Unmarshal(res, &data); err != nil {
		return data, fmt.Errorf("Unmarshal: %w", err)
	}

	if sc != http.StatusOK {
		return data, &Error{
			caller,
			"",
			"",
			0,
			sc,
		}
	}

	return data, nil
}