package xmpp

import (
	"github.com/pkg/errors"

	"dev.narayana.im/narayana/telegabber/config"
	"dev.narayana.im/narayana/telegabber/persistence"
	"dev.narayana.im/narayana/telegabber/telegram"

	log "github.com/sirupsen/logrus"
	"gosrc.io/xmpp"
)

var jid *xmpp.Jid
var tgConf config.TelegramConfig
var sessions map[string]telegram.Client
var db persistence.SessionsYamlDB

// NewComponent starts a new component and wraps it in
// a stream manager that you should start yourself
func NewComponent(conf config.XMPPConfig, tc config.TelegramConfig) (*xmpp.StreamManager, error) {
	var err error

	jid, err = xmpp.NewJid(conf.Jid)
	if err != nil {
		return nil, err
	}

	tgConf = tc

	err = loadSessions(conf.Db)
	if err != nil {
		return nil, err
	}

	options := xmpp.ComponentOptions{
		Address: conf.Host + ":" + conf.Port,
		Domain:  conf.Jid,
		Secret:  conf.Password,
		Name:    "telegabber",
	}

	router := xmpp.NewRouter()
	router.HandleFunc("iq", HandleIq)
	router.HandleFunc("presence", HandlePresence)
	router.HandleFunc("message", HandleMessage)

	component, err := xmpp.NewComponent(options, router)
	if err != nil {
		return nil, err
	}

	cm := xmpp.NewStreamManager(component, nil)

	go maintenance()

	return cm, nil
}

func maintenance() {
	// TODO
}

func loadSessions(dbPath string) error {
	var err error

	sessions = make(map[string]telegram.Client)

	db, err = persistence.LoadSessions(dbPath)
	if err != nil {
		return err
	}

	db.Transaction(func() bool {
		for jid, session := range db.Data.Sessions {
			getTelegramInstance(jid, &session)
		}

		return false
	}, persistence.SessionMarshaller)

	return nil
}

func getTelegramInstance(jid string, savedSession *persistence.Session) (telegram.Client, bool) {
	session, ok := sessions[jid]
	if !ok {
		session, err := telegram.NewClient(tgConf, jid, savedSession)
		if err != nil {
			log.Error(errors.Wrap(err, "TDlib initialization failure"))
			return session, false
		}
		sessions[jid] = session
	}

	return session, true
}