service.go

package golfstream

import (
	"fmt"
	"github.com/Monnoroch/golfstream/backend"
	"github.com/Monnoroch/golfstream/errors"
	"github.com/Monnoroch/golfstream/stream"
	"sync"
)

type backendStreamT struct {
	bs      backend.BackendStream
	back    string
	bstream string
	async   bool

	lock sync.Mutex
	subs []backend.Stream

	// protected by service lock
	refcnt int
}

func (self *backendStreamT) addSub(s backend.Stream, hFrom int, hTo int) (uint, uint, error) {
	self.lock.Lock()
	defer self.lock.Unlock()

	self.subs = append(self.subs, s)
	return self.bs.Interval(hFrom, hTo)
}

func (self *backendStreamT) rmSub(s backend.Stream) bool {
	self.lock.Lock()
	defer self.lock.Unlock()

	for i, v := range self.subs {
		if v == s {
			self.subs = append(self.subs[:i], self.subs[i+1:]...)
			return true
		}
	}
	return false
}

func (self *backendStreamT) Add(evt stream.Event) error {
	self.lock.Lock()
	defer self.lock.Unlock()

	if self.async {
		errs := make([]error, len(self.subs))
		wg := sync.WaitGroup{}
		wg.Add(len(self.subs))
		for i, s := range self.subs {
			go func(n int, st backend.Stream) {
				defer wg.Done()
				errs[n] = st.Add(evt)
			}(i, s)
		}
		wg.Wait()
		return errors.List().AddAll(errs).Err()
	} else {
		errs := errors.List()
		for _, v := range self.subs {
			errs.Add(v.Add(evt))
		}
		return errs.Err()
	}
}

func (self *backendStreamT) Read(from uint, to uint) (stream.Stream, error) {
	return self.bs.Read(from, to)
}

func (self *backendStreamT) Del(from uint, to uint) (bool, error) {
	return self.bs.Del(from, to)
}

func (self *backendStreamT) Interval(from int, to int) (uint, uint, error) {
	return self.bs.Interval(from, to)
}

func (self *backendStreamT) Len() (uint, error) {
	return self.bs.Len()
}

func (self *backendStreamT) Close() error {
	return self.bs.Close()
}

type valueStream struct {
	evt          stream.Event
	iterDone     bool
	markerIssued bool
	finished     bool
}

func (self *valueStream) set(evt stream.Event) {
	self.evt = evt
	self.iterDone = false
	self.markerIssued = false
}

var marker = errors.New("valueStream marker")

func (self *valueStream) Next() (stream.Event, error) {
	if self.finished {
		return nil, stream.EOI
	}

	if self.iterDone {
		self.markerIssued = true
		return nil, marker
	}

	self.iterDone = true
	return self.evt, nil
}

type streamT struct {
	bs   *backendStreamT
	defs []string

	val  *valueStream
	data stream.Stream
}

/*
This one is a bit tricky.
So the general idea is that we set a new value in the valueStream object
which then gets pulled by a function code in stream.Run()
which then gets pulled by self.data.Next() here.
The problem is that the function code does't return one event for each input: it can be 1:N or K:1.
So, the first problem is that we might need to call self.data.Next() multimple times, and
a second is that valueStream.Next() can be called several times for each self.data.Next().
So, what we do is make the value stream return the set event once, and the second time it's called we return a marker error,
and also set a flag, that this marker was issued. Then we call self.data.Next() in a loop until the marker was issued.
We can not directly check if the error is the marker because function code can change the error by, for example,
wrapping it in a errors list, so we need a flag.
So we loop until the  marker was issued and we pull 0 or more events and add them all to self.bs,
colecting the errors while doing it.
*/
func (self *streamT) Add(evt stream.Event) error {
	self.val.set(evt)

	errs := errors.List()
	for {
		res, err := self.data.Next()
		if err != nil {
			if self.val.markerIssued {
				if err != marker { // marker was transformed
					// TODO: log error? Not sure if we need it.
				}
				return errs.Err()
			}
			return errs.Add(err).Err()
		}
		if err := self.bs.Add(res); err != nil {
			errs.Add(err)
		}
	}
}

func (self *streamT) Read(from uint, to uint) (stream.Stream, error) {
	return self.bs.Read(from, to)
}

func (self *streamT) Del(from uint, to uint) (bool, error) {
	return self.bs.Del(from, to)
}

func (self *streamT) Interval(from int, to int) (uint, uint, error) {
	return self.bs.Interval(from, to)
}

func (self *streamT) Len() (uint, error) {
	return self.bs.Len()
}

func (self *streamT) Close() error {
	self.val.finished = true
	return nil
}

type serviceBackend struct {
	back  backend.Backend
	name  string
	async bool

	lock     sync.Mutex
	bstreams map[string]*backendStreamT
	streams  map[string]*streamT
}

func (self *serviceBackend) Backend() backend.Backend {
	return self.back
}

func (self *serviceBackend) Streams() ([]string, []string, [][]string, error) {
	self.lock.Lock()
	defer self.lock.Unlock()

	ss := make([]string, 0, len(self.streams))
	bs := make([]string, 0, len(self.streams))
	ds := make([][]string, 0, len(self.streams))
	for k, self := range self.streams {
		ss = append(ss, k)
		bs = append(bs, self.bs.bstream)
		ds = append(ds, self.defs)
	}
	return ss, bs, ds, nil
}

func (self *serviceBackend) AddStream(bstream, name string, defs []string) (res backend.BackendStream, rerr error) {
	self.lock.Lock()
	defer self.lock.Unlock()

	if _, ok := self.streams[name]; ok {
		return nil, errors.New(fmt.Sprintf("serviceBackend.AddStream: backend with name \"%s\" already has stream \"%s\"", self.name, name))
	}

	bs, ok := self.bstreams[bstream]
	if !ok {
		bstr, err := self.back.GetStream(bstream)
		if err != nil {
			return nil, err
		}

		bs = &backendStreamT{bstr, self.name, bstream, self.async, sync.Mutex{}, []backend.Stream{bstr}, 0}
		self.bstreams[bstream] = bs
	}

	st := &valueStream{nil, false, false, false}
	data, err := stream.Run(st, defs)
	if err != nil {
		return nil, err
	}

	s := &streamT{bs, defs, st, data}
	self.streams[name] = s
	bs.refcnt += 1
	return s, nil
}

func (self *serviceBackend) rmStream(name string) (*streamT, *backendStreamT, error) {
	self.lock.Lock()
	defer self.lock.Unlock()

	s, ok := self.streams[name]
	if !ok {
		return nil, nil, errors.New(fmt.Sprintf("serviceBackend.RmStream: backend with name \"%s\" does not have stream \"%s\"", self.name, name))
	}

	delete(self.streams, name)
	s.bs.refcnt -= 1
	if s.bs.refcnt == 0 {
		delete(self.bstreams, s.bs.bstream)
		return s, s.bs, nil
	}
	return s, nil, nil
}

func (self *serviceBackend) RmStream(name string) error {
	s, bs, err := self.rmStream(name)
	if err != nil {
		return err
	}

	errs := errors.List().Add(s.Close())
	if bs != nil {
		errs.Add(bs.Close())
	}
	return errs.Err()
}

func (self *serviceBackend) GetStream(name string) (backend.BackendStream, string, error) {
	self.lock.Lock()
	defer self.lock.Unlock()

	s, ok := self.streams[name]
	if !ok {
		return nil, "", errors.New(fmt.Sprintf("serviceBackend.GetStream: backend with name \"%s\" does not have stream \"%s\"", self.name, name))
	}

	return s, s.bs.bstream, nil
}

func (self *serviceBackend) addSub(bstream string) (*backendStreamT, error) {
	self.lock.Lock()
	defer self.lock.Unlock()

	bs, ok := self.bstreams[bstream]
	if !ok {
		bstr, err := self.back.GetStream(bstream)
		if err != nil {
			return nil, err
		}

		bs = &backendStreamT{bstr, self.name, bstream, self.async, sync.Mutex{}, []backend.Stream{bstr}, 0}
		self.bstreams[bstream] = bs
	}

	bs.refcnt += 1
	return bs, nil
}

func (self *serviceBackend) AddSub(bstream string, s backend.Stream, hFrom int, hTo int) (uint, uint, error) {
	bs, err := self.addSub(bstream)
	if err != nil {
		return 0, 0, err
	}

	return bs.addSub(s, hFrom, hTo)
}

func (self *serviceBackend) rmSub(bstream string) (*backendStreamT, error) {
	self.lock.Lock()
	defer self.lock.Unlock()

	bs, ok := self.bstreams[bstream]
	if !ok {
		return nil, errors.New(fmt.Sprintf("serviceBackend.RmSub: backend with name \"%s\" does not have backend stream \"%s\"", self.name, bstream))
	}

	bs.refcnt -= 1
	if bs.refcnt == 0 {
		delete(self.bstreams, bstream)
	}
	return bs, nil
}

func (self *serviceBackend) RmSub(bstream string, s backend.Stream) (bool, error) {
	bs, err := self.rmSub(bstream)
	if err != nil {
		return false, err
	}

	return bs.rmSub(s), nil
}

func (self *serviceBackend) close() error {
	self.lock.Lock()
	defer self.lock.Unlock()

	errs := errors.List()
	for _, v := range self.streams {
		errs.Add(v.Close())
	}
	for _, v := range self.bstreams {
		errs.Add(v.Close())
	}
	return errs.Err()
}

type service struct {
	lock     sync.Mutex
	backends map[string]*serviceBackend
	async    bool
}

func (self *service) Backends() ([]string, error) {
	self.lock.Lock()
	defer self.lock.Unlock()

	res := make([]string, 0, len(self.backends))
	for k, _ := range self.backends {
		res = append(res, k)
	}
	return res, nil
}

func (self *service) AddBackend(back string, b backend.Backend) (Backend, error) {
	self.lock.Lock()
	defer self.lock.Unlock()

	if _, ok := self.backends[back]; ok {
		return nil, errors.New(fmt.Sprintf("service.AddBackend: backend with name \"%s\" already exists", back))
	}

	res := &serviceBackend{b, back, self.async, sync.Mutex{}, map[string]*backendStreamT{}, map[string]*streamT{}}
	self.backends[back] = res
	return res, nil
}

func (self *service) rmBackend(back string) (*serviceBackend, error) {
	self.lock.Lock()
	defer self.lock.Unlock()

	v, ok := self.backends[back]
	if !ok {
		return nil, errors.New(fmt.Sprintf("service.RmBackend: backend with name \"%s\" does not exist", back))
	}

	delete(self.backends, back)
	return v, nil
}

func (self *service) RmBackend(back string) error {
	v, err := self.rmBackend(back)
	if err != nil {
		return err
	}

	return v.close()
}

func (self *service) GetBackend(back string) (Backend, error) {
	self.lock.Lock()
	defer self.lock.Unlock()

	v, ok := self.backends[back]
	if !ok {
		return nil, errors.New(fmt.Sprintf("service.GetBackend: backend with name \"%s\" does not exist", back))
	}

	return v, nil
}

func (self *service) Close() error {
	self.lock.Lock()
	defer self.lock.Unlock()

	errs := errors.List()
	for _, v := range self.backends {
		errs.Add(v.close())
	}
	self.backends = nil
	return errs.Err()
}

// Create the golfstream service.
func New() Service {
	return &service{sync.Mutex{}, map[string]*serviceBackend{}, true}
}