package movies

import (
	"errors"
	"fmt"
	"log"
	"net/http"

	"github.com/gorilla/mux"
	"github.com/odwrtw/papi"
	polochon "github.com/odwrtw/polochon/lib"
	"github.com/sirupsen/logrus"
	"gitlab.quimbo.fr/odwrtw/canape/backend/auth"
	"gitlab.quimbo.fr/odwrtw/canape/backend/backend"
	"gitlab.quimbo.fr/odwrtw/canape/backend/config"
	"gitlab.quimbo.fr/odwrtw/canape/backend/subtitles"
	"gitlab.quimbo.fr/odwrtw/canape/backend/users"
	"gitlab.quimbo.fr/odwrtw/canape/backend/web"
)

// PolochonMoviesHandler will returns movies from Polochon
func PolochonMoviesHandler(env *web.Env, w http.ResponseWriter, r *http.Request) error {
	// Get the user from the request
	v := auth.GetCurrentUser(r, env.Log)
	user, ok := v.(*users.User)
	if !ok {
		return env.RenderError(w, fmt.Errorf("invalid user type"))
	}

	// Get the polochon movies of the user
	movies, err := getPolochonMovies(user, env)
	if err != nil {
		return env.RenderError(w, err)
	}

	// Create a new polochon Detailer to get infos about the movies we just got
	var polochonConfig config.UserPolochon
	err = user.GetConfig("polochon", &polochonConfig)
	if err != nil {
		return err
	}

	// Get details with the polochon Detailer for each polochon.Movies we have
	for _, m := range movies {
		// First try from the db
		first := []polochon.Detailer{env.Backend.Detailer}
		// Then try from the polochon detailer
		detailers := env.Config.MovieDetailers
		err := m.GetAndFetch(env, first, detailers)
		if err != nil {
			env.Log.Error(err)
		}

		// Look only for torrents in db
		torrenters := []polochon.Torrenter{env.Backend.Torrenter}
		err = m.GetTorrents(env, torrenters)
		if err != nil {
			env.Log.Errorf("error while getting movie torrents : %s", err)
			continue
		}
	}

	return env.RenderJSON(w, movies)
}

// RefreshMovieHandler refreshes details for a movie
func RefreshMovieHandler(env *web.Env, w http.ResponseWriter, r *http.Request) error {
	vars := mux.Vars(r)
	id := vars["id"]

	// Get the user
	v := auth.GetCurrentUser(r, env.Log)
	user, ok := v.(*users.User)
	if !ok {
		return fmt.Errorf("invalid user type")
	}

	// Create a new papi client
	client, err := user.NewPapiClient()
	if err != nil {
		return env.RenderError(w, err)
	}

	// Get the polochon movie
	pMovie, err := client.GetMovie(id)
	if err != nil && err != papi.ErrResourceNotFound {
		log.Println("Error getting movie ", err)
	}

	// Check if the movie is wishlisted
	isWishlisted, err := backend.IsMovieWishlisted(env.Database, user.ID, id)
	if err != nil {
		log.Println("Error getting wishlisted movie ", err)
	}

	// Create a new movie
	m := New(id, client, pMovie, isWishlisted, env.Config.PublicDir, env.Config.ImgURLPrefix)

	// Refresh the movie's infos
	if err := m.Refresh(env, env.Config.MovieDetailers); err != nil {
		env.Log.Error(err)
	}

	// Refresh the movie's torrents
	if err := m.RefreshTorrents(env, env.Config.MovieTorrenters); err != nil {
		env.Log.Error(err)
	}

	return env.RenderJSON(w, m)
}

// SearchMovie will search movie
func SearchMovie(env *web.Env, w http.ResponseWriter, r *http.Request) error {
	vars := mux.Vars(r)
	search := vars["search"]

	v := auth.GetCurrentUser(r, env.Log)
	user, ok := v.(*users.User)
	if !ok {
		return env.RenderError(w, errors.New("invalid user"))
	}

	// Create a new papi client
	client, err := user.NewPapiClient()
	if err != nil {
		return env.RenderError(w, err)
	}

	// Get the user's polochon movies
	pMovies, err := client.GetMovies()
	if err != nil {
		return env.RenderError(w, err)
	}

	// Get the user's wishlisted movies
	moviesWishlist, err := backend.GetMovieWishlist(env.Database, user.ID)
	if err != nil {
		return env.RenderError(w, err)
	}

	var movies []*polochon.Movie
	searchers := env.Config.MovieSearchers
	// Search for the movie with all the Searchers
	for _, searcher := range searchers {
		result, err := searcher.SearchMovie(search, env.Log)
		if err != nil {
			env.Log.Errorf("error while searching movie : %s", err)
			continue
		}
		movies = append(movies, result...)
	}

	env.Log.Debugf("got %d movies doing search %q", len(movies), search)
	movieList := []*Movie{}
	// For each movie found, fill the details
	for _, m := range movies {
		pMovie, _ := pMovies.Has(m.ImdbID)
		movie := New(
			m.ImdbID,
			client,
			pMovie,
			moviesWishlist.IsMovieInWishlist(m.ImdbID),
			env.Config.PublicDir,
			env.Config.ImgURLPrefix,
		)

		// First check in the DB
		before := []polochon.Detailer{env.Backend.Detailer}
		// Then with the default detailers
		after := env.Config.MovieDetailers
		err := movie.GetAndFetch(env, before, after)
		if err != nil {
			env.Log.Errorf("error while getting movie details : %s", err)
			continue
		}

		// Look only for torrents in db
		torrenters := []polochon.Torrenter{env.Backend.Torrenter}
		err = movie.GetTorrents(env, torrenters)
		if err != nil {
			env.Log.Errorf("error while getting movie torrents : %s", err)
			continue
		}

		movieList = append(movieList, movie)
	}

	return env.RenderJSON(w, movieList)
}

// PolochonDeleteHandler deletes the movie from polochon
func PolochonDeleteHandler(env *web.Env, w http.ResponseWriter, r *http.Request) error {
	vars := mux.Vars(r)
	id := vars["id"]

	log := env.Log.WithFields(logrus.Fields{
		"imdb_id":  id,
		"function": "movies.DeleteHandler",
	})
	log.Debugf("deleting movie")

	// Get the user
	v := auth.GetCurrentUser(r, env.Log)
	user, ok := v.(*users.User)
	if !ok {
		return env.RenderError(w, errors.New("invalid user type"))
	}

	// Create a new papi client
	client, err := user.NewPapiClient()
	if err != nil {
		return env.RenderError(w, err)
	}

	// Delete the movie
	return client.Delete(&papi.Movie{ImdbID: id})
}

// AddToWishlist adds a movie to the user's wishlist
func AddToWishlist(env *web.Env, w http.ResponseWriter, r *http.Request) error {
	vars := mux.Vars(r)
	id := vars["id"]

	v := auth.GetCurrentUser(r, env.Log)
	user, ok := v.(*users.User)
	if !ok {
		return env.RenderError(w, errors.New("invalid user type"))
	}

	if err := backend.AddMovieToWishlist(env.Database, user.ID, id); err != nil {
		return env.RenderError(w, err)
	}

	return env.RenderOK(w, "Movie added to wishlist")
}

// DeleteFromWishlist deletes a movie from the user's wishlist
func DeleteFromWishlist(env *web.Env, w http.ResponseWriter, r *http.Request) error {
	vars := mux.Vars(r)
	id := vars["id"]

	v := auth.GetCurrentUser(r, env.Log)
	user, ok := v.(*users.User)
	if !ok {
		return env.RenderError(w, errors.New("invalid user type"))
	}

	if err := backend.DeleteMovieFromWishlist(env.Database, user.ID, id); err != nil {
		return env.RenderError(w, err)
	}

	return env.RenderOK(w, "Movie deleted from wishlist")
}

// GetWishlistHandler returns the wishlisted movies of a user
func GetWishlistHandler(env *web.Env, w http.ResponseWriter, r *http.Request) error {
	v := auth.GetCurrentUser(r, env.Log)
	user, ok := v.(*users.User)
	if !ok {
		return env.RenderError(w, errors.New("invalid user type"))
	}

	// Create a new papi client
	client, err := user.NewPapiClient()
	if err != nil {
		return env.RenderError(w, err)
	}

	// Get the user's polochon movies
	pMovies, err := client.GetMovies()
	if err != nil {
		return env.RenderError(w, err)
	}

	// Get the user's wishlisted movies
	moviesWishlist, err := backend.GetMovieWishlist(env.Database, user.ID)
	if err != nil {
		return env.RenderError(w, err)
	}

	movieList := []*Movie{}
	// For each movie found, fill the details
	for _, imdbID := range moviesWishlist.List() {
		pMovie, _ := pMovies.Has(imdbID)
		movie := New(
			imdbID,
			client,
			pMovie,
			moviesWishlist.IsMovieInWishlist(imdbID),
			env.Config.PublicDir,
			env.Config.ImgURLPrefix,
		)
		// First check in the DB
		before := []polochon.Detailer{env.Backend.Detailer}
		// Then with the default detailers
		after := env.Config.MovieDetailers
		err := movie.GetAndFetch(env, before, after)
		if err != nil {
			env.Log.Errorf("error while getting movie details : %s", err)
			continue
		}

		// Look only for torrents in db
		torrenters := []polochon.Torrenter{env.Backend.Torrenter}
		err = movie.GetTorrents(env, torrenters)
		if err != nil {
			env.Log.Errorf("error while getting movie torrents : %s", err)
			continue
		}

		movieList = append(movieList, movie)
	}

	return env.RenderJSON(w, movieList)
}

// RefreshMovieSubtitlesHandler refreshes details for a movie
func RefreshMovieSubtitlesHandler(env *web.Env, w http.ResponseWriter, r *http.Request) error {
	vars := mux.Vars(r)
	id := vars["id"]

	// Get the user
	v := auth.GetCurrentUser(r, env.Log)
	user, ok := v.(*users.User)
	if !ok {
		return fmt.Errorf("invalid user type")
	}

	// Create a new papi client
	client, err := user.NewPapiClient()
	if err != nil {
		return env.RenderError(w, err)
	}

	movie := &papi.Movie{ImdbID: id}
	refreshSubs, err := client.UpdateSubtitles(movie)
	if err != nil {
		return env.RenderError(w, err)
	}

	subs := []subtitles.Subtitle{}
	for _, lang := range refreshSubs {
		subtitleURL, _ := client.SubtitleURL(movie, lang)
		subs = append(subs, subtitles.Subtitle{
			Language: lang,
			URL:      subtitleURL,
			VVTFile:  fmt.Sprintf("/movies/%s/subtitles/%s", id, lang),
		})
	}

	return env.RenderJSON(w, subs)
}

// DownloadVVTSubtitle returns a vvt subtitle for the movie
func DownloadVVTSubtitle(env *web.Env, w http.ResponseWriter, r *http.Request) error {
	vars := mux.Vars(r)
	id := vars["id"]
	lang := vars["lang"]

	// Get the user
	v := auth.GetCurrentUser(r, env.Log)
	user, ok := v.(*users.User)
	if !ok {
		return fmt.Errorf("invalid user type")
	}

	// Create a new papi client
	client, err := user.NewPapiClient()
	if err != nil {
		return env.RenderError(w, err)
	}

	url, err := client.SubtitleURL(&papi.Movie{ImdbID: id}, lang)
	if err != nil {
		return env.RenderError(w, err)
	}

	return subtitles.ConvertSubtitle(url, w)
}