package torrents

import (
	"encoding/json"
	"errors"
	"net/http"
	"sort"
	"strconv"

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

// DownloadHandler downloads a movie via polochon
func DownloadHandler(env *web.Env, w http.ResponseWriter, r *http.Request) error {
	var data struct {
		URL string `json:"url"`
	}
	err := json.NewDecoder(r.Body).Decode(&data)
	if err != nil {
		return env.RenderError(w, errors.New("failed to get the url"))
	}

	if data.URL == "" {
		return env.RenderError(w, errors.New("no given url"))
	}

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

	client, err := user.NewPapiClient()
	if err != nil {
		return env.RenderError(w, err)
	}

	err = client.AddTorrent(data.URL)
	if err != nil {
		return env.RenderError(w, err)
	}

	return env.RenderOK(w, "Torrent added")
}

// ListHandler downloads a torrent via polochon
func ListHandler(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"))
	}

	client, err := user.NewPapiClient()
	if err != nil {
		return env.RenderError(w, err)
	}

	torrents, err := client.GetTorrents()
	if err != nil {
		return env.RenderError(w, err)
	}

	return env.RenderJSON(w, torrents)
}

// RemoveHandler removes a torrents via polochon
func RemoveHandler(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"))
	}

	// Get the torrent ID from the URL
	vars := mux.Vars(r)
	torrentID, err := strconv.Atoi(vars["id"])
	if err != nil {
		return env.RenderError(w, errors.New("invalid argument"))
	}

	client, err := user.NewPapiClient()
	if err != nil {
		return env.RenderError(w, err)
	}

	err = client.RemoveTorrent(torrentID)
	if err != nil {
		return env.RenderError(w, err)
	}

	return env.RenderOK(w, "Torrent removed")
}

// SearchHandler search for torrents
func SearchHandler(env *web.Env, w http.ResponseWriter, r *http.Request) error {
	log := env.Log.WithFields(logrus.Fields{
		"function": "torrents.SearchHandler",
	})

	vars := mux.Vars(r)
	searchType := vars["type"]
	searchStr := vars["search"]

	// Get the appropriate torrenters
	var torrenters []polochon.Torrenter
	switch searchType {
	case "movies":
		torrenters = env.Config.MovieTorrenters
	case "shows":
		torrenters = env.Config.ShowTorrenters
	default:
		return env.RenderError(w, errors.New("invalid search type"))
	}

	log.Debugf("searching for %s torrents for the query %q", searchType, searchStr)

	// Search for torrents
	results := []*polochon.Torrent{}
	for _, torrenter := range torrenters {
		torrents, err := torrenter.SearchTorrents(searchStr)
		if err != nil {
			log.Warn(err)
			continue
		}

		if torrents == nil {
			continue
		}

		results = append(results, torrents...)
	}

	// Sort by seeds
	sort.Sort(BySeed(results))

	return env.RenderJSON(w, results)
}

// BySeed is an helper to sort torrents by seeders
type BySeed []*polochon.Torrent

func (t BySeed) Len() int           { return len(t) }
func (t BySeed) Swap(i, j int)      { t[i], t[j] = t[j], t[i] }
func (t BySeed) Less(i, j int) bool { return t[i].Seeders > t[j].Seeders }