controllers

var Authenticate = func(w http.ResponseWriter, r *http.Request) {
	account := &models.Account{}
	err := json.NewDecoder(r.Body).Decode(account)
	if err != nil {
		u.RespondBadRequest(w)
		return
	}

	resp := models.Login(account.Email, account.Password)
	if resp["status"] == false {
		u.RespondUnauthorized(w)
	} else {
		u.Respond(w, resp)
	}
}

var ChangeAclOnPlaylist = func(w http.ResponseWriter, r *http.Request) {
	params := mux.Vars(r)
	id, err := strconv.ParseUint(params["id"], 10, 32)
	if err != nil {
		u.RespondBadRequest(w)
		return
	}

	type UserAcl struct {
		User *uint `json:"user"`
		Role *uint `json:"role"`
	}
	userAcl := &UserAcl{}
	err = json.NewDecoder(r.Body).Decode(userAcl)
	if err != nil || userAcl.Role == nil || userAcl.User == nil {
		u.RespondBadRequest(w)
		return
	}
	user := r.Context().Value("user").(uint)
	resp := models.ChangeAclOnPlaylist(user, *userAcl.User, uint(id), *userAcl.Role)
	if resp["status"] == false {
		w.WriteHeader(http.StatusBadRequest)
	} else {
		websocket.NotifyPlaylistSubscribers(user, uint(id), websocket.PlaylistNeedRefresh(uint(id), user))
	}
	u.Respond(w, resp)
}

var ConnectWebSocket = func(w http.ResponseWriter, r *http.Request) {
	fmt.Println("Trying to establish a connection")
	fmt.Println(r.Header.Get("Sec-WebSocket-Protocol"))

	var wsPool *websocket.WSPool
	wsPool = websocket.GetWSPool()
	wsPool.CreateWebSocket(w, r)
}

var CreateAccount = func(w http.ResponseWriter, r *http.Request) {

	account := &models.Account{}
	err := json.NewDecoder(r.Body).Decode(account)
	if err != nil {
		u.RespondBadRequest(w)
		return
	}

	resp := account.Create()
	u.Respond(w, resp)
}

var CreatePlaylist = func(w http.ResponseWriter, r *http.Request) {
	user := r.Context().Value("user").(uint)

	var playlist = &models.Playlist{}
	err := json.NewDecoder(r.Body).Decode(playlist)
	if err != nil {
		u.RespondBadRequest(w)
		return
	}

	resp := playlist.Create(user)
	u.Respond(w, resp)
}

var CreateSong = func(w http.ResponseWriter, r *http.Request) {
	user := r.Context().Value("user").(uint)
	var song = &models.Song{}
	err := json.NewDecoder(r.Body).Decode(song)
	if err != nil {
		u.Respond(w, u.Message(false, "Invalid request"))
		return
	}

	resp := song.Create(user, websocket.NotifyPlaylistSubscribers, websocket.PlaylistNeedRefresh)
	if resp["status"] == false {
		w.WriteHeader(http.StatusBadRequest)
	}
	u.Respond(w, resp)
}

var DeleteAccount = func(w http.ResponseWriter, r *http.Request) {
	user := r.Context().Value("user").(uint)

	resp := (&models.Account{}).DeleteAccount(user)
	if resp["status"] == false {
		w.WriteHeader(http.StatusBadRequest)
	}
	u.Respond(w, resp)
}

var DeletePlaylist = func(w http.ResponseWriter, r *http.Request) {
	params := mux.Vars(r)
	id, err := strconv.ParseUint(params["id"], 10, 32)
	if err != nil {
		u.RespondBadRequest(w)
		return
	}
	user := r.Context().Value("user").(uint)
	messageOnDelete := websocket.PlaylistDeleted(uint(id), user)
	resp := (&models.Playlist{}).DeletePlaylist(user, uint(id), websocket.NotifyPlaylistSubscribers, messageOnDelete)
	if resp["status"] == false {
		w.WriteHeader(http.StatusBadRequest)
	}
	u.Respond(w, resp)
}

var DeleteSong = func(w http.ResponseWriter, r *http.Request) {
	params := mux.Vars(r)
	id, err := strconv.ParseUint(params["id"], 10, 32)
	if err != nil {
		u.RespondBadRequest(w)
		return
	}
	user := r.Context().Value("user").(uint)
	resp := (&models.Song{}).DeleteSong(user, uint(id), websocket.NotifyPlaylistSubscribers, websocket.PlaylistNeedRefresh)
	if resp["status"] == false {
		w.WriteHeader(http.StatusBadRequest)
	}
	u.Respond(w, resp)
}

var GetAccount = func(w http.ResponseWriter, r *http.Request) {
	user := r.Context().Value("user").(uint)

	acc := models.GetUser(user)
	if acc == nil {
		u.RespondBadRequestWithMessage(w, "Error cannot find account")
		return
	}
	resp := u.Message(true, "success")
	resp["account"] = acc
	u.Respond(w, resp)
}

var GetPlaylist = func(w http.ResponseWriter, r *http.Request) {
	filter := models.PlaylistFilter{
		ShowSongs:    true,
		ShowFollower: false,
		ShowAcl:      false,
	}
	getBoolVal := func(val []string, b *bool) bool {
		if len(val) >= 1 {
			ret, err := strconv.ParseBool(val[0])
			if err == nil {
				*b = ret
				return true
			}
		}
		return false
	}
	vals := r.URL.Query()
	for name, val := range vals {
		goodParam := false
		switch name {
		case "showSongs":
			goodParam = getBoolVal(val, &filter.ShowSongs)
		case "showFollower":
			goodParam = getBoolVal(val, &filter.ShowFollower)
		case "showAcl":
			goodParam = getBoolVal(val, &filter.ShowAcl)
		}
		if !goodParam {
			w.WriteHeader(http.StatusBadRequest)
			u.Respond(w, u.Message(false, "Invalid request, wrong value given to "+name))
			return
		}
	}
	params := mux.Vars(r)
	id, err := strconv.Atoi(params["id"])

	if err != nil {
		u.RespondBadRequest(w)
		return
	}

	data := models.GetPlaylistById(uint(id), &filter)
	if data == nil {
		u.RespondBadRequest(w)
		return
	}
	resp := u.Message(true, "success")
	resp["playlist"] = data
	u.Respond(w, resp)
}

var GetPlaylistRole = func(w http.ResponseWriter, r *http.Request) {
	params := mux.Vars(r)
	id, err := strconv.ParseUint(params["id"], 10, 32)
	if err != nil {
		u.RespondBadRequest(w)
		return
	}
	user := r.Context().Value("user").(uint)
	data, errMsg := models.GetRole(user, uint(id))
	var resp map[string]interface{}
	if errMsg != "" {
		resp = u.Message(false, errMsg)
	} else {
		resp = u.Message(true, "success")
	}
	resp["role"] = data
	u.Respond(w, resp)
}

var GetPlaylists = func(w http.ResponseWriter, r *http.Request) {
	fmt.Println("get playlists")
	vals := r.URL.Query()
	user_id, ok := vals["user_id"]

	user := uint(0)
	if ok && len(user_id) >= 1 {
		id, err := strconv.ParseUint(user_id[0], 10, 32)
		if err != nil {
			u.RespondBadRequest(w)
			return
		}
		user = uint(id)
	} else {
		user = r.Context().Value("user").(uint)
	}

	data := models.GetPlaylistsByUser(uint(user))
	resp := u.Message(true, "success")
	resp["playlists"] = data
	u.Respond(w, resp)
}

var GetRanking = func(w http.ResponseWriter, r *http.Request) {
	params := mux.Vars(r)
	id, err := strconv.ParseUint(params["id"], 10, 32)
	if err != nil {
		u.RespondBadRequest(w)
		return
	}

	data := models.GetSongRankingById(uint(id))
	resp := u.Message(true, "success")
	resp["song_ranking"] = data
	u.Respond(w, resp)
}

var GetRankings = func(w http.ResponseWriter, r *http.Request) {
	var param string

	vals := r.URL.Query()
	playlist_id, ok := vals["playlist_id"]

	if ok && len(playlist_id) >= 1 {
		param = playlist_id[0]
	} else {
		w.WriteHeader(http.StatusBadRequest)
		u.Respond(w, u.Message(false, "Invalid request need playlist id"))
		return
	}

	plistid, err := strconv.Atoi(param)
	if err != nil {

		w.WriteHeader(http.StatusBadRequest)
		u.Respond(w, u.Message(false, "Invalid request"))
		return
	}

	data := models.GetSongsRanking(uint(plistid))
	resp := u.Message(true, "success")
	resp["songs_rankings"] = data
	u.Respond(w, resp)
}

var GetSongs = func(w http.ResponseWriter, r *http.Request) {
	var param string

	user := r.Context().Value("user").(uint)
	vals := r.URL.Query()
	playlistId, ok := vals["playlist_id"]

	if ok && len(playlistId) >= 1 {
		param = playlistId[0]
	} else {
		w.WriteHeader(http.StatusBadRequest)
		u.Respond(w, u.Message(false, "Invalid request need playlist id"))
		return
	}

	plistid, err := strconv.Atoi(param)
	if err != nil {

		w.WriteHeader(http.StatusBadRequest)
		u.Respond(w, u.Message(false, "Invalid request"))
		return
	}

	data := models.GetSongs(uint(plistid), user)
	if data == nil {
		u.RespondBadRequestWithMessage(w, "Invalid request, playlist Id doesn't match with any playlist")
		return
	}
	resp := u.Message(true, "success")
	resp["songs"] = data
	u.Respond(w, resp)
}

var GetVote = func(w http.ResponseWriter, r *http.Request) {
	user := r.Context().Value("user").(uint)
	songId, err := getSongId(r.URL.Query())
	if err != nil {
		u.RespondBadRequest(w)
		return
	}

	data := models.GetPersonalVoteBySongId(uint(songId), user)
	resp := u.Message(true, "success")
	resp["vote"] = data
	u.Respond(w, resp)
}

var GetVotes = func(w http.ResponseWriter, r *http.Request) {
	params := mux.Vars(r)
	songId, err := strconv.ParseUint(params["song_id"], 10, 32)
	if err != nil {
		u.RespondBadRequest(w)
		return
	}

	data := models.GetVotesBySongId(uint(songId))
	resp := u.Message(true, "success")
	resp["votes"] = data
	u.Respond(w, resp)
}

var JoinPlaylist = func(w http.ResponseWriter, r *http.Request) {
	params := mux.Vars(r)
	id, err := strconv.ParseUint(params["id"], 10, 32)
	if err != nil {
		u.RespondBadRequest(w)
		return
	}
	user := r.Context().Value("user").(uint)
	resp := (&models.Playlist{}).Join(user, uint(id))
	if resp["status"] == false {
		w.WriteHeader(http.StatusBadRequest)
	} else {
		websocket.NotifyPlaylistSubscribers(user, uint(id), websocket.PlaylistNeedRefresh(uint(id), user))
	}
	u.Respond(w, resp)
}

var LeavePlaylist = func(w http.ResponseWriter, r *http.Request) {
	params := mux.Vars(r)
	id, err := strconv.ParseUint(params["id"], 10, 32)
	if err != nil {
		u.RespondBadRequest(w)
		return
	}
	user := r.Context().Value("user").(uint)
	resp := (&models.Playlist{}).LeavePlaylist(user, uint(id))
	if resp["status"] == false {
		w.WriteHeader(http.StatusBadRequest)
	} else {
		websocket.NotifyPlaylistSubscribers(user, uint(id), websocket.PlaylistNeedRefresh(uint(id), user))
	}
	u.Respond(w, resp)
}

var UpdateAccount = func(w http.ResponseWriter, r *http.Request) {
	user := r.Context().Value("user").(uint)
	var account = &models.Account{}
	err := json.NewDecoder(r.Body).Decode(account)
	if err != nil {
		u.RespondBadRequest(w)
		return
	}
	account.ID = user
	resp := account.UpdateAccount()
	if resp["status"] == false {
		w.WriteHeader(http.StatusBadRequest)
	}
	u.Respond(w, resp)
}

var UpdateOrCreateVote = func(w http.ResponseWriter, r *http.Request) {
	user := r.Context().Value("user").(uint)

	songId, err := getSongId(r.URL.Query())
	if err != nil {
		fmt.Println(err)
		u.RespondBadRequest(w)
		return
	}
	vote := &models.Vote{}
	err = json.NewDecoder(r.Body).Decode(&vote)
	if err != nil {
		fmt.Println(err)
		u.RespondBadRequest(w)
		return
	}

	resp := u.Message(true, "This request has performed no action")
	if vote.UpVote == true {
		resp = models.UpVoteSong(uint(songId), user, websocket.NotifyPlaylistSubscribers, websocket.PlaylistNeedRefresh)
	} else if vote.DownVote == true {
		resp = models.DownVoteSong(uint(songId), user, websocket.NotifyPlaylistSubscribers, websocket.PlaylistNeedRefresh)
	}
	u.Respond(w, resp)
}

var UpdatePassword = func(w http.ResponseWriter, r *http.Request) {

	user := r.Context().Value("user").(uint)
	account := &models.Account{}
	err := json.NewDecoder(r.Body).Decode(account)
	if err != nil {
		u.RespondBadRequest(w)
		return
	}
	resp := models.UpdatePassword(user, account.Password)
	u.Respond(w, resp)
}

var UpdatePlaylist = func(w http.ResponseWriter, r *http.Request) {
	params := mux.Vars(r)
	id, err := strconv.ParseUint(params["id"], 10, 32)
	if err != nil {
		u.RespondBadRequest(w)
		return
	}
	user := r.Context().Value("user").(uint)
	var playlist = &models.Playlist{}
	err = json.NewDecoder(r.Body).Decode(playlist)
	if err != nil {
		u.RespondBadRequest(w)
		return
	}
	resp := playlist.UpdatePlaylist(user, uint(id), playlist)
	if resp["status"] == false {
		w.WriteHeader(http.StatusBadRequest)
	} else {
		websocket.NotifyPlaylistSubscribers(user, uint(id), websocket.PlaylistNeedRefresh(uint(id), user))
	}
	u.Respond(w, resp)
}

var UpdateSong = func(w http.ResponseWriter, r *http.Request) {
	params := mux.Vars(r)
	id, err := strconv.ParseUint(params["id"], 10, 32)
	if err != nil {
		u.RespondBadRequest(w)
		return
	}
	user := r.Context().Value("user").(uint)
	var song = &models.Song{}
	err = json.NewDecoder(r.Body).Decode(song)
	if err != nil {
		u.RespondBadRequest(w)
		return
	}
	resp := song.UpdateSong(user, uint(id), song, websocket.NotifyPlaylistSubscribers, websocket.PlaylistNeedRefresh)
	if resp["status"] == false {
		w.WriteHeader(http.StatusBadRequest)
	}
	u.Respond(w, resp)
}