package main

import (
	"errors"
)

type MemDB struct {
	MovieList  map[int]*Movie
	TagList    map[int]*Tag
	TagToMovie map[string][]int
	mId        int
	tId        int
}

func CreateMemDB() *MemDB {
	return &MemDB{make(map[int]*Movie), make(map[int]*Tag), make(map[string][]int), 1, 1}
}

func (m *MemDB) CreateMovie(title, imdb string) (Movie, error) {
	mov := Movie{m.mId, title, imdb, []*Tag{}}
	m.MovieList[m.mId] = &mov
	m.mId = m.mId + 1
	return mov, nil
}

func (m *MemDB) UpdateMovie(id int, title string, imdb string) error {
	m.MovieList[id].Title = title
	m.MovieList[id].Imdb = imdb
	return nil
}
func (m *MemDB) GetMovies(limit ...int) ([]Movie, error) {
	lim := -1
	var res []Movie
	if len(limit) > 0 {
		lim = limit[0]
	}
	count := 0
	for _, mov := range m.MovieList {
		if count == lim {
			break
		}
		res = append(res, *mov)
	}
	return res, nil
}

func (m *MemDB) GetMovieById(id int) (Movie, error) {
	mov := m.MovieList[id]
	if mov.ID == 0 {
		return *mov, errors.New("No movie found!")
	} else {
		return *mov, nil
	}
}

func (m *MemDB) GetMoviesByTag(id int) ([]Movie, error) {
	tag := m.TagList[id]
	if tag.Name == "" {
		return []Movie{}, nil //nonexistent tag is a valid option
	}
	var res []Movie
	movies := m.TagToMovie[tag.Name]
	for _, movID := range movies {
		res = append(res, *m.MovieList[movID])
	}
	return res, nil
}

func (m *MemDB) DeleteMovie(id int) error {
	delete(m.MovieList, id)
	return nil
}

func (m *MemDB) CreateTag(name string) (Tag, error) {
	tag := Tag{m.tId, name}
	m.TagList[m.tId] = &tag
	m.tId = m.tId + 1
	return tag, nil
}

func (m *MemDB) DeleteTag(id int) error {
	tag := m.TagList[id]
	delete(m.TagList, id)
	delete(m.TagToMovie, tag.Name)
	return nil
}

func (m *MemDB) GetTags(limit ...int) ([]Tag, error) {
	lim := -1
	var res []Tag
	if len(limit) > 0 {
		lim = limit[0]
	}
	count := 0
	for _, tag := range m.TagList {
		if count == lim {
			break
		}
		res = append(res, *tag)
	}
	return res, nil
}

func (m *MemDB) GetTagById(id int) (Tag, error) {
	tag := m.TagList[id]
	if tag.ID == 0 {
		return *tag, errors.New("No tag found!")
	} else {
		return *tag, nil
	}
}

func (m *MemDB) TagMovie(tagId int, movieId int) error {
	mov := m.MovieList[movieId]
	tag := m.TagList[tagId]
	if mov.ID == 0 {
		return errors.New("No movie found for tagging!")
	}
	if tag.ID == 0 {
		return errors.New("No tag found for tagging!")
	}
	m.TagToMovie[tag.Name] = append(m.TagToMovie[tag.Name], movieId)
	mov.Tags = append(mov.Tags, tag)

	return nil
}

func (m *MemDB) UnTagMovie(tagId int, movieId int) error {
	mov := m.MovieList[movieId]
	tag := m.TagList[tagId]
	if mov.ID == 0 {
		return errors.New("No movie found for untagging!")
	}
	if tag.ID == 0 {
		return errors.New("No tag found for untagging!")
	}
	for i, v := range m.TagToMovie[tag.Name] {
		if v == movieId {
			m.TagToMovie[tag.Name][i] = m.TagToMovie[tag.Name][len(m.TagToMovie[tag.Name])-1]
			m.TagToMovie[tag.Name] = m.TagToMovie[tag.Name][:len(m.TagToMovie[tag.Name])-1]
			break
		}
	}

	return nil
}