fixed world of tanks mod : reset personal mission for obj 279 early

import BigWorld
from PlayerEvents import g_playerEvents
from gui.ClientUpdateManager import g_clientUpdateManager
from helpers import dependency
from skeletons.gui.shared import IItemsCache
import Account
from personal_missions import g_cache

STAT_DIFF_KEY = 'stats'
INVENTORY_DIFF_KEY = 'inventory'
_STAT_DIFF_FORMAT = STAT_DIFF_KEY + '.{0:>s}'
CREDITS_DIFF_KEY = _STAT_DIFF_FORMAT.format('credits')

class WBPMAutoReset:
    itemsCache = dependency.descriptor(IItemsCache)
    player = None
    canReset = True
    needTimer = True

    def __init__(self):
        self._initListeners()
        self._patchQuestResetter()

    def _patchQuestResetter(self):
        old_selectPersonalMissions = Account.PlayerAccount.selectPersonalMissions

        def new_selectPersonalMissions(self, personalMissionsIDs, questType, callback):
            old_selectPersonalMissions(self, personalMissionsIDs, questType, callback)

        Account.PlayerAccount.selectPersonalMissions = new_selectPersonalMissions

    def _initListeners(self):
        self.itemsCache.onSyncCompleted += self._onSyncCompleted
        g_playerEvents.onBattleResultsReceived += self._onBattleResultsReceived
        g_clientUpdateManager.addCallbacks({CREDITS_DIFF_KEY: self._onCreditsUpdate})

    def _onCreditsUpdate(self, _):
        self.canReset = True
        self._checkQuestState()

    def _onSyncCompleted(self, *args):
        self._checkQuestState()

    def _onBattleResultsReceived(self, isPlayerVehicle, results):
        self.canReset = True

    def _checkQuestState(self):
        questProgress = Account.g_accountRepository.questProgress
        if questProgress is None:
            return
        else:
            self.needTimer = True
            pmProgress = questProgress._QuestProgress__cache['pm2_progress']
            questsToReset = {}
            for q in pmProgress:
                quest = pmProgress[q]
                print '--\t', q, quest
                questId = g_cache._PQCache__questUniqueIDToPotapovQuestID['%s_main' % q]
                if 'battlesSeries' in quest.keys():
                    questKeys = quest['battlesSeries'].keys()
                    mainConditionFailed = False
                    advConditionFailed = False
                    if 'battles' in questKeys:
                        if len(quest['battlesSeries']['battles']) > 0:
                            mainConditionFailed = True
                            for battle in quest['battlesSeries']['battles']:
                                if battle:
                                    mainConditionFailed = False
                                    break

                        if mainConditionFailed:
                            questsToReset[questId] = True
                        else:
                            advConditionFailed = False
                            if 'state' in questKeys and quest['battlesSeries']['state'] >= 5:
                                if len(quest['battlesSeriesAdv']['battles']) > 0:
                                    advConditionFailed = True
                                    for battle in quest['battlesSeriesAdv']['battles']:
                                        if battle:
                                            advConditionFailed = False
                                            break

                                if advConditionFailed and len(quest['battlesSeries']['battles']) == 0:
                                    questsToReset[questId] = True

                    print '>>', questId, 'main cond:', mainConditionFailed, 'adv cond:', advConditionFailed,

            needReset = False
            for r in questsToReset:
                needReset = needReset or questsToReset[r]

            if needReset:
                self._resetQuest(questsToReset)
            else:
                print 'no need to reset quests:', questsToReset
            return

    def _voidCallback(self, *args):
        pass

    def _resetQuest(self, questIds):
        if self.canReset:
            self.canReset = False
            print ('>> trying to reset quest:', questIds, questIds.keys())
            BigWorld.player().resetPersonalMissions(list(questIds.keys()), 2, self._voidCallback)
            print ('>> reset seems successful', list(questIds.keys()))
        else:
            print '>> reset quest blocked till next battle'


wbPMAutoReset = WBPMAutoReset()