// Copyright 2011 The Go Authors.  All rights reserved.

// Use of this source code is governed by a BSD-style

// license that can be found in the LICENSE file.

package xmpp

import (

	"encoding/xml"

	"fmt"

)

// This file contains support for roster management, RFC 3921, Section 7.

var rosterExt Extension = Extension{StanzaHandlers: map[string]func(*xml.Name) interface{}{NsRoster: newRosterQuery}, Start: startRosterFilter}

// Roster query/result

type RosterQuery struct {

	XMLName xml.Name `xml:"jabber:iq:roster query"`

	Item    []RosterItem `xml:"item"`

}

// See RFC 3921, Section 7.1.

type RosterItem struct {

	XMLName      xml.Name `xml:"jabber:iq:roster item"`

	Jid          string   `xml:"jid,attr"`

	Subscription string   `xml:"subscription,attr"`

	Name         string   `xml:"name,attr"`

	Group        []string

}

type rosterClient struct {

	rosterChan   <-chan []RosterItem

	rosterUpdate chan<- RosterItem

}

var (

	rosterClients = make(map[string]rosterClient)

)

// Implicitly becomes part of NewClient's extStanza arg.

func newRosterQuery(name *xml.Name) interface{} {

	return &RosterQuery{}

}

// Synchronously fetch this entity's roster from the server and cache

// that information. This is called once from a fairly deep call stack

// as part of XMPP negotiation.

func fetchRoster(client *Client) error {

	rosterUpdate := rosterClients[client.Uid].rosterUpdate

	iq := &Iq{Header: Header{From: client.Jid.String(), Type: "get",

		Id: <-Id, Nested: []interface{}{RosterQuery{}}}}

	ch := make(chan error)

	f := func(v Stanza) bool {

		defer close(ch)

		iq, ok := v.(*Iq)

		if !ok {

			ch <- fmt.Errorf("response to iq wasn't iq: %s", v)

			return false

		}

		if iq.Type == "error" {

			ch <- iq.Error

			return false

		}

		var rq *RosterQuery

		for _, ele := range iq.Nested {

			if q, ok := ele.(*RosterQuery); ok {

				rq = q

				break

			}

		}

		if rq == nil {

			ch <- fmt.Errorf(

				"Roster query result not query: %v", v)

			return false

		}

		for _, item := range rq.Item {

			rosterUpdate <- item

		}

		ch <- nil

		return false

	}

	client.HandleStanza(iq.Id, f)

	client.Out <- iq

	// Wait for f to complete.

	return <-ch

}

// The roster filter updates the Client's representation of the

// roster, but it lets the relevant stanzas through. This also starts

// the roster feeder, which is the goroutine that provides data on

// client.Roster.

func startRosterFilter(client *Client) {

	out := make(chan Stanza)

	in := client.AddFilter(out)

	go func(in <-chan Stanza, out chan<- Stanza) {

		defer close(out)

		for st := range in {

			maybeUpdateRoster(client, st)

			out <- st

		}

	}(in, out)

	rosterCh := make(chan []RosterItem)

	rosterUpdate := make(chan RosterItem)

	rosterClients[client.Uid] = rosterClient{rosterChan: rosterCh,

		rosterUpdate: rosterUpdate}

	go feedRoster(rosterCh, rosterUpdate)

}

func maybeUpdateRoster(client *Client, st interface{}) {

	iq, ok := st.(*Iq)

	if !ok {

		return

	}

	rosterUpdate := rosterClients[client.Uid].rosterUpdate

	var rq *RosterQuery

	for _, ele := range iq.Nested {

		if q, ok := ele.(*RosterQuery); ok {

			rq = q

			break

		}

	}

	if iq.Type == "set" && rq != nil {

		for _, item := range rq.Item {

			rosterUpdate <- item

		}

		// Send a reply.

		reply := &Iq{Header: Header{To: iq.From, Id: iq.Id,

			Type: "result"}}

		client.Out <- reply

	}

}

func feedRoster(rosterCh chan<- []RosterItem, rosterUpdate <-chan RosterItem) {

	roster := make(map[string]RosterItem)

	snapshot := []RosterItem{}

	for {

		select {

		case newIt := <-rosterUpdate:

			if newIt.Subscription == "remove" {

				delete(roster, newIt.Jid)

			} else {

				roster[newIt.Jid] = newIt

			}

		case rosterCh <- snapshot:

		}

		snapshot = make([]RosterItem, 0, len(roster))

		for _, v := range roster {

			snapshot = append(snapshot, v)

		}

	}

}

// Retrieve a snapshot of the roster for the given Client.

func Roster(client *Client) []RosterItem {

	rosterChan := rosterClients[client.Uid].rosterChan

	return <-rosterChan

}