func updateView(pid, uid string) {
	if isRelevantTo(pid, uid) {
		now := time.Now()
		p := firego.New(userPostsURL + "/" + uid + "/" + pid)
		p.Set(now)
		p = firego.New(postUsersURL + "/" + pid + "/" + uid)
		p.Set(now)
	}
}

func putPostNode(id string, p *PostNode) error {
	fb := firego.New(postsURL + "/" + id)
	if err := fb.Set(p); err != nil {
		return err
	}
	return nil
}

// SignIn creates the user's posts view and starts the user's notification
// channel.
func SignIn(uid, name, imageUrl string) error {
	un := UserNode{Name: name, ImageURL: imageUrl}
	if err := putUserNode(uid, &un); err != nil {
		return err
	}

	// for right now, every user is watching every post
	fb := firego.New(userPostsURL + "/" + uid)
	fb.Set(nil)
	qns, err := getPostNodes(QuestionType)
	if err != nil {
		return err
	}

	for pid := range qns {
		updateView(pid, uid)
	}

	c := make(chan firego.Event)
	if err := fb.Watch(c); err != nil {
		return err
	}

	// TODO:  this needs to be protected by a mutex
	userNotifications[uid] = c
	return nil
}

func ExampleFirebase_IncludePriority() {
	fb := firego.New("https://someapp.firebaseio.com")
	// turn on
	fb.IncludePriority(true)
	// turn off
	fb.IncludePriority(false)
}

func ExampleFirebase_Shallow() {
	fb := firego.New("https://someapp.firebaseio.com")
	// turn on
	fb.Shallow(true)
	// turn off
	fb.Shallow(false)
}

func CustomerHandler(response http.ResponseWriter, request *http.Request) {
	vars := mux.Vars(request)
	customer := vars["customer"]
	orderId := vars["order"]

	f := firego.New("https://example-app-123.firebaseio.com")
	f.Auth("<FIREBASE KEY>")

	var profileBuffer bytes.Buffer
	profileBuffer.WriteString("/customers/")
	profileBuffer.WriteString(customer)
	profileBuffer.WriteString("/profile/")

	var orderBuffer bytes.Buffer
	orderBuffer.WriteString("/customers/")
	orderBuffer.WriteString(customer)
	orderBuffer.WriteString("/orders/")
	orderBuffer.WriteString(orderId)

	profile := f.Child(profileBuffer.String())
	var p Profile
	if err := profile.Value(&p); err != nil {
		log.Fatal(err)
	}

	order := f.Child(orderBuffer.String())
	var o Order
	if err := order.Value(&o); err != nil {
		log.Fatal(err)
	}

	if _, err := Mailer(p, o); err != nil {
		log.Fatal(err)
	}
}

func getPostNode(id string) (*PostNode, error) {
	fb := firego.New(postsURL + "/" + id)
	v := &PostNode{}
	if err := fb.Value(v); err != nil {
		return nil, err
	}
	return v, nil
}

func getCommentNode(id string) (*CommentNode, error) {
	fb := firego.New(commentsURL + "/" + id)
	v := &CommentNode{}
	if err := fb.Value(v); err != nil {
		return nil, err
	}
	return v, nil
}

func NewAPI(fbURL, fbSecret string) (*api, error) {
	if fbURL == "" || fbSecret == "" {
		return nil, errors.New("fbURL or fbSecret are empty")
	}
	fb := firego.New(fbURL)
	fb.Auth(fbSecret)
	return &api{fb: fb}, nil
}

func getQuestionNode(id string) (*QuestionNode, error) {
	fb := firego.New(questionsURL + "/" + id)
	v := &QuestionNode{}
	if err := fb.Value(v); err != nil {
		return nil, err
	}
	return v, nil
}

// getUser returns a User given a UID.  Note that it never returns an error;
// if a user isn't found, the User returned will have the zero value.
func getUser(uid string) User {
	fb := firego.New(usersURL + "/" + uid)
	var v UserNode
	if err := fb.Value(&v); err != nil {
		return User{}
	}
	return User{UID: uid, Name: v.Name, ImageURL: v.ImageURL}
}

func getAnswerNode(id string) (*AnswerNode, error) {
	fb := firego.New(answersURL + "/" + id)
	v := &AnswerNode{}
	if err := fb.Value(v); err != nil {
		return nil, err
	}
	return v, nil
}

func ExampleFirebase_Value() {
	fb := firego.New("https://someapp.firebaseio.com/some/value")
	var v interface{}
	if err := fb.Value(v); err != nil {
		log.Fatal(err)
	}

	log.Printf("My value %v\n", v)
}

func ExampleFirebase_Push() {
	fb := firego.New("https://someapp.firebaseio.com")
	newRef, err := fb.Push("my-value")
	if err != nil {
		log.Fatal(err)
	}

	log.Printf("My new ref %s\n", newRef)
}

func addPostNode(uid string, t PostType) (string, error) {
	fb := firego.New(postsURL)

	p := PostNode{Type: t, Added: time.Now(), AddedBy: uid}
	n, err := fb.Push(p)
	if err != nil {
		return "", err
	}
	path := strings.Split(n.String(), "/")
	return path[len(path)-1], nil
}

func TestFirebase(t *testing.T) {
	f := firego.New("https://peekapp.firebaseio.com/testnode")
	err := f.Set(struct {
		Status  string `json:"status"`
		Message string `json:"message"`
	}{"success", "sadasf"})

	if err != nil {
		t.Fatal(err)
	}
}

func touchPostNode(id string) error {
	// find the users that are watching this post
	fb := firego.New(postUsersURL + "/" + id)
	var v map[string]interface{}
	if err := fb.Value(&v); err != nil {
		return err
	}

	now := time.Now()
	for uid := range v {
		// notify users that this post has changed.
		fb = firego.New(userPostsURL + "/" + uid + "/" + id)
		fb.Set(now)
		// TODO (rrossney):  is it really necessary to keep a last-modified
		// timestamp under postUsers?
		fb = firego.New(postUsersURL + "/" + id + "/" + uid)
		fb.Set(now)
	}
	return nil
}

func ExampleFirebase_Set() {
	fb := firego.New("https://someapp.firebaseio.com")

	v := map[string]interface{}{
		"foo": "bar",
		"bar": 1,
		"bez": []string{"hello", "world"},
	}
	if err := fb.Set(v); err != nil {
		log.Fatal(err)
	}
}

func getPostNodes(t PostType) (map[string]PostNode, error) {
	fb := firego.New(postsURL)
	var v map[string]PostNode
	if err := fb.Value(&v); err != nil {
		return nil, err
	}
	result := make(map[string]PostNode, 0)
	for pk, pn := range v {
		if pn.Type == t {
			result[pk] = pn
		}
	}
	return result, nil
}

func ExampleFirebase_StopWatching() {
	fb := firego.New("https://someapp.firebaseio.com/some/value")
	notifications := make(chan firego.Event)
	if err := fb.Watch(notifications); err != nil {
		log.Fatal(err)
	}

	go func() {
		for _ = range notifications {
		}
		log.Println("Channel closed")
	}()
	time.Sleep(10 * time.Millisecond) // let go routine start

	fb.StopWatching()
}