def addDefMessage(message):
    mColor = g_settings.getColorScheme('battle/message').getHexStr('unknown')
    pColor = g_settings.getColorScheme('battle/player').getHexStr('unknown')
    return g_settings.battle.messageFormat % {'playerColor': pColor,
     'playerName': unicode(g_sessionProvider.getCtx().getFullPlayerName(accID=message.originator), 'utf-8', errors='ignore'),
     'messageColor': mColor,
     'messageText': message.data}

def addDefMessage(message):
    mColor = g_settings.getColorScheme("battle/message").getHexStr("unknown")
    pColor = g_settings.getColorScheme("battle/player").getHexStr("unknown")
    return g_settings.battle.messageFormat % {
        "playerColor": pColor,
        "playerName": unicode(g_battleContext.getFullPlayerName(accID=message.originator), "utf-8", errors="ignore"),
        "messageColor": mColor,
        "messageText": message.data,
    }

 def setColors(self, dbID):
     pColorScheme = g_settings.getColorScheme('battle/player')
     pColor = pColorScheme.getHexStr('squadman')
     if isCurrentPlayer(dbID):
         pColor = pColorScheme.getHexStr('himself')
     elif g_sessionProvider.getCtx().isTeamKiller(accID=dbID):
         pColor = pColorScheme.getHexStr('teamkiller')
     self._ctx['playerColor'] = pColor
     self._ctx['messageColor'] = g_settings.getColorScheme('battle/message').getHexStr('squad')
     return self

 def getMessageColors(self, message):
     dbID = message.originator
     mColor = g_settings.getColorScheme('battle/message').getHexStr('squad')
     pColorScheme = g_settings.getColorScheme('battle/player')
     pColor = pColorScheme.getHexStr('squadman')
     if isCurrentPlayer(dbID):
         pColor = pColorScheme.getHexStr('himself')
     elif g_sessionProvider.getCtx().isTeamKiller(accID=dbID):
         pColor = pColorScheme.getHexStr('teamkiller')
     return (pColor, mColor)

 def getMessageColors(self, message):
     dbID = message.originator
     mColor = g_settings.getColorScheme("battle/message").getHexStr("squad")
     pColorScheme = g_settings.getColorScheme("battle/player")
     pColor = pColorScheme.getHexStr("squadman")
     if isCurrentPlayer(dbID):
         pColor = pColorScheme.getHexStr("himself")
     elif g_battleContext.isTeamKiller(accID=dbID):
         pColor = pColorScheme.getHexStr("teamkiller")
     return (pColor, mColor)

    def setPlayers(self, prbID, roster):
        foundIdx = -1
        getUser = self.usersStorage.getUser
        getColor = g_settings.getColorScheme('rosters').getColor
        for idx, item in enumerate(self.__list):
            if item['prbID'] == prbID:
                players = []
                foundIdx = idx
                for info in roster:
                    if info.roster is PREBATTLE_ROSTER.ASSIGNED_IN_TEAM1:
                        user = getUser(info.dbID)
                        if user is not None:
                            key = user.getGuiType()
                        else:
                            key = USER_GUI_TYPE.OTHER
                        players.append({'label': info.getFullName(),
                         'userName': info.name,
                         'clanAbbrev': info.clanAbbrev,
                         'igrType': info.igrType,
                         'region': g_lobbyContext.getRegionCode(info.dbID),
                         'color': getColor(key)})

                item['players'] = players
            else:
                item['players'] = []

        return foundIdx

    def buildList(self, selectedID, result):
        self.clear()
        userGetter = storage_getter('users')().getUser
        colorGetter = g_settings.getColorScheme('rosters').getColors
        pNameGetter = g_lobbyContext.getPeripheryName
        ratingFormatter = BigWorld.wg_getIntegralFormat
        self._selectedIdx = -1
        for unitItem in result:
            creator = unitItem.creator
            if creator:
                dbID = creator.dbID
                creatorVO = makePlayerVO(creator, userGetter(dbID), colorGetter)
            else:
                creatorVO = None
            cfdUnitID = unitItem.cfdUnitID
            index = len(self.collection)
            if cfdUnitID == selectedID:
                self._selectedIdx = index
            self.mapping[cfdUnitID] = index
            self.collection.append({'cfdUnitID': cfdUnitID,
             'unitMgrID': unitItem.unitMgrID,
             'creator': creatorVO,
             'creatorName': creatorVO.get('userName', ''),
             'rating': ratingFormatter(unitItem.rating),
             'playersCount': unitItem.playersCount,
             'commandSize': unitItem.commandSize,
             'inBattle': unitItem.state.isInArena(),
             'isFreezed': unitItem.state.isLocked(),
             'isRestricted': unitItem.isRosterSet,
             'description': unitItem.description,
             'peripheryID': unitItem.peripheryID,
             'server': pNameGetter(unitItem.peripheryID)})

        return self._selectedIdx

 def buildList(self, members):
     self.__list = []
     members = sorted(members, key=lambda member: member.getName().lower())
     getUser = self.usersStorage.getUser
     getColors = g_settings.getColorScheme("rosters").getColors
     for member in members:
         dbID = member.getDatabaseID()
         isOnline = member.isOnline()
         user = getUser(dbID)
         if user:
             tags = list(user.getTags())
             colors = getColors(user.getGuiType())
         else:
             tags = []
             colors = getColors(USER_GUI_TYPE.OTHER)
         self.__list.append(
             {
                 "dbID": dbID,
                 "userName": member.getFullName(),
                 "isOnline": isOnline,
                 "color": colors[0 if isOnline else 1],
                 "tags": tags,
                 "isPlayerSpeaking": False,
             }
         )

    def __updateUsersData(self, userDBIDs):
        diff = []
        userGetter = storage_getter('users')().getUser
        colorGetter = g_settings.getColorScheme('rosters').getColors
        for userDBID in userDBIDs:
            data = findFirst(lambda d: d['creator'].get('dbID') == userDBID, self.collection)
            if data is not None:
                clubDBID = data['cfdUnitID']
                try:
                    index = self.mapping[clubDBID]
                    item = self.collection[index]
                except (KeyError, IndexError):
                    LOG_ERROR('Item not found', clubDBID)
                    continue

                creator = userGetter(userDBID)
                creatorVO = makeUserVO(creator, colorGetter)
                creatorName = creator.getName()
                item.update({'creatorName': creatorName,
                 'rating': self.getGuiUserRating(userDBID)})
                if creator.hasValidName():
                    item['creator'] = creatorVO
                diff.append(index)

        if len(diff):
            self.updateItems(diff)
        return

 def _getColors(cls, name):
     if not cls._colors:
         scheme = g_settings.getColorScheme('contacts')
         cls._colors = {'friend': scheme.getColors('friend'),
          'clanMember': scheme.getColors('clanMember'),
          'others': scheme.getColors('others'),
          'currentUser': scheme.getColors('currentUser')}
     return cls._colors[name]

def makeUserItem(user):
    return {'uid': user.getID(),
     'userName': user.getName(),
     'chatRoster': user.getRoster(),
     'online': user.isOnline(),
     'himself': user.isCurrentPlayer(),
     'displayName': user.getFullName(),
     'colors': g_settings.getColorScheme('rosters').getColors(user.getGuiType())}

def makeUserItem(user):
    return {'dbID': user.getID(),
     'userName': user.getName(),
     'fullName': user.getFullName(),
     'tags': list(user.getTags()),
     'isOnline': user.isOnline(),
     'colors': g_settings.getColorScheme('rosters').getColors(user.getGuiType()),
     'clanAbbrev': user.getClanAbbrev()}

def _getSlotsData(unitIdx, unit, unitState, pInfo, slotsIter, app = None, levelsRange = None, checkForVehicles = True):
    isPlayerCreator = pInfo.isCreator()
    isPlayerInSlot = pInfo.isInSlot
    slots = []
    userGetter = storage_getter('users')().getUser
    colorGetter = g_settings.getColorScheme('rosters').getColors
    vehicleGetter = g_itemsCache.items.getItemByCD
    if app:
        isPlayerSpeaking = app.voiceChatManager.isPlayerSpeaking
    else:
        isPlayerSpeaking = lambda dbID: False
    if unitState.isFortBattle():
        makeVO = makeClanBattlePlayerVO
    elif unitState.isSortie():
        makeVO = makeSortiePlayerVO
    else:
        makeVO = makePlayerVO
    for slotInfo in slotsIter:
        index = slotInfo.index
        slotState = slotInfo.state
        player = slotInfo.player
        vehicle = slotInfo.vehicle
        canAssign, vehicles = pInfo.canAssignToSlot(index)
        vehCount = len(vehicles)
        slotLevel = 0
        vehicleVO = None
        slotPlayerUI = None
        if player is not None:
            dbID = player.dbID
            slotPlayerUI = makeVO(player, userGetter(dbID), colorGetter, isPlayerSpeaking(dbID))
            if vehicle:
                if 'vehLevel' in vehicle:
                    slotLevel = vehicle['vehLevel']
                if 'vehTypeCompDescr' in vehicle:
                    vehicleVO = makeVehicleVO(vehicleGetter(vehicle['vehTypeCompDescr']), levelsRange)
        slotLabel = makeSlotLabel(unitState, slotState, isPlayerCreator, vehCount, checkForVehicles)
        playerStatus = getPlayerStatus(slotState, player, unitState.isFortBattle())
        if unit is not None:
            restrictions = makeUnitRosterVO(unit, pInfo, index=index, isSortie=unitState.isSortie(), levelsRange=levelsRange)['conditions']
        else:
            restrictions = []
        isFreezed = unitState.isLocked() or unitState.isInSearch() or unitState.isInQueue() or unitState.isInArena()
        slot = {'rallyIdx': unitIdx,
         'isCommanderState': isPlayerCreator,
         'isCurrentUserInSlot': isPlayerInSlot,
         'playerStatus': playerStatus,
         'isClosed': slotState.isClosed,
         'isFreezed': isFreezed,
         'slotLabel': slotLabel,
         'player': slotPlayerUI,
         'canBeTaken': canAssign,
         'compatibleVehiclesCount': vehCount,
         'selectedVehicle': vehicleVO,
         'selectedVehicleLevel': 1 if slotState.isClosed else slotLevel,
         'restrictions': restrictions}
        slots.append(slot)

    return slots

    def updateList(self, selectedID, result):
        isFullUpdate, diff = False, []
        self._selectedIdx = None
        userGetter = storage_getter("users")().getUser
        colorGetter = g_settings.getColorScheme("rosters").getColors
        ratingFormatter = BigWorld.wg_getIntegralFormat
        result = set(result)
        removed = set(filter(lambda item: item[1] is None, result))
        isFullUpdate = len(removed)
        for cfdUnitID, unitItem in removed:
            index = self.mapping.pop(cfdUnitID, None)
            if index is not None:
                self.collection.pop(index)
                if cfdUnitID == selectedID:
                    self._selectedIdx = -1
                self.rebuildIndexes()

        if isFullUpdate:
            updated = result.difference(removed)
        else:
            updated = result
        for cfdUnitID, unitItem in updated:
            try:
                index = self.mapping[cfdUnitID]
                item = self.collection[index]
            except (KeyError, IndexError):
                LOG_ERROR("Item not found", unitItem)
                continue

            creator = unitItem.creator
            if creator:
                dbID = creator.dbID
                creatorVO = makePlayerVO(creator, userGetter(dbID), colorGetter)
            else:
                creatorVO = None
            item.update(
                {
                    "creator": creatorVO,
                    "creatorName": creatorVO.get("userName", ""),
                    "rating": ratingFormatter(unitItem.rating),
                    "playersCount": unitItem.playersCount,
                    "commandSize": unitItem.commandSize,
                    "inBattle": unitItem.flags.isInArena() or unitItem.flags.isInPreArena(),
                    "isFreezed": unitItem.flags.isLocked(),
                    "isRestricted": unitItem.isRosterSet,
                    "description": unitItem.description,
                }
            )
            diff.append(index)

        if self._selectedIdx is None and selectedID in self.mapping:
            self._selectedIdx = self.mapping[selectedID]
        if isFullUpdate:
            self.refresh()
        elif len(diff):
            self.updateItems(diff)
        return self._selectedIdx

 def getGuiUserData(self, userDbID):
     user = self.getContact(userDbID)
     colorGetter = g_settings.getColorScheme('rosters').getColors
     return {'userName': self.getGuiUserName(userDbID),
      'clanAbbrev': self.getUserClanAbbrev(userDbID),
      'region': self.getUserRegionCode(userDbID),
      'tags': user.getTags() if user else [],
      'dbID': userDbID,
      'colors': colorGetter(user.getGuiType() if user else USER_GUI_TYPE.OTHER)}

def makeUserItem(user):
    return {
        "dbID": user.getID(),
        "userName": user.getName(),
        "fullName": user.getFullName(),
        "tags": list(user.getTags()),
        "isOnline": user.isOnline(),
        "colors": g_settings.getColorScheme("rosters").getColors(user.getGuiType()),
        "clanAbbrev": user.getClanAbbrev(),
    }

 def _buildData(self, candidates):
     isPlayerSpeaking = self.bwProto.voipController.isPlayerSpeaking
     userGetter = storage_getter('users')().getUser
     colorGetter = g_settings.getColorScheme('rosters').getColors
     mapping = map(lambda pInfo: (pInfo, userGetter(pInfo.dbID)), candidates.itervalues())
     sortedList = sorted(mapping, cmp=getUnitCandidatesComparator())
     for pInfo, user in sortedList:
         dbID = pInfo.dbID
         self._mapping[dbID] = len(self._list)
         self._list.append(self._makePlayerVO(pInfo, user, colorGetter, isPlayerSpeaking(dbID)))

 def getMessageColors(self, message):
     dbID = message.originator
     mColor = g_settings.getColorScheme('battle/message').getHexStr('common')
     pColorScheme = g_settings.getColorScheme('battle/player')
     pColor = pColorScheme.getHexStr('unknown')
     if isCurrentPlayer(dbID):
         pColor = pColorScheme.getHexStr('himself')
     else:
         channel = self.channelsStorage.getChannel(self._teamChannel)
         if channel and channel.hasMember(dbID):
             if g_battleContext.isTeamKiller(accID=dbID):
                 pColor = pColorScheme.getHexStr('teamkiller')
             elif g_battleContext.isSquadMan(accID=dbID):
                 pColor = pColorScheme.getHexStr('squadman')
             else:
                 pColor = pColorScheme.getHexStr('teammate')
         elif self._channel.hasMember(dbID):
             pColor = pColorScheme.getHexStr('enemy')
     return (pColor, mColor)

def makeUserItem(user):
    return {'uid': user.getID(),
     'userName': user.getName(),
     'chatRoster': user.getRoster(),
     'online': user.isOnline(),
     'himself': user.isCurrentPlayer(),
     'displayName': user.getFullName(),
     'colors': g_settings.getColorScheme('rosters').getColors(user.getGuiType()),
     'group': user.getGroup(),
     'referralType': game_control.g_instance.refSystem.getUserType(user.getID())}

 def _getColors(cls, name):
     if not cls._colors:
         scheme = g_settings.getColorScheme("contacts")
         cls._colors = {
             "friend": scheme.getColors("friend"),
             "clanMember": scheme.getColors("clanMember"),
             "others": scheme.getColors("others"),
             "currentUser": scheme.getColors("currentUser"),
         }
     return cls._colors[name]