package main

import (
	"encoding/json"
	"fmt"
	"html/template"
	"net/http"

	"github.com/gorilla/mux"
)

// HandleIndex takes care of rendering our embedded template out to the client
func (a *App) HandleIndex(w http.ResponseWriter, r *http.Request) {
	t, err := template.ParseFS(a.templateFS, "templates/index.html")
	if err != nil {
		Logger.Printf("While parsing template for index: %s", err)
		http.Error(w, "Internal server error ( template )",
			http.StatusInternalServerError)
		return
	}

	err = t.Execute(w,
		struct {
			App   *App
			Local bool
		}{
			a,
			isLocal(r.RemoteAddr),
		})
	if err != nil {
		Logger.Printf("While Rendering template: %s", err)
	}
	Logger.Printf("Client %s Index page", r.RemoteAddr)
}

// HandleInstall takes the HTTP requests for installing a game from a URL
// or local file path
func (a *App) HandleInstall(w http.ResponseWriter, r *http.Request) {
	err := r.ParseForm()
	if err != nil {
		Logger.Printf("Installer: While parsing form: %s", err)
		http.Error(w, fmt.Sprintf("Invalid form: %s", err), 400)
		return
	}

	uri := r.Form.Get("uri")

	Logger.Printf("Installer: Sending request for: %s to downloader", uri)

	go func() {
		g, err := a.Library.ExtractSmart(uri)
		if err != nil {
			Logger.Printf("Error encountered installing: %s", err)
		}
		Logger.Printf("Extracted game: %s", g)
	}()

	http.Redirect(w, r, "/", 302)
}

// HandleDownload takes care of exporting our games out to an HTTP request
//
// @Summary Handles downloading of a game
// @Description Streams a tarball of the game including the ACF file down
// @Description to the client machine
// @Tags all, game
// @Param game path string true "Name of the videogame"
// @Header 200 {string} Estimated-size "Estimated game size in bytes"
// @Accept  json
// @Produce  application/tar
// @Success 200
// @Router /lib/game/{game} [get]
func (a *App) HandleDownload(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	game := vars["game"]

	g, ok := a.Library.Games()[game]
	if !ok {
		Logger.Printf("Missing: %s", game)
		http.Error(w, "Game is missing", 404)
		return
	}

	w.Header().Add("Content-type", "application/tar")
	w.Header().Add("Estimated-size", fmt.Sprintf("%d", g.Size))

	Logger.Printf("Client %s is downloading: %s", r.RemoteAddr, game)

	err := a.Library.Package(g.Name, w)
	if err != nil {
		Logger.Printf("Encountered download error: %s", err)
	}
	return
}

// HandleDelete removes the game in question, though it doesn't
// spawn any background processes it usually completes fast enough.
// TODO: Fix if the request taking too long becomes an issue
func (a *App) HandleDelete(w http.ResponseWriter, r *http.Request) {
	err := r.ParseForm()
	if err != nil {
		Logger.Printf("Installer: While parsing form: %s", err)
		http.Error(w, fmt.Sprintf("Invalid form: %s", err), 400)
		return
	}

	game := r.PostForm.Get("name")

	if game == "" {
		Logger.Println("Delete: No game specified")
		http.Error(w, "Game param required", 400)
		return
	}

	g, ok := a.Library.Games()[game]
	if !ok {
		Logger.Printf("Missing: %s", game)
		http.Error(w, "Game is missing", 404)
		return
	}

	err = a.Library.Delete(g.Name)
	if err != nil {
		Logger.Printf("Error removing game: %s", err)
		http.Error(w, fmt.Sprintf("Error removing game: %s", err), 500)
		return
	}
	Logger.Printf("Removed game: %s", game)

	http.Redirect(w, r, "/", 302)
}

// HandleStats dumps out some internal statistics of installation which
// is then parsed by some JS for a progress bar and such
func (a *App) HandleStats() http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Header().Add("Content-type", "application/json")

		enc := json.NewEncoder(w)

		enc.SetIndent("", "  ")

		err := enc.Encode(a.Library.Status())
		if err != nil {
			Logger.Println("While encoding Status: ", err)
		}
		return
	})
}

// HandleSetLib sets a new library path
func (a *App) HandleSetLib(w http.ResponseWriter, r *http.Request) {
	err := r.ParseForm()
	if err != nil {
		Logger.Printf("Setlib: While parsing form: %s", err)
		http.Error(w, fmt.Sprintf("Invalid form: %s", err), 400)
		return
	}

	a.Library.ProcessLibrary(r.Form.Get("path"))

	http.Redirect(w, r, "/", 302)
}