package xmpp

import (
	"crypto/tls"
	"crypto/x509"
	"log"
)

type Event uint8

const (
	DisconnectEvent Event = iota
	ConnectEvent
	ShouldDisconnectEvent
)

type Conn struct {
	ch chan Event
	jid, pwd string
	tcp *tls.Conn
	enc encoder
}

func NewConn(ch chan Event, jid string, pwd string) *Conn {
	c := Conn{
		ch: ch,
		jid: jid,
		pwd: pwd}

	return &c
}

func (c *Conn) Connect() error {
	var err error

	domain := domainpart(c.jid)

	roots, err := x509.SystemCertPool()
	if err != nil {
		log.Println(err)
		return err
	}

	c.tcp, err = tls.Dial("tcp", domain+":"+"5223", &tls.Config{RootCAs: roots})
	if err != nil {
		log.Println(err)
		return err
	}

	return nil
}

func (c *Conn) Disconnect() {
	c.tcp.Close()
}

func (c *Conn) Run() {
	err := c.Connect()
	if err != nil {
		return
	}
	defer c.Disconnect()

	decoder := newDecoder(c.tcp)
	go decoder.run()
	defer decoder.stop()

	c.enc = newEncoder(c.tcp)
	defer c.enc.Close()

	tr := newTokenRouter()

	end := sendStreamStart(&c.enc, c.jid)
	defer sendStreamEnd(&c.enc, end)

	c.ch <- ConnectEvent
	defer func() { c.ch <- DisconnectEvent }()

	for {
		select {
		case ev := <-c.ch:
			switch ev {
			case ShouldDisconnectEvent:
				return
			default:
				log.Printf("Unknown Event '%d'!\n", ev)
			}
		case token := <-decoder.data:
			err = tr.route(token, c)
			if err != nil {
				log.Println(err)
				return
			}
		}
	}
}