from direct.directnotify import DirectNotifyGlobal
from direct.showbase.PythonUtil import invertDictLossless
from toontown.coghq import MintRoomSpecs
from toontown.toonbase import ToontownGlobals
from direct.showbase.PythonUtil import normalDistrib, lerp
import random

def printAllCashbotInfo():
    print('roomId: roomName')
    for roomId, roomName in list(MintRoomSpecs.CashbotMintRoomId2RoomName.items()):
        print('%s: %s' % (roomId, roomName))

    print('\nroomId: numBattles')
    for roomId, numBattles in list(MintRoomSpecs.roomId2numBattles.items()):
        print('%s: %s' % (roomId, numBattles))

    print('\nmintId floor roomIds')
    printMintRoomIds()
    print('\nmintId floor numRooms')
    printNumRooms()
    print('\nmintId floor numForcedBattles')
    printNumBattles()


def iterateCashbotMints(func):
    from toontown.toonbase import ToontownGlobals
    for mintId in [ToontownGlobals.CashbotMintIntA, ToontownGlobals.CashbotMintIntB, ToontownGlobals.CashbotMintIntC]:
        for floorNum in range(ToontownGlobals.MintNumFloors[mintId]):
            func(MintLayout(mintId, floorNum))


def printMintInfo():

    def func(ml):
        print(ml)

    iterateCashbotMints(func)


def printMintRoomIds():

    def func(ml):
        print(ml.getMintId(), ml.getFloorNum(), ml.getRoomIds())

    iterateCashbotMints(func)


def printMintRoomNames():

    def func(ml):
        print(ml.getMintId(), ml.getFloorNum(), ml.getRoomNames())

    iterateCashbotMints(func)


def printNumRooms():

    def func(ml):
        print(ml.getMintId(), ml.getFloorNum(), ml.getNumRooms())

    iterateCashbotMints(func)


def printNumBattles():

    def func(ml):
        print(ml.getMintId(), ml.getFloorNum(), ml.getNumBattles())

    iterateCashbotMints(func)


BakedFloorLayouts = {12500: {0: (0,
             4,
             9,
             6,
             5,
             8,
             17),
         1: (0,
             15,
             13,
             16,
             7,
             6,
             22),
         2: (0,
             4,
             11,
             3,
             9,
             6,
             14,
             19),
         3: (0,
             1,
             3,
             4,
             16,
             14,
             15,
             24),
         4: (0,
             15,
             5,
             8,
             9,
             11,
             10,
             21),
         5: (0,
             13,
             12,
             8,
             7,
             16,
             10,
             18),
         6: (0,
             16,
             13,
             5,
             12,
             7,
             1,
             23),
         7: (0,
             10,
             12,
             7,
             3,
             13,
             16,
             8,
             20),
         8: (0,
             3,
             5,
             7,
             6,
             1,
             4,
             9,
             25),
         9: (0,
             6,
             9,
             10,
             13,
             16,
             8,
             4,
             22),
         10: (0,
              13,
              1,
              7,
              2,
              16,
              11,
              3,
              19),
         11: (0,
              3,
              1,
              6,
              4,
              14,
              8,
              9,
              24),
         12: (0,
              7,
              14,
              2,
              1,
              8,
              5,
              10,
              11,
              21),
         13: (0,
              13,
              6,
              4,
              11,
              3,
              9,
              10,
              8,
              17),
         14: (0,
              15,
              5,
              1,
              14,
              10,
              4,
              7,
              16,
              23),
         15: (0,
              16,
              10,
              11,
              2,
              1,
              3,
              14,
              5,
              20),
         16: (0,
              5,
              8,
              10,
              6,
              3,
              15,
              14,
              7,
              25),
         17: (0,
              12,
              13,
              5,
              8,
              14,
              11,
              7,
              16,
              10,
              22),
         18: (0,
              11,
              3,
              15,
              7,
              16,
              14,
              6,
              1,
              5,
              18),
         19: (0,
              10,
              16,
              11,
              3,
              5,
              12,
              13,
              7,
              14,
              24)},
 12600: {0: (0,
             8,
             1,
             6,
             14,
             2,
             5,
             9,
             17),
         1: (0,
             4,
             14,
             7,
             2,
             13,
             8,
             9,
             18),
         2: (0,
             7,
             9,
             6,
             5,
             14,
             12,
             3,
             20),
         3: (0,
             6,
             2,
             13,
             16,
             7,
             5,
             3,
             9,
             22),
         4: (0,
             15,
             4,
             9,
             8,
             6,
             13,
             5,
             11,
             23),
         5: (0,
             13,
             7,
             14,
             15,
             11,
             3,
             2,
             8,
             25),
         6: (0,
             5,
             14,
             2,
             11,
             7,
             16,
             10,
             15,
             18),
         7: (0,
             10,
             9,
             5,
             4,
             2,
             7,
             13,
             11,
             19),
         8: (0,
             11,
             4,
             12,
             6,
             1,
             13,
             7,
             3,
             21),
         9: (0,
             15,
             16,
             5,
             13,
             9,
             14,
             4,
             6,
             3,
             23),
         10: (0,
              16,
              15,
              7,
              6,
              8,
              3,
              4,
              9,
              10,
              24),
         11: (0,
              5,
              8,
              4,
              12,
              13,
              9,
              11,
              16,
              3,
              17),
         12: (0,
              13,
              16,
              7,
              4,
              12,
              3,
              6,
              5,
              1,
              19),
         13: (0,
              14,
              6,
              12,
              13,
              7,
              10,
              3,
              16,
              9,
              20),
         14: (0,
              9,
              15,
              13,
              5,
              6,
              3,
              14,
              11,
              4,
              22),
         15: (0,
              13,
              14,
              3,
              12,
              16,
              11,
              9,
              4,
              5,
              7,
              24),
         16: (0,
              3,
              6,
              1,
              7,
              5,
              10,
              9,
              4,
              13,
              15,
              25),
         17: (0,
              3,
              6,
              14,
              4,
              13,
              16,
              12,
              8,
              5,
              7,
              18),
         18: (0,
              11,
              13,
              4,
              1,
              15,
              6,
              3,
              8,
              9,
              16,
              20),
         19: (0,
              11,
              5,
              8,
              7,
              2,
              6,
              13,
              3,
              14,
              9,
              21)},
 12700: {0: (0,
             16,
             14,
             6,
             1,
             5,
             9,
             2,
             15,
             8,
             17),
         1: (0,
             3,
             2,
             12,
             14,
             8,
             13,
             6,
             10,
             7,
             23),
         2: (0,
             15,
             9,
             5,
             12,
             7,
             4,
             11,
             14,
             16,
             21),
         3: (0,
             2,
             13,
             7,
             6,
             8,
             15,
             4,
             1,
             11,
             19),
         4: (0,
             12,
             7,
             4,
             6,
             10,
             14,
             13,
             16,
             15,
             11,
             17),
         5: (0,
             10,
             2,
             9,
             13,
             4,
             8,
             1,
             15,
             14,
             11,
             23),
         6: (0,
             2,
             14,
             4,
             10,
             16,
             15,
             1,
             3,
             8,
             6,
             21),
         7: (0,
             14,
             11,
             1,
             7,
             9,
             10,
             12,
             8,
             5,
             2,
             19),
         8: (0,
             9,
             11,
             8,
             5,
             1,
             4,
             3,
             7,
             15,
             2,
             17),
         9: (0,
             2,
             9,
             7,
             11,
             16,
             10,
             15,
             3,
             8,
             6,
             23),
         10: (0,
              4,
              10,
              6,
              8,
              7,
              15,
              2,
              1,
              3,
              13,
              21),
         11: (0,
              10,
              14,
              8,
              6,
              9,
              15,
              5,
              1,
              2,
              13,
              19),
         12: (0,
              16,
              5,
              12,
              10,
              6,
              9,
              11,
              3,
              15,
              13,
              17),
         13: (0,
              1,
              3,
              6,
              14,
              4,
              10,
              12,
              15,
              13,
              16,
              24),
         14: (0,
              8,
              7,
              14,
              9,
              1,
              2,
              6,
              16,
              10,
              15,
              13,
              21),
         15: (0,
              4,
              1,
              8,
              11,
              12,
              3,
              10,
              16,
              13,
              6,
              15,
              19),
         16: (0,
              6,
              3,
              10,
              4,
              1,
              2,
              13,
              11,
              5,
              15,
              16,
              17),
         17: (0,
              6,
              16,
              5,
              12,
              11,
              1,
              8,
              14,
              15,
              9,
              10,
              24),
         18: (0,
              15,
              8,
              12,
              10,
              1,
              7,
              11,
              9,
              16,
              4,
              5,
              21),
         19: (0,
              10,
              2,
              16,
              5,
              6,
              11,
              13,
              7,
              12,
              1,
              3,
              19)}}

class MintLayout:
    notify = DirectNotifyGlobal.directNotify.newCategory('MintLayout')

    def __init__(self, mintId, floorNum):
        self.mintId = mintId
        self.floorNum = floorNum
        self.roomIds = []
        self.hallways = []
        self.numRooms = 1 + ToontownGlobals.MintNumRooms[self.mintId][self.floorNum]
        self.numHallways = self.numRooms - 1
        if self.mintId in BakedFloorLayouts and self.floorNum in BakedFloorLayouts[self.mintId]:
            self.roomIds = list(BakedFloorLayouts[self.mintId][self.floorNum])
        else:
            self.roomIds = self._genFloorLayout()
        hallwayRng = self.getRng()
        connectorRoomNames = MintRoomSpecs.CashbotMintConnectorRooms
        for i in range(self.numHallways):
            self.hallways.append(hallwayRng.choice(connectorRoomNames))

    def _genFloorLayout(self):
        rng = self.getRng()
        startingRoomIDs = MintRoomSpecs.CashbotMintEntranceIDs
        middleRoomIDs = MintRoomSpecs.CashbotMintMiddleRoomIDs
        finalRoomIDs = MintRoomSpecs.CashbotMintFinalRoomIDs

        numBattlesLeft = ToontownGlobals.MintNumBattles[self.mintId]

        finalRoomId = rng.choice(finalRoomIDs)
        numBattlesLeft -= MintRoomSpecs.getNumBattles(finalRoomId)

        middleRoomIds = []
        middleRoomsLeft = self.numRooms - 2

        numBattles2middleRoomIds = invertDictLossless(MintRoomSpecs.middleRoomId2numBattles)

        allBattleRooms = []
        for num, roomIds in list(numBattles2middleRoomIds.items()):
            if num > 0:
                allBattleRooms.extend(roomIds)
        while 1:
            allBattleRoomIds = list(allBattleRooms)
            rng.shuffle(allBattleRoomIds)
            battleRoomIds = self._chooseBattleRooms(numBattlesLeft,
                                                    allBattleRoomIds)
            if battleRoomIds is not None:
                break

            MintLayout.notify.info('could not find a valid set of battle rooms, trying again')

        middleRoomIds.extend(battleRoomIds)
        middleRoomsLeft -= len(battleRoomIds)

        if middleRoomsLeft > 0:
            actionRoomIds = numBattles2middleRoomIds[0]
            for i in range(middleRoomsLeft):
                roomId = rng.choice(actionRoomIds)
                actionRoomIds.remove(roomId)
                middleRoomIds.append(roomId)

        roomIds = []

        roomIds.append(rng.choice(startingRoomIDs))

        rng.shuffle(middleRoomIds)
        roomIds.extend(middleRoomIds)

        roomIds.append(finalRoomId)

        return roomIds

    def getNumRooms(self):
        return len(self.roomIds)

    def getRoomId(self, n):
        return self.roomIds[n]

    def getRoomIds(self):
        return self.roomIds[:]

    def getRoomNames(self):
        names = []
        for roomId in self.roomIds:
            names.append(MintRoomSpecs.CashbotMintRoomId2RoomName[roomId])

        return names

    def getNumHallways(self):
        return len(self.hallways)

    def getHallwayModel(self, n):
        return self.hallways[n]

    def getNumBattles(self):
        numBattles = 0
        for roomId in self.getRoomIds():
            numBattles += MintRoomSpecs.roomId2numBattles[roomId]

        return numBattles

    def getMintId(self):
        return self.mintId

    def getFloorNum(self):
        return self.floorNum

    def getRng(self):
        return random.Random(self.mintId * self.floorNum)

    def _chooseBattleRooms(self, numBattlesLeft, allBattleRoomIds, baseIndex = 0, chosenBattleRooms = None):
        if chosenBattleRooms is None:
            chosenBattleRooms = []
        while baseIndex < len(allBattleRoomIds):
            nextRoomId = allBattleRoomIds[baseIndex]
            baseIndex += 1
            newNumBattlesLeft = numBattlesLeft - MintRoomSpecs.middleRoomId2numBattles[nextRoomId]
            if newNumBattlesLeft < 0:
                continue
            elif newNumBattlesLeft == 0:
                chosenBattleRooms.append(nextRoomId)
                return chosenBattleRooms
            chosenBattleRooms.append(nextRoomId)
            result = self._chooseBattleRooms(newNumBattlesLeft, allBattleRoomIds, baseIndex, chosenBattleRooms)
            if result is not None:
                return result
            else:
                del chosenBattleRooms[-1:]
        else:
            return

        return

    def __str__(self):
        return 'MintLayout: id=%s, floor=%s, numRooms=%s, numBattles=%s' % (self.mintId,
         self.floorNum,
         self.getNumRooms(),
         self.getNumBattles())

    def __repr__(self):
        return str(self)