package api

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

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

	"github.com/julienschmidt/httprouter"
)

func init() {
	router.GET("/api/qa/:eid", apiHandler(exerciceHandler(getExerciceQA)))
	router.POST("/api/qa/:eid", apiHandler(exerciceHandler(createExerciceQA)))

	router.PUT("/api/qa/:eid/:qid", apiHandler(qaHandler(updateExerciceQA)))
	router.DELETE("/api/qa/:eid/:qid", apiHandler(qaHandler(deleteExerciceQA)))

	router.GET("/api/qa/:eid/:qid/comments", apiHandler(qaHandler(getQAComments)))
	router.POST("/api/qa/:eid/:qid/comments", apiHandler(qaHandler(createQAComment)))

	router.DELETE("/api/qa/:eid/:qid/comments/:cid", apiHandler(qaCommentHandler(deleteQAComment)))
}

func qaHandler(f func(QAUser, fic.QAQuery, fic.Exercice, []byte) (interface{}, error)) func(QAUser, httprouter.Params, []byte) (interface{}, error) {
	return func(u QAUser, ps httprouter.Params, body []byte) (interface{}, error) {
		return exerciceHandler(func(u QAUser, exercice fic.Exercice, _ []byte) (interface{}, error) {
			if qid, err := strconv.ParseInt(string(ps.ByName("qid")), 10, 64); err != nil {
				return nil, err
			} else if query, err := exercice.GetQAQuery(qid); err != nil {
				return nil, err
			} else {
				return f(u, query, exercice, body)
			}
		})(u, ps, body)
	}
}

func qaCommentHandler(f func(QAUser, fic.QAComment, fic.QAQuery, fic.Exercice, []byte) (interface{}, error)) func(QAUser, httprouter.Params, []byte) (interface{}, error) {
	return func(u QAUser, ps httprouter.Params, body []byte) (interface{}, error) {
		return qaHandler(func(u QAUser, query fic.QAQuery, exercice fic.Exercice, _ []byte) (interface{}, error) {
			if cid, err := strconv.ParseInt(string(ps.ByName("cid")), 10, 64); err != nil {
				return nil, err
			} else if comment, err := query.GetComment(cid); err != nil {
				return nil, err
			} else {
				return f(u, comment, query, exercice, body)
			}
		})(u, ps, body)
	}
}

func getExerciceQA(_ QAUser, exercice fic.Exercice, body []byte) (interface{}, error) {
	return exercice.GetQAQueries()
}

func createExerciceQA(u QAUser, exercice fic.Exercice, body []byte) (interface{}, error) {
	// Create a new query
	var uq fic.QAQuery
	if err := json.Unmarshal(body, &uq); err != nil {
		return nil, err
	}

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

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

	if qa, err := exercice.NewQAQuery(uq.Subject, u.TeamId, u.User, uq.State); err != nil {
		return nil, err
	} else {
		var uc fic.QAComment
		if err := json.Unmarshal(body, &uc); err != nil {
			return nil, err
		}

		if uc.Content != "" {
			_, err = qa.AddComment(uc.Content, u.TeamId, u.User)
		}

		return qa, err
	}
}

func updateExerciceQA(u QAUser, query fic.QAQuery, exercice fic.Exercice, body []byte) (interface{}, error) {
	var uq fic.QAQuery
	if err := json.Unmarshal(body, &uq); err != nil {
		return nil, err
	}

	uq.Id = query.Id

	if uq.User != query.User && (uq.IdExercice != query.IdExercice || uq.IdTeam != query.IdTeam || uq.User != query.User || uq.Creation != query.Creation || uq.State != query.State || uq.Subject != query.Subject || uq.Closed != query.Closed) {
		return nil, errors.New("You can only update your own entry.")
	}

	if _, err := uq.Update(); err != nil {
		return nil, err
	} else {
		return uq, err
	}
}

func deleteExerciceQA(u QAUser, query fic.QAQuery, exercice fic.Exercice, body []byte) (interface{}, error) {
	if u.User != query.User {
		return nil, errors.New("You can only delete your own entry.")
	}

	return query.Delete()
}

func getQAComments(_ QAUser, query fic.QAQuery, exercice fic.Exercice, body []byte) (interface{}, error) {
	return query.GetComments()
}

func createQAComment(u QAUser, query fic.QAQuery, exercice fic.Exercice, body []byte) (interface{}, error) {
	// Create a new query
	var uc fic.QAComment
	if err := json.Unmarshal(body, &uc); err != nil {
		return nil, err
	}

	if len(uc.Content) == 0 {
		return nil, errors.New("Empty comment")
	}

	return query.AddComment(uc.Content, u.TeamId, u.User)
}

func deleteQAComment(u QAUser, comment fic.QAComment, query fic.QAQuery, exercice fic.Exercice, body []byte) (interface{}, error) {
	if u.User != comment.User {
		return nil, errors.New("You can only delete your own comment.")
	}

	return comment.Delete()
}