package channels

import (
	"errors"
	"sync"
)

type ChannelManager struct {
	channels     map[string]*Channel
	channelsLock sync.RWMutex

	channelStreams     map[string]*ChannelStreams
	channelStreamsLock sync.RWMutex
}

func (manager *ChannelManager) Channel(uuid string) *Channel {
	manager.channelsLock.RLock()
	defer manager.channelsLock.RUnlock()

	channel, ok := manager.channels[uuid]
	if !ok {
		return nil
	}

	return channel
}

func (manager *ChannelManager) Streams(uuid string) *ChannelStreams {
	manager.channelStreamsLock.RLock()
	defer manager.channelStreamsLock.RUnlock()

	streams, ok := manager.channelStreams[uuid]
	if !ok {
		return nil
	}

	return streams
}

func (manager *ChannelManager) Close(uuid string) (err error) {
	manager.channelsLock.Lock()
	defer manager.channelsLock.Unlock()

	manager.channelStreamsLock.Lock()
	defer manager.channelStreamsLock.Unlock()

	_, ok := manager.channels[uuid]
	if !ok {
		err = errors.New("channel uuid is not known")
		return
	}

	delete(manager.channels, uuid)
	delete(manager.channelStreams, uuid)

	return
}

func (manager *ChannelManager) Open(uuid string) (channel *Channel, err error) {
	manager.channelsLock.Lock()
	defer manager.channelsLock.Unlock()

	if _, ok := manager.channels[uuid]; ok {
		err = errors.New("channel uuid is already in use")
		return
	}

	manager.channelStreamsLock.Lock()
	defer manager.channelStreamsLock.Unlock()

	channel = new(Channel)
	manager.channels[uuid] = channel

	manager.channelStreams[uuid] = new(ChannelStreams)

	return
}