package restutility
  
  import (
  	"net/http"
  	"encoding/json"
  )

  var _apiVersion = "/api/v1"
  
  func SetApiVersion(ver string) string {
  	_apiVersion = ver
  	return _apiVeresion
  }

  ////
  //// ERROR UTILITY
  ////
  
  const templateHttpErr500_EN = "An internal server error has occurred."
  const templateHttpErr500_RS = "Došlo je do greške na serveru."
  const templateHttpErr400_EN = "Bad request: invalid request body."
  const templateHttpErr400_RS = "Neispravan zahtev."
  
  type HttpError struct {
  	Error   []HttpErrorDesc `json:"error"`
  	Request string          `json:"request"`
  }
  
  type HttpErrorDesc struct {
  	Lang string `json:"lang"`
  	Desc string `json:"description"`
  }

  func RespondWithHttpError(w http.ResponseWriter,

  	req *http.Request,
  	code int,
  	httpErr []HttpErrorDesc) {
  
  	err := HttpError{
  		Error: httpErr,
  		Request: req.Method + " " + req.URL.Path,
  	}
  	w.WriteHeader(code)
  	json.NewEncoder(w).Encode(err)
  }

  func RespondWithHttpError400(w http.ResponseWriter, req *http.Request) {
  	RespondWithHttpError(w, req, http.StatusBadRequest, []HttpErrorDesc{
  		{Lang: "en", Desc: templateHttpErr400_EN},
  		{Lang: "rs", Desc: templateHttpErr400_RS},
  	})

  }

  func RespondWithHttpError500(w http.ResponseWriter, req *http.Request) {
  	RespondWithHttpError(w, req, http.StatusInternalServerError, []HttpErrorDesc{
  		{Lang: "en", Desc: templateHttpErr500_EN},
  		{Lang: "rs", Desc: templateHttpErr500_RS},
  	})

  }

  func DeliverPayload(w http.ResponseWriter, payload JSONPayload) {

  	json.NewEncoder(w).Encode(payload)
  	payload.Data = nil
  }
  
  ////
  //// HANDLER FUNC WRAPPER
  ////
  
  // wrapHandlerFunc is as wrapper function for route handlers.
  // Sets common headers and checks for token validity.

  func HandleFuncWrap(fn http.HandlerFunc) http.HandlerFunc {

  	return func(w http.ResponseWriter, req *http.Request) {
  //		@TODO: check Content-type header (must be application/json)
  //		ctype := w.Header.Get("Content-Type")
  //		if req.Method != "GET" && ctype != "application/json" {
  //			replyWithHttpError(w, req, http.StatusBadRequest,
  //				"Not a supported content type: " + ctype)
  //		}
  
  		w.Header().Set("Access-Control-Allow-Origin", "*")
  		w.Header().Set("Access-Control-Allow-Methods",
  			`POST,
  			GET,
  			PUT,
  			DELETE,
  			OPTIONS`)
  		w.Header().Set("Access-Control-Allow-Headers",
  			`Accept,
  			Content-Type,
  			Content-Length,
  			Accept-Encoding,
  			X-CSRF-Token,
  			Authorization`)
  		w.Header().Set("Content-Type", "application/json; charset=utf-8")
  
  		if req.Method == "OPTIONS" {
  			return
  		}

  		if req.URL.Path != _apiVersion + "/token/new" {

  			token := req.Header.Get("Authorization")

  			if _, err := ParseAPIToken(token); err != nil {
  				RespondWithHttpError(w, req, http.StatusUnauthorized,

  					[]HttpErrorDesc{

  						{Lang: "en", Desc: "Unauthorized request."},
  						{Lang: "rs", Desc: "Neautorizovani zahtev."},

  					})
  				return
  			}
  		}
  
  		err := req.ParseForm()
  		if err != nil {

  			RespondWithHttpError(w, req, http.StatusBadRequest,

  				[]HttpErrorDesc{

  					{Lang: "en", Desc: templateHttpErr400_EN},
  					{Lang: "rs", Desc: templateHttpErr400_RS},

  				})
  			return
  		}
  		fn(w, req)
  	}
  }
  
  ////
  //// NOT FOUND HANDLER
  ////

  func NotFoundHandler(w http.ResponseWriter, req *http.Request) {
  	RespondWithHttpError(w, req, http.StatusNotFound, []HttpErrorDesc{
  		{Lang: "en", Desc: "Not found."},
  		{Lang: "rs", Desc: "Traženi resurs ne postoji."},
  	})

  }