package api

import (
	"encoding/json"
	"errors"
	"strconv"

	"srs.epita.fr/fic-server/libfic"

	"github.com/julienschmidt/httprouter"
)

func init() {
	router.GET("/api/exercices/", apiHandler(listExercices))

	router.GET("/api/exercices/:eid", apiHandler(exerciceHandler(showExercice)))
	router.PUT("/api/exercices/:eid", apiHandler(updateExercice))
	router.DELETE("/api/exercices/:eid", apiHandler(deleteExercice))
}

func listExercices(_ httprouter.Params, body []byte) (interface{}, error) {
	// List all exercices
	return fic.GetExercices()
}

func showExercice(exercice fic.Exercice, body []byte) (interface{}, error) {
	return exercice, nil
}

func deleteExercice(ps httprouter.Params, body []byte) (interface{}, error) {
	if eid, err := strconv.Atoi(ps.ByName("eid")); err != nil {
		return nil, err
	} else if exercice, err := fic.GetExercice(int64(eid)); err != nil {
		return nil, err
	} else {
		return exercice.Delete()
	}
}

type uploadedExercice struct {
	Title     string
	Statement string
	Depend    *int64
	Gain      int
	VideoURI  string
}

func updateExercice(ps httprouter.Params, body []byte) (interface{}, error) {
	if eid, err := strconv.Atoi(ps.ByName("eid")); err != nil {
		return nil, err
	} else if exercice, err := fic.GetExercice(int64(eid)); err != nil {
		return nil, err
	} else {
		// Update an exercice
		var ue uploadedExercice
		if err := json.Unmarshal(body, &ue); err != nil {
			return nil, err
		}

		if len(ue.Title) == 0 {
			return nil, errors.New("Exercice's title not filled")
		}

		if ue.Depend != nil {
			if _, err := fic.GetExercice(*ue.Depend); err != nil {
				return nil, err
			}
		}

		exercice.Title = ue.Title
		exercice.Statement = ue.Statement
		exercice.Depend = ue.Depend
		exercice.Gain = int64(ue.Gain)
		exercice.VideoURI = ue.VideoURI

		return exercice.Update()
	}
}

func createExercice(theme fic.Theme, body []byte) (interface{}, error) {
	// Create a new exercice
	var ue uploadedExercice
	if err := json.Unmarshal(body, &ue); err != nil {
		return nil, err
	}

	if len(ue.Title) == 0 {
		return nil, errors.New("Title not filled")
	}

	var depend *fic.Exercice = nil
	if ue.Depend != nil {
		if d, err := fic.GetExercice(*ue.Depend); err != nil {
			return nil, err
		} else {
			depend = &d
		}
	}

	return theme.AddExercice(ue.Title, ue.Statement, depend, ue.Gain, ue.VideoURI)
}

type uploadedKey struct {
	Name string
	Key  string
}

func createExerciceKey(theme fic.Theme, exercice fic.Exercice, body []byte) (interface{}, error) {
	var uk uploadedKey
	if err := json.Unmarshal(body, &uk); err != nil {
		return nil, err
	}

	if len(uk.Key) == 0 {
		return nil, errors.New("Key not filled")
	}

	return exercice.AddRawKey(uk.Name, uk.Key)
}

type uploadedHint struct {
	Title    string
	Content  string
	Cost     int64
}

func createExerciceHint(theme fic.Theme, exercice fic.Exercice, body []byte) (interface{}, error) {
	var uh uploadedHint
	if err := json.Unmarshal(body, &uh); err != nil {
		return nil, err
	}

	if len(uh.Content) == 0 {
		return nil, errors.New("Hint's content not filled")
	}

	return exercice.AddHint(uh.Title, uh.Content, uh.Cost)
}