package memory

import (
	"errors"
	"fmt"

	"git.andreafazzi.eu/andrea/probo/client"
	"git.andreafazzi.eu/andrea/probo/models"
	"github.com/google/uuid"
)

func (s *MemoryProboCollectorStore) getCollectionFromID(id string) *models.Collection {
	s.lock.RLock()
	defer s.lock.RUnlock()

	collection, ok := s.collections[id]
	if ok {
		return collection
	}

	return nil
}

func (s *MemoryProboCollectorStore) ReadAllCollections() ([]*models.Collection, error) {
	result := make([]*models.Collection, 0)
	for id := range s.collections {
		if collection := s.getCollectionFromID(id); collection != nil {
			result = append(result, collection)
		}
	}
	return result, nil
}

func (s *MemoryProboCollectorStore) CreateCollection(r *client.CreateUpdateCollectionRequest) (*models.Collection, error) {
	q, _, err := s.createOrUpdateCollection(r, "")
	return q, err
}

func (s *MemoryProboCollectorStore) UpdateCollection(r *client.CreateUpdateCollectionRequest, id string) (*models.Collection, bool, error) {
	return s.createOrUpdateCollection(r, id)
}

func (s *MemoryProboCollectorStore) ReadCollectionByID(id string) (*models.Collection, error) {
	if id == "" {
		return nil, errors.New("ID should not be an empty string!")
	}
	collection := s.getCollectionFromID(id)
	if collection == nil {
		return nil, fmt.Errorf("Collection ID %v not found in the store", id)
	}
	return collection, nil
}

func (s *MemoryProboCollectorStore) DeleteCollection(r *client.DeleteCollectionRequest) (*models.Collection, error) {
	return s.deleteCollection(r.ID)
}

func (s *MemoryProboCollectorStore) deleteCollection(id string) (*models.Collection, error) {
	s.lock.Lock()
	defer s.lock.Unlock()

	collection := s.collections[id]
	if collection == nil {
		return nil, fmt.Errorf("Trying to delete a collection that doesn't exist in memory (ID: %v)", id)
	}

	delete(s.collections, id)

	return collection, nil
}

func (s *MemoryProboCollectorStore) createOrUpdateCollection(r *client.CreateUpdateCollectionRequest, id string) (*models.Collection, bool, error) {
	var collection *models.Collection

	if r.Collection == nil {
		return nil, false, errors.New("A request was made passing a nil collection object")
	}

	if id != "" { // we're updating a collection
		collection = s.getCollectionFromID(id)
		if collection == nil { // Quiz is not present in the store
			return nil, false, fmt.Errorf("Collection ID %v doesn't exist in the store!", id)
		}
	} else {
		id = uuid.New().String()
		collection = new(models.Collection)
	}

	collection.Name = r.Collection.Name
	collection.Query = r.Collection.Query

	collection.Quizzes = s.query(collection.Query)

	return s.createCollectionFromID(id, collection), true, nil
}

func (s *MemoryProboCollectorStore) query(query string) []*models.Quiz {
	s.lock.Lock()
	defer s.lock.Unlock()

	result := make([]*models.Quiz, 0)

	for _, quiz := range s.quizzes {
		for _, tag := range quiz.Tags {
			if query == tag.Name {
				result = append(result, quiz)
				break
			}
		}
	}

	return result
}

func (s *MemoryProboCollectorStore) createCollectionFromID(id string, collection *models.Collection) *models.Collection {
	s.lock.Lock()
	defer s.lock.Unlock()

	collection.ID = id

	s.collections[id] = collection

	return collection
}