package message

import (
	"local/truckstop/config"
	"log"

	"github.com/matrix-org/gomatrix"
)

type Matrix struct {
	mock       bool
	homeserver string
	username   string
	token      string
	room       string
}

func NewMatrix() Matrix {
	conf := config.Get().Message.Matrix
	return Matrix{
		homeserver: conf.Homeserver,
		username:   conf.Username,
		token:      conf.Token,
		room:       conf.Room,
		mock:       conf.Mock,
	}
}

func (m Matrix) getclient() (*gomatrix.Client, error) {
	return gomatrix.NewClient(m.homeserver, m.username, m.token)
}

func (m Matrix) Receive() ([]Message, error) {
	if m.mock {
		log.Printf("matrix.Receive()")
		messages := make([]Message, 0)
		for k := range config.Get().Clients {
			messages = append(messages, Message{Sender: k, Content: "OH"})
		}
		return messages, nil
	}
	clients := config.Get().Clients
	matrixIDs := map[string]struct{}{}
	for k := range clients {
		matrixIDs[clients[k].IDs.Matrix] = struct{}{}
	}
	if len(matrixIDs) == 0 {
		return nil, nil
	}
	c, err := m.getclient()
	if err != nil {
		return nil, err
	}
	messages := make([]Message, 0)
	result, err := c.Messages(m.room, "", "", 'b', 50)
	for _, event := range result.Chunk {
		if _, ok := matrixIDs[event.Sender]; !ok {
			continue
		}
		switch event.Type {
		case "m.room.message":
			b, ok := event.Body()
			if ok {
				messages = append(messages, Message{Sender: event.Sender, Content: b})
			}
		}
	}
	if err != nil {
		return nil, err
	}
	for i := range messages {
		for k, v := range config.Get().Clients {
			if v.IDs.Matrix == messages[i].Sender {
				messages[i].Sender = k
			}
		}
	}
	return messages, nil
}

func (m Matrix) Send(text string) error {
	if m.mock {
		log.Printf("matrix.Send(%s)", text)
		return nil
	}
	c, err := m.getclient()
	if err != nil {
		return err
	}
	_, err = c.SendText(m.room, text)
	return err
}