func LobbySettingsToJSON() *simplejson.Json {

        j := simplejson.New()

        // formats

        {

                formats := simplejson.New()

                formatList := make([]*simplejson.Json, len(LobbyFormats))

                for i, format := range LobbyFormats {

                        f := simplejson.New()

                        f.Set("value", format.Name)

                        f.Set("title", format.PrettyName)

                        f.Set("important", format.Important)

                        formatList[i] = f

                }

                formats.Set("key", "type")

                formats.Set("title", "Format")

                formats.Set("options", formatList)

                j.Set("formats", formats)

        }

        // maps

        {

                maps := simplejson.New()

                mapList := make([]*simplejson.Json, len(LobbyMaps))

                for i, amap := range LobbyMaps {

                        f := simplejson.New()

                        f.Set("value", amap.Name)

                        for _, mapFormat := range amap.Formats {

                                f.Set(mapFormat.Format.Name, mapFormat.Importance)

                        }

                        mapList[i] = f

                }

                maps.Set("key", "mapName")

                maps.Set("title", "Map")

                maps.Set("options", mapList)

                j.Set("maps", maps)

        }

        // leagues

        {

                leagues := simplejson.New()

                leagueList := make([]*simplejson.Json, len(LobbyLeagues))

                for i, league := range LobbyLeagues {

                        leagueDescs := simplejson.New()

                        for _, leagueDesc := range league.Descriptions {

                                leagueDescs.Set(string(leagueDesc.MapType), leagueDesc.Description)

                        }

                        f := simplejson.New()

                        f.Set("value", league.Name)

                        f.Set("title", league.PrettyName)

                        f.Set("descriptions", leagueDescs)

                        for _, leagueFormat := range league.Formats {

                                f.Set(leagueFormat.Format.Name, leagueFormat.Used)

                        }

                        leagueList[i] = f

                }

                leagues.Set("key", "league")

                leagues.Set("title", "League")

                leagues.Set("options", leagueList)

                j.Set("leagues", leagues)

        }

        // whitelists

        {

                whitelists := simplejson.New()

                whitelistList := make([]*simplejson.Json, len(LobbyWhitelists))

                for i, whitelist := range LobbyWhitelists {

                        f := simplejson.New()

                        f.Set("value", whitelist.ID)

                        f.Set("title", whitelist.PrettyName)

                        f.Set("league", whitelist.League.Name)

                        f.Set("format", whitelist.Format.Name)

                        whitelistList[i] = f

                }

                whitelists.Set("key", "whitelist")

                whitelists.Set("title", "Whitelist")

                whitelists.Set("options", whitelistList)

                j.Set("whitelists", whitelists)

        }

        return j

}

func (l *Lobby) FitsRequirements(player *Player, slot int) (bool, *helpers.TPError) {

        //BUG(vibhavp): FitsRequirements doesn't check reliability

        var req *Requirement

        slotReq, err := l.GetSlotRequirement(slot)

        if err == nil {

                req = slotReq

        }

        db.DB.Preload("Stats").First(player, player.ID)

        if time.Since(player.UpdatedAt) < time.Hour*time.Duration(req.Hours-player.GameHours) {

                //update player info only if the number of hours needed > the number of hours

                //passed since player info was last updated

                player.UpdatePlayerInfo()

                player.Save()

        }

        if player.GameHours < req.Hours {

                return false, ReqHoursErr

        }

        if player.Stats.TotalLobbies() < req.Lobbies {

                return false, ReqLobbiesErr

        }

        return true, nil

}

func (lobby *Lobby) Close(rpc bool) {

        db.DB.First(&lobby).UpdateColumn("state", LobbyStateEnded)

        db.DB.Table("server_records").Where("id = ?", lobby.ServerInfoID).Delete(&ServerRecord{})

        db.DB.Table("requirements").Where("lobby_id = ?", lobby.ID).Delete(&Requirement{})

        //db.DB.Exec("DELETE FROM spectators_players_lobbies WHERE lobby_id = ?", lobby.ID)

        if rpc {

                End(lobby.ID)

        }

        privateRoom := fmt.Sprintf("%d_private", lobby.ID)

        broadcaster.SendMessageToRoom(privateRoom, "lobbyLeft", DecorateLobbyLeave(lobby))

        publicRoom := fmt.Sprintf("%d_public", lobby.ID)

        broadcaster.SendMessageToRoom(publicRoom, "lobbyClosed", DecorateLobbyClosed(lobby))

        BroadcastSubList()

        BroadcastLobby(lobby)

        BroadcastLobbyList() // has to be done manually for now

        FumbleLobbyEnded(lobby)

}

func (player *Player) GenAuthKey() string {

        var count int

        var authKey string

        for {

                buff := bytes.NewBufferString(player.SteamID)

                buff.Grow(32)

                rand.Read(buff.Bytes())

                sum := sha256.Sum256(buff.Bytes())

                authKey = hex.EncodeToString(sum[:])

                db.DB.Table("players").Where("mumble_authkey = ?", authKey).Count(&count)

                if count == 0 {

                        break

                }

        }

        return authKey

}

func (lobby *Lobby) SubNotInGamePlayers() {

        playerids := []uint{}

        db.DB.Table("lobby_slots").Where("lobby_id = ? AND in_game = ?", lobby.ID, false).Pluck("player_id", &playerids)

        db.DB.Table("lobby_slots").Where("lobby_id = ? AND in_game = ? AND needs_sub = ?", lobby.ID, false, false).UpdateColumn("needs_sub", true)

        for _, id := range playerids {

                player, _ := GetPlayerByID(id)

                SendNotification(fmt.Sprintf("%s has been reported for not joining the game.", player.Alias()), int(lobby.ID))

        }

        BroadcastSubList()

        return

}

func (player *Player) GetLobbyID(inProgress bool) (uint, *helpers.TPError) {

        playerSlot := &LobbySlot{}

        states := []LobbyState{LobbyStateEnded}

        if inProgress {

                states = append(states, LobbyStateInProgress)

        }

        err := db.DB.Joins("INNER JOIN lobbies ON lobbies.id = lobby_slots.lobby_id").

                Where("lobby_slots.player_id = ? AND lobbies.state NOT IN (?)", player.ID, states).

                First(playerSlot).Error

        // if the player is not in any lobby or the player has been reported/needs sub, return error

        if err != nil || playerSlot.NeedsSub {

                return 0, helpers.NewTPError("Player not in any lobby", 1)

        }

        return playerSlot.LobbyID, nil

}

func LobbyGetPlayerSlot(lobbytype LobbyType, teamStr string, classStr string) (int, *helpers.TPError) {

        team, ok := teamMap[teamStr]

        if !ok {

                return -1, helpers.NewTPError("Invalid team", -1)

        }

        class, ok := typeClassMap[lobbytype][classStr]

        if !ok {

                return -1, helpers.NewTPError("Invalid class", -1)

        }

        return team*NumberOfClassesMap[lobbytype] + class, nil

}

func DeleteUnusedServerRecords() {

        serverInfoIDs := []uint{}

        db.DB.Table("server_records").Pluck("id", &serverInfoIDs)

        for _, id := range serverInfoIDs {

                lobby := &Lobby{}

                err := db.DB.Where("server_info_id = ?", id).First(lobby).Error

                if err != nil || lobby.State == LobbyStateEnded {

                        db.DB.Table("server_records").Where("id = ?", id).Delete(&ServerRecord{})

                }

        }

}

func DecorateSubstitute(slot *LobbySlot) SubstituteData {

        lobby := &Lobby{}

        db.DB.First(lobby, slot.LobbyID)

        substitute := SubstituteData{

                LobbyID: lobby.ID,

                Format:  formatMap[lobby.Type],

                MapName: lobby.MapName,

                Mumble:  lobby.Mumble,

        }

        substitute.Region.Name = lobby.RegionName

        substitute.Region.Code = lobby.RegionCode

        substitute.Team, substitute.Class, _ = LobbyGetSlotInfoString(lobby.Type, slot.Slot)

        return substitute

}

func DecorateSubstituteList() []SubstituteData {

        slots := []*LobbySlot{}

        subList := []SubstituteData{}

        db.DB.Table("lobby_slots").Joins("INNER JOIN lobbies ON lobbies.id = lobby_slots.lobby_id").Where("lobby_slots.needs_sub = ? AND lobbies.state = ?", true, LobbyStateInProgress).Find(&slots)

        for _, slot := range slots {

                subList = append(subList, DecorateSubstitute(slot))

        }

        return subList

}

func (lobby *Lobby) Save() error {

        var err error

        if db.DB.NewRecord(lobby) {

                err = db.DB.Create(lobby).Error

        } else {

                err = db.DB.Save(lobby).Error

        }

        lobby.RealAfterSave()

        return err

}

func LobbyGetSlotInfoString(lobbytype LobbyType, slot int) (team, class string, err *helpers.TPError) {

        classList := typeClassList[lobbytype]

        teamI, classI, err := LobbyGetSlotInfo(lobbytype, slot)

        if err == nil {

                team, class, err = teamList[teamI], classList[classI], nil

        }

        return

}

func (player *Player) IsBannedWithTime(t PlayerBanType) (bool, time.Time) {

        ban := &PlayerBan{}

        err := db.DB.Where("type = ? AND until > now() AND player_id = ? AND active = TRUE", t, player.ID).

                Order("until desc").First(ban).Error

        if err != nil {

                return false, time.Time{}

        }

        return true, ban.Until

}

func (player *Player) Save() error {

        var err error

        if db.DB.NewRecord(player) {

                err = db.DB.Create(player).Error

        } else {

                err = db.DB.Save(player).Error

        }

        return err

}

func (ps *PlayerStats) IncreaseClassCount(lobby *Lobby, slot int) {

        _, class, _ := LobbyGetSlotInfoString(lobby.Type, slot)

        classes := map[string]*int{

                "scout1":   &ps.Scout,

                "scout2":   &ps.Scout,

                "roamer":   &ps.Soldier,

                "pocket":   &ps.Soldier,

                "soldier":  &ps.Soldier,

                "soldier1": &ps.Soldier,

                "soldier2": &ps.Soldier,

                "pyro":     &ps.Pyro,

                "engineer": &ps.Engineer,

                "heavy":    &ps.Heavy,

                "demoman":  &ps.Demoman,

                "sniper":   &ps.Sniper,

                "medic":    &ps.Medic,

                "spy":      &ps.Spy,

        }

        *(classes[class])++

        database.DB.Save(ps)

}

func (player *Player) SetSetting(key string, value string) {

        if player.Settings == nil {

                player.Settings = make(gorm.Hstore)

        }

        player.Settings[key] = &value

        player.Save()

}

func (lobby *Lobby) OnChange(base bool) {

        switch lobby.State {

        case LobbyStateWaiting, LobbyStateInProgress, LobbyStateReadyingUp:

                BroadcastLobby(lobby)

                if base {

                        BroadcastLobbyList()

                }

        }

}

func (lobby *Lobby) Substitute(player *Player) {

        db.DB.Table("lobby_slots").Where("lobby_id = ? AND player_id = ?", lobby.ID, player.ID).UpdateColumn("needs_sub", true)

        db.DB.Preload("Stats").First(player, player.ID)

        player.Stats.IncreaseSubCount()

        BroadcastSubList()

}

func (player *Player) GenMumbleUsername() string {

        last := &Player{}

        db.DB.Table("players").Last(last)

        mumbleNick := fmt.Sprintf("TF2Stadium%d", last.ID+1)

        return mumbleNick

}

func (lobby *Lobby) HasSlotRequirement(slot int) bool {

        var count int

        db.DB.Table("requirements").Where("lobby_id = ? AND slot = ?", lobby.ID, slot).Count(&count)

        return count != 0

}

func GetRoomMessages(room int) ([]*ChatMessage, error) {

        var messages []*ChatMessage

        err := db.DB.Table("chat_messages").Where("room = ?", room).Order("created_at").Find(&messages).Error

        return messages, err

}

func (lobby *Lobby) HasPlayer(player *Player) bool {

        var count int

        db.DB.Table("lobby_slots").Where("lobby_id = ? AND player_id = ?", lobby.ID, player.ID).Count(&count)

        return count != 0

}

func NewBotMessage(message string, room int) *ChatMessage {

        m := &ChatMessage{

                Timestamp: time.Now().Unix(),

                Player:  botSummary,

                Room:    room,

                Message: message,

                Bot: true,

        }

        m.Save()

        return m

}

func (lobby *Lobby) GetPlayerSlotObj(player *Player) (*LobbySlot, error) {

        slotObj := &LobbySlot{}

        err := db.DB.Where("player_id = ? AND lobby_id = ?", player.ID, lobby.ID).First(slotObj).Error

        return slotObj, err

}

func GetPlayerMessages(player *Player) ([]*ChatMessage, error) {

        var messages []*ChatMessage

        err := db.DB.Table("chat_messages").Where("player_id = ?", player.ID).Order("room, created_at").Find(&messages).Error

        return messages, err

}

func (lobby *Lobby) GetSlotRequirement(slot int) (*Requirement, error) {

        req := &Requirement{}

        err := db.DB.Table("requirements").Where("lobby_id = ? AND slot = ?", lobby.ID, slot).First(req).Error

        return req, err

}

func (l *Lobby) CurrentState() LobbyState {

        var state int

        db.DB.DB().QueryRow("SELECT state FROM lobbies WHERE id = $1", l.ID).Scan(&state)

        return LobbyState(state)

}

func DecoratePlayerSummary(p *Player) PlayerSummary {

        db.DB.Preload("Stats").First(p, p.ID)

        summary := PlayerSummary{

                Avatar:        p.Avatar,

                GameHours:     p.GameHours,

                ProfileURL:    p.Profileurl,

                LobbiesPlayed: p.Stats.TotalLobbies(),

                SteamID:       p.SteamID,

                Name:          p.Alias(),

                Tags:          decoratePlayerTags(p),

                Role:          helpers.RoleNames[p.Role],

        }

        return summary

}

func (lobby *Lobby) GetPlayerIDBySlot(slot int) (uint, error) {

        slotObj := &LobbySlot{}

        err := db.DB.Where("lobby_id = ? AND slot = ?", lobby.ID, slot).First(slotObj).Error

        return uint(slotObj.PlayerID), err

}

func (lobby *Lobby) FillSubstitute(slot int) error {

        err := db.DB.Table("lobby_slots").Where("lobby_id = ? AND slot = ?", lobby.ID, slot).UpdateColumn("needs_sub", false).Error

        BroadcastSubList()

        return err

}

func (lobby *Lobby) UnreadyAllPlayers() error {

        err := db.DB.Table("lobby_slots").Where("lobby_id = ?", lobby.ID).UpdateColumn("ready", false).Error

        lobby.OnChange(false)

        return err

}

func (lobby *Lobby) setInGameStatus(player *Player, inGame bool) error {

        err := db.DB.Table("lobby_slots").Where("player_id = ? AND lobby_id = ?", player.ID, lobby.ID).UpdateColumn("in_game", inGame).Error

        lobby.OnChange(false)

        return err

}

func (lobby *Lobby) IsEveryoneReady() bool {

        readyPlayers := 0

        db.DB.Table("lobby_slots").Where("lobby_id = ? AND ready = ?", lobby.ID, true).Count(&readyPlayers)

        return readyPlayers == 2*NumberOfClassesMap[lobby.Type]

}

func (lobby *Lobby) IsPlayerReady(player *Player) (bool, error) {

        var ready bool

        err := db.DB.DB().QueryRow("SELECT ready FROM lobby_slots WHERE lobby_id = $1 AND player_id = $2", lobby.ID, player.ID).Scan(&ready)

        return ready, err

}

func (lobby *Lobby) Start() {

        db.DB.Table("lobbies").Where("id = ?", lobby.ID).Update("state", LobbyStateInProgress)

        time.AfterFunc(time.Minute*5, func() {

                if lobby.CurrentState() != LobbyStateEnded {

                        lobby.SubNotInGamePlayers()

                }

        })

}

func (player *Player) BanUntil(tim time.Time, t PlayerBanType, reason string) error {

        ban := PlayerBan{

                PlayerID: player.ID,

                Type:     t,

                Until:    tim,

                Reason:   reason,

        }

        return db.DB.Create(&ban).Error

}

func (ps *PlayerStats) IncreaseSubCount() {

        ps.Substitutes++

        database.DB.Save(ps)

}

func decoratePlayerTags(p *Player) []string {

        tags := []string{helpers.RoleNames[p.Role]}

        return tags

}

func LogCustomAdminAction(playerid uint, reltext string, relid uint) error {

        entry := AdminLogEntry{

                PlayerID: playerid,

                RelID:    relid,

                RelText:  reltext,

        }

        return database.DB.Create(&entry).Error

}

func (lobby *Lobby) SlotNeedsSubstitute(slot int) (needsSub bool) {

        //use database/sql API, since it's simpler here

        db.DB.DB().QueryRow("SELECT needs_sub FROM lobby_slots WHERE lobby_id = $1 AND slot = $2", lobby.ID, slot).Scan(&needsSub)

        return

}

func (player *Player) IsBanned(t PlayerBanType) bool {

        res, _ := player.IsBannedWithTime(t)

        return res

}

func BroadcastLobby(lobby *Lobby) {

        //db.DB.Preload("Spectators").First(&lobby, lobby.ID)

        room := strconv.FormatUint(uint64(lobby.ID), 10)

        broadcaster.SendMessageToRoom(fmt.Sprintf("%s_public", room), "lobbyData", DecorateLobbyData(lobby, true))

}

func FumbleLobbyPlayerJoined(lob *Lobby, player *Player, slot int) {

        team, class, _ := LobbyGetSlotInfoString(lob.Type, slot)

        fumbleAllowPlayer(lob.ID, strings.ToUpper(team)+"_"+strings.ToUpper(class), "")

}

func SendNotification(message string, room int) {

        pub := fmt.Sprintf("%d_public", room)

        broadcaster.SendMessageToRoom(pub, "chatReceive", NewBotMessage(message, room))

}

func NewLobby(mapName string, lobbyType LobbyType, league string, serverInfo ServerRecord, whitelist string, mumble bool, whitelistGroup, password string) *Lobby {

        lobby := &Lobby{

                Mode:            getGamemode(mapName, lobbyType),

                Type:            lobbyType,

                State:           LobbyStateInitializing,

                League:          league,

                MapName:         mapName,

                Whitelist:       whitelist, // that's a strange line

                Mumble:          mumble,

                ServerInfo:      serverInfo,

                PlayerWhitelist: whitelistGroup,

                SlotPassword:    password,

        }

        // Must specify CreatedBy manually if the lobby is created by a player

        return lobby

}

func BroadcastSubList() {

        subList := DecorateSubstituteList()

        broadcaster.SendMessageToRoom("0_public", "subListData", subList)

}

func GetWaitingLobbies() (lobbies []*Lobby) {

        db.DB.Where("state = ?", LobbyStateWaiting).Order("id desc").Find(&lobbies)

        return

}

func (lobby *Lobby) BanPlayer(player *Player) {

        DisallowPlayer(lobby.ID, player.SteamID)

        db.DB.Model(lobby).Association("BannedPlayers").Append(player)

}

func NewPlayerStats() PlayerStats {

        stats := PlayerStats{}

        return stats

}

func NewChatMessage(message string, room int, player *Player) *ChatMessage {

        record := &ChatMessage{

                Timestamp: time.Now().Unix(),

                PlayerID: player.ID,

                Player:   DecoratePlayerSummary(player),

                Room:    room,

                Message: message,

        }

        return record

}

func (lobby *Lobby) GetPlayerSlot(player *Player) (int, error) {

        slotObj, err := lobby.GetPlayerSlotObj(player)

        return slotObj.Slot, err

}

func (lobby *Lobby) HasRequirements(slot int) bool {

        return lobby.HasSlotRequirement(slot)

}

func (m *ChatMessage) Save() { db.DB.Save(m) }

func (r *Requirement) Save() { db.DB.Save(r) }

func (ps *PlayerStats) TotalLobbies() int {

        return ps.PlayedSixesCount + ps.PlayedHighlanderCount + ps.PlayedFoursCount + ps.PlayedUltiduoCount + ps.PlayedBballCount

}

func (lobby *Lobby) SetInGame(player *Player) error {

        return lobby.setInGameStatus(player, true)

}

func (player *Player) Unban(t PlayerBanType) error {

        return db.DB.Model(&PlayerBan{}).Where("player_id = ? AND type = ? AND active = TRUE", player.ID, t).

                Update("active", "FALSE").Error

}

func (lobby *Lobby) SetNotInGame(player *Player) error {

        return lobby.setInGameStatus(player, false)

}

func (lobby *Lobby) RealAfterSave() {

        lobby.OnChange(true)

}

func BroadcastLobbyList() {

        broadcaster.SendMessageToRoom(

                fmt.Sprintf("%s_public", config.GlobalChatRoom),

                "lobbyListData", DecorateLobbyListData(GetWaitingLobbies()))

}

func End(lobbyId uint) {

        pauling.Call("Pauling.End", &Args{Id: lobbyId}, &Args{})

}

func LogAdminAction(playerid uint, permission authority.AuthAction, relid uint) error {

        return LogCustomAdminAction(playerid, helpers.ActionNames[permission], relid)

}

func DecorateLobbyLeave(lobby *Lobby) LobbyEvent {

        return LobbyEvent{lobby.ID}

}

func DecorateLobbyClosed(lobby *Lobby) LobbyEvent {

        return LobbyEvent{lobby.ID}

}

func DisallowPlayer(lobbyId uint, steamId string) error {

        return pauling.Call("Pauling.DisallowPlayer", &Args{Id: lobbyId, SteamId: steamId}, &Args{})

}

func DecorateLobbyData(lobby *Lobby, includeDetails bool) LobbyData {

        lobbyData := LobbyData{

                ID:            lobby.ID,

                Mode:          lobby.Mode,

                Type:          formatMap[lobby.Type],

                Players:       lobby.GetPlayerNumber(),

                Map:           lobby.MapName,

                League:        lobby.League,

                Mumble:        lobby.Mumble,

                TwitchChannel: lobby.TwitchChannel,

                SteamGroup: lobby.PlayerWhitelist,

                Password:   lobby.SlotPassword != "",

        }

        lobbyData.Region.Name = lobby.RegionName

        lobbyData.Region.Code = lobby.RegionCode

        var classList = typeClassList[lobby.Type]

        classes := make([]ClassDetails, len(classList))

        lobbyData.MaxPlayers = NumberOfClassesMap[lobby.Type] * 2

        for slot, className := range classList {

                class := ClassDetails{

                        Red:   decorateSlotDetails(lobby, slot, includeDetails),

                        Blu:   decorateSlotDetails(lobby, slot+NumberOfClassesMap[lobby.Type], includeDetails),

                        Class: className,

                }

                classes[slot] = class

        }

        lobbyData.Classes = classes

        lobbyData.WhitelistID = lobby.Whitelist

        if !includeDetails {

        }

        var leader Player

        db.DB.Where("steam_id = ?", lobby.CreatedBySteamID).First(&leader)

        lobbyData.Leader = DecoratePlayerSummary(&leader)

        lobbyData.CreatedAt = lobby.CreatedAt.Unix()

        lobbyData.State = int(lobby.State)

        var specIDs []uint

        db.DB.Table("spectators_players_lobbies").Where("lobby_id = ?", lobby.ID).Pluck("player_id", &specIDs)

        spectators := make([]SpecDetails, len(specIDs))

        for i, spectatorID := range specIDs {

                specPlayer := &Player{}

                db.DB.First(specPlayer, spectatorID)

                specJs := SpecDetails{

                        Name:    specPlayer.Alias(),

                        SteamID: specPlayer.SteamID,

                }

                spectators[i] = specJs

        }

        lobbyData.Spectators = spectators

        return lobbyData

}

func decorateSlotDetails(lobby *Lobby, slot int, includeDetails bool) SlotDetails {

        playerId, err := lobby.GetPlayerIDBySlot(slot)

        j := SlotDetails{Slot: slot, Filled: err == nil}

        if err == nil && includeDetails {

                var player Player

                db.DB.First(&player, playerId)

                db.DB.Preload("Stats").First(&player, player.ID)

                summary := DecoratePlayerSummary(&player)

                j.Player = &summary

                ready, _ := lobby.IsPlayerReady(&player)

                j.Ready = &ready

                ingame, _ := lobby.IsPlayerInGame(&player)

                j.InGame = &ingame

        }

        if lobby.HasSlotRequirement(slot) {

        }

        return j

}

func (lobby *Lobby) RemoveUnreadyPlayers(spec bool) error {

        playerids := []uint{}

        if spec {

                //get list of player ids which are not ready

                err := db.DB.Table("lobby_slots").Where("lobby_id = ? AND ready = ?", lobby.ID, false).Pluck("player_id", &playerids).Error

                if err != nil {

                }

        }

        //remove players which aren't ready

        err := db.DB.Where("lobby_id = ? AND ready = ?", lobby.ID, false).Delete(&LobbySlot{}).Error

        if spec {

                for _, id := range playerids {

                        player := &Player{}

                        db.DB.First(player, id)

                        lobby.AddSpectator(player)

                }

        }

        lobby.OnChange(true)

        return err

}

func LoadLobbySettings(data []byte) error {

        var args struct {

                Formats []struct {

                        Name       string `json:"name"`

                        PrettyName string `json:"prettyName"`

                        Important  bool   `json:"important"`

                } `json:"formats"`

                Maps []struct {

                        Name    string         `json:"name"`

                        Formats map[string]int `json:"formats"`

                } `json:"maps"`

                Leagues []struct {

                        Name         string            `json:"name"`

                        PrettyName   string            `json:"prettyName"`

                        Descriptions map[string]string `json:"descriptions"`

                        Formats      map[string]bool   `json:"formats"`

                } `json:"leagues"`

                Whitelists []struct {

                        ID         int    `json:"id"`

                        PrettyName string `json:"prettyName"`

                        League     string `json:"league"`

                        Format     string `json:"format"`

                } `json:"whitelists"`

        }

        err := json.Unmarshal(data, &args)

        if err != nil {

        }

        // formats

        LobbyFormats = make([]LobbyFormat, len(args.Formats))

        lobbyFormatFromName = make(map[string]int)

        for i, format := range args.Formats {

                LobbyFormats[i] = LobbyFormat{

                        Name:       format.Name,

                        PrettyName: format.PrettyName,

                        Important:  format.Important,

                }

                lobbyFormatFromName[format.Name] = i

        }

        // maps

        LobbyMaps = make([]LobbyMap, len(args.Maps))

        lobbyMapFromName = make(map[string]int)

        for i, amap := range args.Maps {

                lobbyMap := LobbyMap{

                        Name:    amap.Name,

                        Formats: make([]*LobbyMapFormat, 0, len(amap.Formats)),

                }

                for name, importance := range amap.Formats {

                        if lobbyFormat, ok := GetLobbyFormat(name); ok {

                                lobbyMap.Formats = append(lobbyMap.Formats, &LobbyMapFormat{

                                        Format:     lobbyFormat,

                                        Importance: importance,

                                })

                        } else {

                        }

                }

                LobbyMaps[i] = lobbyMap

                lobbyMapFromName[amap.Name] = i

        }

        // leagues

        LobbyLeagues = make([]LobbyLeague, len(args.Leagues))

        lobbyLeagueFromName = make(map[string]int)

        for i, league := range args.Leagues {

                lobbyLeague := LobbyLeague{

                        Name:         league.Name,

                        PrettyName:   league.PrettyName,

                        Descriptions: make([]*LobbyLeagueDescription, 0, len(league.Descriptions)),

                        Formats:      make([]*LobbyLeagueFormat, 0, len(league.Formats)),

                }

                for atype, description := range league.Descriptions {

                        lobbyLeagueDescription := &LobbyLeagueDescription{

                                MapType:     MapType(atype),

                                Description: description,

                        }

                        lobbyLeague.Descriptions = append(lobbyLeague.Descriptions, lobbyLeagueDescription)

                }

                for name, used := range league.Formats {

                        if lobbyFormat, ok := GetLobbyFormat(name); ok {

                                lobbyLeagueFormat := &LobbyLeagueFormat{

                                        Format: lobbyFormat,

                                        Used:   used,

                                }

                                lobbyLeague.Formats = append(lobbyLeague.Formats, lobbyLeagueFormat)

                        } else {

                        }

                }

                LobbyLeagues[i] = lobbyLeague

                lobbyLeagueFromName[league.Name] = i

        }

        // whitelists

        LobbyWhitelists = make([]LobbyWhitelist, len(args.Whitelists))

        lobbyWhitelistFromID = make(map[int]int)

        for i, whitelist := range args.Whitelists {

                if lobbyLeague, ok := GetLobbyLeague(whitelist.League); ok {

                        if lobbyFormat, ok := GetLobbyFormat(whitelist.Format); ok {

                                lobbyWhitelist := LobbyWhitelist{

                                        ID:         whitelist.ID,

                                        PrettyName: whitelist.PrettyName,

                                        League:     lobbyLeague,

                                        Format:     lobbyFormat,

                                }

                                LobbyWhitelists[i] = lobbyWhitelist

                                lobbyWhitelistFromID[whitelist.ID] = i

                        } else {

                        }

                } else {

                }

        }

        return nil

}

func fumbleAllowPlayer(lobbyId uint, playerName string, playerTeam string) error {

        user := mumble.User{}

        user.Name = playerName

        user.Team = mumble.Team(playerTeam)

        err := fumble.Call("Fumble.AllowPlayer", &mumble.LobbyArgs{

                User: user, LobbyID: lobbyId}, &struct{}{})

        if err != nil {

        }

        return nil

}

func (player *Player) GetSetting(key string) string {

        db.DB.First(player)

        if player.Settings == nil {

                return ""

        }

        value, ok := player.Settings[key]

        if !ok {

        }

        return *value

}

func (lobby *Lobby) UpdateStats() {

        db.DB.Preload("Slots").First(lobby, lobby.ID)

        for _, slot := range lobby.Slots {

                player := &Player{}

                err := db.DB.First(player, slot.PlayerID).Error

                if err != nil {

                }

                db.DB.Preload("Stats").First(player, slot.PlayerID)

                player.Stats.PlayedCountIncrease(lobby.Type)

                player.Stats.IncreaseClassCount(lobby, slot.Slot)

                player.Save()

        }

        lobby.OnChange(false)

}

func LobbyGetSlotInfo(lobbytype LobbyType, slot int) (int, int, *helpers.TPError) {

        classList := typeClassList[lobbytype]

        if slot < len(classList) {

                return 0, slot, nil

        } else if slot < 2*len(classList) {

                return 1, slot - len(classList), nil

        } else {

        }

}

func (lobby *Lobby) RemoveSpectator(player *Player, broadcast bool) *helpers.TPError {

        err := db.DB.Model(lobby).Association("Spectators").Delete(player).Error

        if err != nil {

        }

        if broadcast {

                lobby.OnChange(false)

        }

        return nil

}

func (lobby *Lobby) RemovePlayer(player *Player) *helpers.TPError {

        err := db.DB.Where("player_id = ? AND lobby_id = ?", player.ID, lobby.ID).Delete(&LobbySlot{}).Error

        if err != nil {

        }

        DisallowPlayer(lobby.ID, player.SteamID)

        lobby.OnChange(true)

        return nil

}

func GetLobbyByID(id uint) (*Lobby, *helpers.TPError) {

        nonExistentLobby := helpers.NewTPError("Lobby not in the database", -1)

        lob := &Lobby{}

        err := db.DB.First(lob, id).Error

        if err != nil {

        }

        return lob, nil

}

func GetLobbyByIDServer(id uint) (*Lobby, *helpers.TPError) {

        nonExistentLobby := helpers.NewTPError("Lobby not in the database", -1)

        lob := &Lobby{}

        err := db.DB.Preload("ServerInfo").First(lob, id).Error

        if err != nil {

        }

        return lob, nil

}

func (m *LobbyMap) GetFormat(formatName string) (*LobbyMapFormat, bool) {

        for _, mapFormat := range m.Formats {

                if mapFormat.Format.Name == formatName {

                        return mapFormat, true

                }

        }

        if format, ok := GetLobbyFormat(formatName); ok {

                return &LobbyMapFormat{

                        Format:     format,

                        Importance: 0,

                }, true

        }

}

func NewPlayer(steamId string) (*Player, error) {

        player := &Player{SteamID: steamId}

        if config.Constants.SteamDevAPIKey == "" {

                player.Stats = NewPlayerStats()

                err := player.UpdatePlayerInfo()

                if err != nil {

                }

        } else {

        }

        player.MumbleUsername = player.GenMumbleUsername()

        player.MumbleAuthkey = player.GenAuthKey()

        return player, nil

}

func (lobby *Lobby) UnreadyPlayer(player *Player) *helpers.TPError {

        err := db.DB.Table("lobby_slots").Where("lobby_id = ? AND player_id = ?", lobby.ID, player.ID).UpdateColumn("ready", false).Error

        if err != nil {

        }

        lobby.OnChange(false)

        return nil

}

func (lobby *Lobby) IsPlayerInGame(player *Player) (bool, error) {

        var ingame bool

        err := db.DB.DB().QueryRow("SELECT in_game FROM lobby_slots WHERE lobby_id = $1 AND player_id = $2", lobby.ID, player.ID).Scan(&ingame)

        if err != nil {

        }

        return ingame, err

}

func (player *Player) GetSpectatingIds() ([]uint, *helpers.TPError) {

        var ids []uint

        err := db.DB.Model(&Lobby{}).

                Joins("INNER JOIN spectators_players_lobbies l ON l.lobby_id = lobbies.id").

                Where("l.player_id = ? AND lobbies.state <> ?", player.ID, LobbyStateEnded).

                Pluck("id", &ids).Error

        if err != nil {

        }

        return ids, nil

}

func (player *Player) IsSpectatingID(lobbyid uint) bool {

        count := 0

        err := db.DB.Table("spectators_players_lobbies").Where("player_id = ? AND lobby_id = ?", player.ID, lobbyid).Count(&count).Error

        if err != nil {

        }

        return count != 0

}

func (player *Player) GetActiveBans() ([]*PlayerBan, error) {

        var bans []*PlayerBan

        err := db.DB.Where("player_id = ? AND active = TRUE AND until > now()", player.ID).Find(&bans).Error

        if err != nil {

        }

        return bans, nil

}

func (lobby *Lobby) AddSpectator(player *Player) *helpers.TPError {

        err := db.DB.Model(lobby).Association("Spectators").Append(player).Error

        if err != nil {

        }

        lobby.OnChange(false)

        return nil

}

func (lobby *Lobby) GetPlayerNumber() int {

        count := 0

        err := db.DB.Table("lobby_slots").Where("lobby_id = ?", lobby.ID).Count(&count).Error

        if err != nil {

        }

        return count

}

func GetPlayerWithStats(steamid string) (*Player, *helpers.TPError) {

        var player = Player{}

        err := db.DB.Where("steam_id = ?", steamid).Preload("Stats").First(&player).Error

        if err != nil {

        }

        return &player, nil

}

func GetPlayerBySteamID(steamid string) (*Player, *helpers.TPError) {

        var player = Player{}

        err := db.DB.Where("steam_id = ?", steamid).First(&player).Error

        if err != nil {

        }

        return &player, nil

}

func (lobby *Lobby) ReadyPlayer(player *Player) *helpers.TPError {

        err := db.DB.Table("lobby_slots").Where("lobby_id = ? AND player_id = ?", lobby.ID, player.ID).UpdateColumn("ready", true).Error

        if err != nil {

        }

        lobby.OnChange(false)

        return nil

}

func GetPlayerByID(ID uint) (*Player, error) {

        player := &Player{}

        if err := db.DB.First(player, ID).Error; err != nil {

        }

        return player, nil

}

func (p *Player) Alias() string {

        alias := p.GetSetting("siteAlias")

        if alias == "" {

                return p.Name

        }

}

func FumbleLobbyEnded(lob *Lobby) {

        err := fumble.Call("Fumble.EndLobby", lob.ID, nil)

        if err != nil {

        }

}

func GetLobbyFormat(formatName string) (*LobbyFormat, bool) {

        if format, ok := lobbyFormatFromName[formatName]; ok {

                return &LobbyFormats[format], true

        }

}

func GetLobbyMap(mapName string) (*LobbyMap, bool) {

        if amap, ok := lobbyMapFromName[mapName]; ok {

                return &LobbyMaps[amap], true

        }

}

func GetLobbyLeague(leagueName string) (*LobbyLeague, bool) {

        if league, ok := lobbyLeagueFromName[leagueName]; ok {

                return &LobbyLeagues[league], true

        }

}

func (lobby *Lobby) AddPlayer(player *Player, slot int, password string) *helpers.TPError {

        /* Possible errors while joining

         * Slot has been filled

         * Player has already joined a lobby

         * anything else?

         */

        //check if slot password is valid

        if lobby.SlotPassword != "" && lobby.SlotPassword != password {

        }

        num := 0

        //Check if player is banned

        //TODO(nonagon): It should really be possible to do this query using relations

        if err := db.DB.Table("banned_players_lobbies").

                Where("lobby_id = ? AND player_id = ?", lobby.ID, player.ID).

                Count(&num).Error; num > 0 || err != nil {

                //logrus.Debug(fmt.Sprint(err))

                return LobbyBanErr

        }

        if slot >= 2*NumberOfClassesMap[lobby.Type] || slot < 0 {

                return BadSlotErr

        }

        var slotChange bool

        //Check if the player is currently in another lobby

        if currLobbyID, err := player.GetLobbyID(false); err == nil {

                if currLobbyID != lobby.ID {

                        //if the player is in a different lobby, remove them from that lobby

                        //plus substitute them

                        curLobby, _ := GetLobbyByID(currLobbyID)

                        if curLobby.State == LobbyStateInProgress {

                                curLobby.Substitute(player)

                        } else {

                        }

                } else { //player is in the same lobby, they're changing their slots

                        //assign the player to a new slot

                        if lobby.SlotNeedsSubstitute(slot) {

                                //the slot needs a substitute (which happens when the lobby is in progress),

                                //so players already in the lobby cannot fill it.

                        }

                        db.DB.Where("player_id = ? AND lobby_id = ?", player.ID, lobby.ID).Delete(&LobbySlot{})

                        slotChange = true

                }

        }

        if !slotChange {

                //check if the player is in the steam group whitelist

                url := fmt.Sprintf(`http://steamcommunity.com/groups/%s/memberslistxml/?xml=1`,

                        lobby.PlayerWhitelist)

                if lobby.PlayerWhitelist != "" && !helpers.IsWhitelisted(player.SteamID, url) {

                }

                if lobby.HasRequirements(slot) {

                        //check if player fits the requirements for the slot

                        if ok, err := lobby.FitsRequirements(player, slot); !ok {

                                return err

                        }

                }

                //check if player has been subbed to the twitch channel (if any)

                if lobby.TwitchChannel != "" {

                        //check if player has connected their twitch account

                        }

                        }

                }

        }

        // Check if player is a substitute (the slot needs a subtitute)

        if lobby.SlotNeedsSubstitute(slot) {

                //kicks previous slot occupant if they're in-game, resets their !rep count, removes them from the lobby

                //delete previous slot

                //notify players in game server of subtitute