package packetlog

import (
	"encoding/xml"
	"errors"
	"fmt"
	"strings"
)

type Message struct {
	ID          string
	From        string
	To          string
	Type        string
	Body        string
	Subject     string
	SendTime    string
	ReceiptID   string
	ReceiptType string
	Consumed    bool
	Read        bool
}

type xmppMessage struct {
	XMLName  xml.Name    `xml:"message"`
	ID       string      `xml:"id,attr"`
	From     string      `xml:"from,attr"`
	To       string      `xml:"to,attr"`
	Type     string      `xml:"type,attr"`
	Body     string      `xml:"body"`
	Subject  string      `xml:"subject"`
	Receipt  xmppReceipt `xml:"received"`
	ISphere  xmppISphere `xml:"isphere"`
	Consumed *struct{}   `xml:"consumed"`
	Readed   *struct{}   `xml:"readed"`
}

type xmppReceipt struct {
	ID   string `xml:"id,attr"`
	Type string `xml:"type,attr"`
}

type xmppISphere struct {
	SendTime string `xml:"sendtime,attr"`
}

func ParseMessageLog(plaintext string) (Message, error) {
	start := strings.Index(plaintext, "<message")
	if start < 0 {
		return Message{}, errors.New("message stanza not found")
	}
	payload := strings.TrimSpace(plaintext[start:])
	var parsed xmppMessage
	if err := xml.Unmarshal([]byte(payload), &parsed); err != nil {
		return Message{}, fmt.Errorf("parse xmpp message: %w", err)
	}
	if parsed.ID == "" {
		return Message{}, errors.New("message id is empty")
	}
	return Message{
		ID:          parsed.ID,
		From:        parsed.From,
		To:          parsed.To,
		Type:        parsed.Type,
		Body:        strings.TrimSpace(parsed.Body),
		Subject:     strings.TrimSpace(parsed.Subject),
		SendTime:    parsed.ISphere.SendTime,
		ReceiptID:   parsed.Receipt.ID,
		ReceiptType: parsed.Receipt.Type,
		Consumed:    parsed.Consumed != nil,
		Read:        parsed.Readed != nil,
	}, nil
}