package main

import (
	room "git.fromouter.space/mcg/cardgage/room/api"
)

// RuleBot is the functional part of RuleBot
type RuleBot struct {
	API   BotInterface
	Name  string
	Rooms map[string]roomInfo
	Games map[string]*engine.Game
}

type roomInfo struct {
	Name  string
	Owner string
}

// BotInterface is the interface needed by RuleBot for working in cardgage
// This exists so that RuleBot can be attached to a mocked API for testing
type BotInterface interface {
	Send(room.BotMessage)
}

// NewRuleBot creates a new rule engine instance with the given name
// and communication interface
func NewRuleBot(botAPI BotInterface, name string) *RuleBot {
	return &RuleBot{
		API:      botAPI,
		Name:     name,
		Rooms:    make(map[string]roomInfo),
		Sessions: make(map[string]*session),
	}
}

// OnMessage is the function to be called when messages are received
func (d *RuleBot) OnMessage(msg room.ServerMessage) {
	switch msg.Type {
	case room.MsgMessage:
		if logAll {
			logger.Log("event", "message",
				"roomid", msg.RoomID,
				"from", msg.Message.From,
				"to", msg.Message.To,
				"content", msg.Message.Message)
		}
		// Only consider messages that speak directly to me
		if msg.Message.To == d.Name {
			d.handleMessage(msg.RoomID, *msg.Message)
		}
	case room.MsgEvent:
		if logAll {
			logger.Log("event", "event",
				"roomid", msg.RoomID,
				"content", msg.Event.Message)
		}
		d.handleEvent(msg.RoomID, *msg.Event)
	}
}

func (d *RuleBot) sendMessage(roomid string, msg room.Message) {
	d.API.Send(room.BotMessage{
		RoomID:  roomid,
		Type:    room.MsgMessage,
		Message: &msg,
	})
}

func (d *RuleBot) handleMessage(roomid string, msg room.Message) {
	//TODO
}

func (d *RuleBot) handleSessionMessages(roomid string, s *session) {
	for msg := range s.messages {
		d.sendMessage(roomid, msg)
	}
}