package singleflight

import "sync"

type Group struct {
	m  map[string]*Result
	mu sync.Mutex
}

func (g *Group) Do(key string, fn func() (interface{}, error)) *Result {
	g.mu.Lock()
	defer g.mu.Unlock()
	if g.m == nil {
		g.m = make(map[string]*Result)
	}
	if r, ok := g.m[key]; ok {
		return r
	}
	rdy := make(chan struct{})
	r := &Result{rdy: rdy}
	go func() {
		r.val, r.err = fn()
		close(rdy)
	}()
	g.m[key] = r
	return r
}

func (g *Group) Forget(key string) {
	g.mu.Lock()
	if g.m != nil {
		delete(g.m, key)
	}
	g.mu.Unlock()
}

type Result struct {
	rdy <-chan struct{}
	val interface{}
	err error
}

func (r *Result) Done() <-chan struct{} {
	return r.rdy
}

func (r *Result) Get() (interface{}, error) {
	<-r.rdy
	return r.val, r.err
}