package movies

import (
	"fmt"
	"net"
	"net/http"
	"net/url"

	"github.com/odwrtw/papi"
	"github.com/odwrtw/polochon/lib"
	"github.com/odwrtw/polochon/modules/mock"
	traktdetailer "github.com/odwrtw/polochon/modules/trakttv"
	"github.com/odwrtw/trakttv"

	"gitlab.quimbo.fr/odwrtw/canape-sql/auth"
	"gitlab.quimbo.fr/odwrtw/canape-sql/config"
	"gitlab.quimbo.fr/odwrtw/canape-sql/users"
	"gitlab.quimbo.fr/odwrtw/canape-sql/web"
)

var ErrPolochonUnavailable = fmt.Errorf("Invalid polochon address")

func getPolochonMovies(user *users.User) ([]*Movie, error) {
	movies := []*Movie{}

	var polochonConfig config.UserPolochon
	err := user.GetConfig("polochon", &polochonConfig)
	if err != nil {
		return movies, err
	}

	client, err := papi.New(polochonConfig.URL, polochonConfig.Token)
	if err != nil {
		return movies, err
	}
	pmovies, err := client.MoviesByID()
	if err != nil {
		// Catch network error for accessing specified polochon address
		if uerr, ok := err.(*url.Error); ok {
			if nerr, ok := uerr.Err.(*net.OpError); ok {
				if nerr.Op == "dial" {
					return movies, ErrPolochonUnavailable
				}

			}
		}
		return movies, err
	}
	for _, pmovie := range pmovies {
		movies = append(movies, New(pmovie.ImdbID))
	}
	return movies, nil
}

func FromPolochon(env *web.Env, w http.ResponseWriter, r *http.Request) error {

	v := auth.GetCurrentUser(r)
	user, ok := v.(*users.User)
	if !ok {
		return fmt.Errorf("invalid user type")
	}
	web.SetData(r, "user", user)

	movies, err := getPolochonMovies(user)

	if err != nil {
		// Catch network error for accessing specified polochon address
		if err == ErrPolochonUnavailable {
			web.SetData(r, "error", "Invalid address")
			return env.Rends(w, r, "movies/library")
		}

		return err
	}

	//TODO use configurable detailer
	// detailer, err := tmdb.New(&tmdb.Params{"57be344f84917b3f32c68a678f1482eb"})
	detailer, _ := mock.NewDetailer(nil)
	if err != nil {
		return err
	}

	for _, m := range movies {
		m.Detailers = []polochon.Detailer{detailer}
		err := m.GetDetails(env.Database, env.Log)
		if err != nil {
			env.Log.Error(err)
		}
	}

	env.Log.Info(movies)

	return nil
}

func ExplorePopular(env *web.Env, w http.ResponseWriter, r *http.Request) error {

	queryOption := trakttv.QueryOption{
		ExtendedInfos: []trakttv.ExtendedInfo{
			trakttv.ExtendedInfoMin,
		},
		Pagination: trakttv.Pagination{
			Page:  1,
			Limit: 20,
		},
	}
	trakt := trakttv.New(env.Config.TraktTVClientID)
	trakt.Endpoint = trakttv.ProductionEndpoint
	tmovies, err := trakt.PopularMovies(queryOption)
	if err != nil {
		return err
	}

	detailer, err := traktdetailer.New(&traktdetailer.Params{env.Config.TraktTVClientID})
	if err != nil {
		return err
	}

	movies := []*Movie{}
	ids := []string{}
	for _, m := range tmovies {
		movie := New(m.IDs.ImDB)
		movie.Detailers = []polochon.Detailer{detailer}
		err := movie.GetDetails(env.Database, env.Log)
		if err != nil {
			env.Log.Error(err)
			continue
		}
		movies = append(movies, movie)
		ids = append(ids, m.IDs.ImDB)
	}
	web.SetData(r, "movies", movies)
	return env.Rends(w, r, "movies/library")
}