import mysql.connector
import json
import random

class Card:
    def __init__(self):
        self.name = ""
        self.isVisible = False
        self.isAccessible = False
class Game:
    def __init__(self):
        self.board 
class Player:
    def __init__(self):
        self.name = "Player"
        self.ownedStarters = []
        self.ownedCitizens = []
        self.ownedDomains = []
        self.ownedDukes = []
        self.ownedMonsters = []
        self.goldScore = 2
        self.strengthScore = 0
        self.magicScore = 1
        self.isFirst = False
        self.shadowCount = 0
        self.holyCount = 0
        self.soldierCount = 0
        self.workerCount = 0
    def display(self):
        print(self.name)
        print(f"Gold: {self.goldScore} Strength: {self.strengthScore} Magic: {self.magicScore}")
        print(f"Starters: {len(self.ownedStarters)} Citizens: {len(self.ownedCitizens)} Monsters: {len(self.ownedMonsters)} Domains: {len(self.ownedDomains)}")
        if self.shadowCount != 0:
            tempChar = ''
            if self.shadowCount > 1:
                tempChar = 's'
            print(f"{self.shadowCount} Shadow icon{tempChar}")
        if self.holyCount != 0:
            tempChar = ''
            if self.holyCount > 1:
                tempChar = 's'
            print(f"{self.holyCount} Holy icon{tempChar}")
        if self.soldierCount != 0:
            tempChar = ''
            if self.soldierCount > 1:
                tempChar = 's'
            print(f"{self.soldierCount} Soldier icon{tempChar}")
        if self.workerCount != 0:
            tempChar = ''
            if self.workerCount > 1:
                tempChar = 's'
            print(f"{self.workerCount} Worker icon{tempChar}")
        print(f"Starters:")
        for starter in self.ownedStarters:
            print(f"{starter.name} {starter.rollMatch1} {starter.rollMatch2} {starter.goldPayoutOnTurn} {starter.goldPayoutOffTurn} {starter.strengthPayoutOnTurn} {starter.strengthPayoutOffTurn}")
        for citizen in self.ownedCitizens:
            print(f"{citizen.name} {citizen.goldCost} {citizen.rollMatch1} {citizen.rollMatch2} {citizen.goldPayoutOnTurn} {citizen.goldPayoutOffTurn} {citizen.strengthPayoutOnTurn} {citizen.strengthPayoutOffTurn}")
        for monster in self.ownedMonsters:
            print(f"{monster.name} {citizen.goldCost} {citizen.rollMatch1} {citizen.rollMatch2} {citizen.goldPayoutOnTurn} {citizen.goldPayoutOffTurn} {citizen.strengthPayoutOnTurn} {citizen.strengthPayoutOffTurn}")
    def calc_roles(self):
        for citizen in self.ownedCitizens:
            self.shadowCount = self.shadowCount + citizen.shadowCount
            self.holyCount = self.holyCount + citizen.holyCount
            self.soldierCount = self.soldierCount + citizen.soldierCount
            self.workerCount = self.workerCount + citizen.workerCount
        for domain in self.ownedDomains:
            self.shadowCount = self.shadowCount + domain.shadowCount
            self.holyCount = self.holyCount + domain.holyCount
            self.soldierCount = self.soldierCount + domain.soldierCount
            self.workerCount = self.workerCount + domain.workerCount

class Starter(Card):
    def __init__(self, name, roll_match1, roll_match2, gold_payout_on_turn, gold_payout_off_turn, strength_payout_on_turn, strength_payout_off_turn, magic_payout_on_turn, magic_payout_off_turn, has_special_payout_on_turn, has_special_payout_off_turn, special_payout_on_turn, special_payout_off_turn):
        self.name = name
        self.rollMatch1 = roll_match1
        self.rollMatch2 = roll_match2
        self.goldPayoutOnTurn = gold_payout_on_turn
        self.goldPayoutOffTurn = gold_payout_off_turn
        self.strengthPayoutOnTurn = strength_payout_on_turn
        self.strengthPayoutOffTurn = strength_payout_off_turn
        self.magicPayoutOnTurn = magic_payout_on_turn
        self.magicPayoutOffTurn = magic_payout_off_turn
        self.hasSpecialPayoutOnTurn = has_special_payout_on_turn
        self.hasSpecialPayoutOffTurn = has_special_payout_off_turn
        self.specialPayoutOnTurn = special_payout_on_turn
        self.specialPayoutOffTurn = special_payout_off_turn

class Citizen(Card):
    def __init__(self, name, gold_cost, roll_match1, roll_match2, shadow_count, holy_count, soldier_count, worker_count, gold_payout_on_turn, gold_payout_off_turn, strength_payout_on_turn, strength_payout_off_turn, magic_payout_on_turn, magic_payout_off_turn, has_special_payout_on_turn, has_special_payout_off_turn, special_payout_on_turn, special_payout_off_turn, special_citizen):
        self.name = name
        self.goldCost = gold_cost
        self.rollMatch1 = roll_match1
        self.rollMatch2 = roll_match2
        self.shadowCount = shadow_count
        self.holyCount = holy_count
        self.soldierCount = soldier_count
        self.workerCount = worker_count
        self.goldPayoutOnTurn = gold_payout_on_turn
        self.goldPayoutOffTurn = gold_payout_off_turn
        self.strengthPayoutOnTurn = strength_payout_on_turn
        self.strengthPayoutOffTurn = strength_payout_off_turn
        self.magicPayoutOnTurn = magic_payout_on_turn
        self.magicPayoutOffTurn = magic_payout_off_turn
        self.hasSpecialPayoutOnTurn = has_special_payout_on_turn
        self.hasSpecialPayoutOffTurn = has_special_payout_off_turn
        self.specialPayoutOnTurn = special_payout_on_turn
        self.specialPayoutOffTurn = special_payout_off_turn
        self.specialCitizen = special_citizen
    def display(self):
        print(f"\n{self.name}")
        print(f"Cost: {self.goldCost} Gold")
        if self.shadowCount != 0:
            tempChar = ''
            if self.shadowCount > 1:
                tempChar = 's'
            print(f"{self.shadowCount} Shadow icon{tempChar}")
        if self.holyCount != 0:
            tempChar = ''
            if self.holyCount > 1:
                tempChar = 's'
            print(f"{self.holyCount} Holy icon{tempChar}")
        if self.soldierCount != 0:
            tempChar = ''
            if self.soldierCount > 1:
                tempChar = 's'
            print(f"{self.soldierCount} Soldier icon{tempChar}")
        if self.workerCount != 0:
            tempChar = ''
            if self.workerCount > 1:
                tempChar = 's'
            print(f"{self.workerCount} Worker icon{tempChar}")

class Domain(Card):
    def __init__(self, name, gold_cost, shadow_count, holy_count, soldier_count, worker_count, vp_reward, has_activation_effect, has_passive_effect, passive_effect, activation_effect, text):
        self.name = name
        self.goldCost = gold_cost
        self.shadowCount = shadow_count
        self.holyCount = holy_count
        self.soldierCount = soldier_count
        self.workerCount = worker_count
        self.vpReward = vp_reward
        self.hasActivationEffect = has_activation_effect
        self.hasPassiveEffect = has_passive_effect
        self.passiveEffect = passive_effect
        self.activationEffect = activation_effect
        self.text = text
    def display(self):
        print("\n%s" % self.name)
        print("Cost: {} Gold".format(self.goldCost))
        if self.shadowCount != 0:
            tempChar = ''
            if self.shadowCount > 1:
                tempChar = 's'
            print(f"{self.shadowCount} Shadow icon{tempChar}")
        if self.holyCount != 0:
            tempChar = ''
            if self.holyCount > 1:
                tempChar = 's'
            print(f"{self.holyCount} Holy icon{tempChar}")
        if self.soldierCount != 0:
            tempChar = ''
            if self.soldierCount > 1:
                tempChar = 's'
            print(f"{self.soldierCount} Soldier icon{tempChar}")
        if self.workerCount != 0:
            tempChar = ''
            if self.workerCount > 1:
                tempChar = 's'
            print(f"{self.workerCount} Worker icon{tempChar}")
        print(self.text)

class Monster(Card):
    def __init__(self, name, area, type, order, strength_cost, magic_cost, vp_reward, gold_reward, strength_reward, magic_reward, has_special_reward, special_reward, has_special_cost, special_cost, is_extra):
        self.name = name
        self.area = area
        self.type = type
        self.order = order
        self.strengthCost = strength_cost
        self.magicCost = magic_cost
        self.vpReward = vp_reward
        self.goldReward = gold_reward
        self.strengthReward = strength_reward
        self.magicReward = magic_reward
        self.hasSpecialReward = has_special_reward
        self.specialReward = special_reward
        self.hasSpecialCost = has_special_cost
        self.specialCost = special_cost
        self.isExtra = is_extra
    def display(self):
        print(f"{self.name} is a {self.type} from {self.area}")
    def add_strength_cost(self, addedStrength):
        self.strengthCost = self.strengthCost + addedStrength
    def add_magic_cost(self, addedMagic):
        self.magicCost = self.magicCost + addedMagic

class Duke(Card):
    def __init__(self, name, gold_mult, strength_mult, magic_mult, shadow_mult, holy_mult, soldier_mult, worker_mult, monster_mult, citizen_mult, domain_mult, boss_mult, minion_mult, beast_mult, titan_mult):
        self.name = name
        self.goldMultiplier = gold_mult
        self.strengthMultiplier = strength_mult
        self.magicMultiplier = magic_mult
        self.shadowMultiplier = shadow_mult
        self.holyMultiplier = holy_mult
        self.soldierMultiplier = soldier_mult
        self.workerMultiplier = worker_mult
        self.monsterMultiplier = monster_mult
        self.citizenMultiplier = citizen_mult
        self.domainMultiplier = domain_mult
        self.bossMultiplier = boss_mult
        self.minionMultiplier = minion_mult
        self.beastMultiplier = beast_mult
        self.titanMultiplier = titan_mult
        
    def display(self):
        print("\n%s" % self.name)
        if (self.goldMultiplier != self.strengthMultiplier):
            resourceScore = 1/float(self.strengthMultiplier)
            print(f"1 Victory Point per gold and {resourceScore:.2f} per Strength/Magic")
        else:
            resourceScore = 1/float(self.goldMultiplier)
            print(f"{resourceScore:.2f} Victory Points per resource")
        if self.shadowMultiplier != 0:
            tempChar = ''
            if self.shadowMultiplier > 1:
                tempChar = 's'
            print(f"{self.shadowMultiplier} Victory Point{tempChar} per Shadow")
        if self.holyMultiplier != 0:
            tempChar = ''
            if self.holyMultiplier > 1:
                tempChar = 's'
            print(f"{self.holyMultiplier} Victory Point{tempChar} per Holy")
        if self.soldierMultiplier != 0:
            tempChar = ''
            if self.soldierMultiplier > 1:
                tempChar = 's'
            print(f"{self.soldierMultiplier} Victory Point{tempChar} per Soldier")
        if self.workerMultiplier != 0:
            tempChar = ''
            if self.workerMultiplier > 1:
                tempChar = 's'
            print(f"{self.workerMultiplier} Victory Point{tempChar} per Worker")
        if self.monsterMultiplier != 0:
            tempChar = ''
            if self.monsterMultiplier > 1:
                tempChar = 's'
            print(f"{self.monsterMultiplier} Victory Point{tempChar} per Monster")
        if self.citizenMultiplier != 0:
            tempChar = ''
            if self.citizenMultiplier > 1:
                tempChar = 's'
            print(f"{self.citizenMultiplier} Victory Point{tempChar} per Citizen")
        if self.domainMultiplier != 0:
            tempChar = ''
            if self.domainMultiplier > 1:
                tempChar = 's'
            print(f"{self.domainMultiplier} Victory Point{tempChar} per Domain")
        if self.bossMultiplier != 0:
            tempChar = ''
            if self.bossMultiplier > 1:
                tempChar = 's'
            print(f"{self.bossMultiplier} Victory Point{tempChar} per Boss")
        if self.titanMultiplier != 0:
            tempChar = ''
            if self.titanMultiplier > 1:
                tempChar = 's'
            print(f"{self.titanMultiplier} Victory Point{tempChar} per Titan")
   

class Board:
    def __init__(self, player_count, preset, numberOfDukes=2):
        self.playerCount = player_count
        self.preset = preset
        self.numberOfDukes = numberOfDukes
        self.playerList = []
        self.citizenGrid = [[] for _ in range(10)]
        self.domainGrid = [[] for _ in range(5)]
        self.monsterGrid = [[] for _ in range(5)]
        self.dukeStack = []
        self.domainStack = []
        self.citizenStack = []
        self.monsterStack = []
        self.starterStack = []
        self.dieOne = 0
        self.dieTwo = 0
        self.dieSum = 0
        self.exhaustedCount = 0
        
        myConnect = mysql.connector.connect(user='vckonline', password='vckonline', host='localhost', database='vckonline')
        myCursor = myConnect.cursor(dictionary = True)
        
#load game data
        myCursor.execute("SELECT * FROM dukes")
        myResult = myCursor.fetchall()
        for row in myResult:
            myDuke = Duke(row['name'], row['gold_mult'], row['strength_mult'], row['magic_mult'], row['shadow_mult'], row['holy_mult'], row['soldier_mult'], row['worker_mult'], row['monster_mult'], row['citizen_mult'], row['domain_mult'], row['boss_mult'], row['minion_mult'], row['beast_mult'], row['titan_mult'])
            self.dukeStack.append(myDuke)
        random.shuffle(self.dukeStack)
        for duke in self.dukeStack:
            duke.display()
        myCursor.execute("SELECT * FROM domains")
        myResult = myCursor.fetchall()
        for row in myResult:
            myDomain = Domain(row['name'], row['gold_cost'], row['shadow_count'], row['holy_count'], row['soldier_count'], row['worker_count'], row['vp_reward'], row['has_activation_effect'], row['has_passive_effect'], row['passive_effect'], row['activation_effect'], row['text'])
            self.domainStack.append(myDomain)
        random.shuffle(self.domainStack)
        for domain in self.domainStack:
            domain.display()

        myCursor.execute("SELECT * FROM citizens")
        myResult = myCursor.fetchall()
        for row in myResult:
            myCitizen = Citizen(row['name'], row['gold_cost'], row['roll_match1'], row['roll_match2'], row['shadow_count'], row['holy_count'], row['soldier_count'], row['worker_count'], row['gold_payout_on_turn'], row['gold_payout_off_turn'], row['strength_payout_on_turn'], row['strength_payout_off_turn'], row['magic_payout_on_turn'], row['magic_payout_off_turn'], row['has_special_payout_on_turn'], row['has_special_payout_off_turn'], row['special_payout_on_turn'], row['special_payout_off_turn'], row['special_citizen'])
            self.citizenStack.append(myCitizen)
        random.shuffle(self.citizenStack)
        for citizen in self.citizenStack:
            citizen.display()
        
        myCursor.execute("SELECT * FROM starters")
        myResult = myCursor.fetchall()
        for row in myResult:
            myStarter = Starter(row['name'], row['roll_match1'], row['roll_match2'], row['gold_payout_on_turn'], row['gold_payout_off_turn'], row['strength_payout_on_turn'], row['strength_payout_off_turn'], row['magic_payout_on_turn'], row['magic_payout_off_turn'], row['has_special_payout_on_turn'], row['has_special_payout_off_turn'], row['special_payout_on_turn'], row['special_payout_off_turn'])
            self.starterStack.append(myStarter)
        
        myCursor.execute("SELECT * FROM monsters")
        myResult = myCursor.fetchall()
        for row in myResult:
            myMonster = Monster(row['name'], row['area'], row['type'], row['order'], row['strength_cost'], row['magic_cost'], row['vp_reward'], row['gold_reward'], row['strength_reward'], row['magic_reward'], row['has_special_reward'], row['special_reward'], row['has_special_cost'], row['special_cost'], row['is_extra'])
            self.monsterStack.append(myMonster)
        for monster in self.monsterStack:
            monster.display()
        myConnect.close()
#end load game data

#create players and deal cards
        for x in range(0, self.playerCount):
            myPlayer = Player()
            myPlayer.name = f"Player {(x + 1)}" 
            self.playerList.append(myPlayer)
        random.shuffle(self.playerList)
        self.playerList[0].isFirst = True
        for player in self.playerList:
            player.ownedStarters.append(self.starterStack[0])
            player.ownedStarters.append(self.starterStack[1])
            for i in range(numberOfDukes):
                player.ownedDukes.append(self.dukeStack.pop())
        groupedMonsters = {}
        for monster in self.monsterStack:
            area = monster.area
            if area in groupedMonsters:
                groupedMonsters[area].append(monster)
            else:
                groupedMonsters[area] = [monster]
        if self.preset == "shuffled":
            # Convert groupedMonsters to a list of (area, monsters) tuples
            area_monsters = list(groupedMonsters.items())
            # Shuffle the list of (area, monsters) tuples
            random.shuffle(area_monsters)
            # Convert the shuffled list back to a dictionary
            groupedMonsters = {area: monsters for area, monsters in area_monsters}
        
        # Fill the stacks with monsters from each area
        stack_index = 0
        for area, monsters in groupedMonsters.items():
            if stack_index >= 5:  # stop dealing after 5 stacks
                break
            stack = self.monsterGrid[stack_index]
            for monster in monsters:
                stack.append(monster)
                stack_index = (stack_index + 1) % 5  # move to the next stack
        if self.playerCount != 5:
            for stack in self.monsterGrid:
                # Remove monsters with isExtra = True from each stack
                stack[:] = [monster for monster in stack if not monster.isExtra]
                # Turn monsters face up
                for monster in stack:
                    monster.is
        for i, stack in enumerate(self.monsterGrid):
            sorted_stack = sorted(stack, key=lambda monster: monster.order, reverse=True)
            self.monsterGrid[i] = sorted_stack
        for stack in self.monsterGrid:
            if stack:  # check if the stack is not empty
                monster = stack.pop()
                print(f"Popped {monster.name}")

    def roll_phase(self):
        self.dieOne = random.randint(1, 6)
        self.dieTwo = random.randint(1, 6)
        self.dieSum = self.dieOne + self.dieTwo
        print(f"{self.dieOne} | {self.dieTwo} | {self.dieSum}")
        for citizen in self.playerList[0].ownedCitizens:
            if (citizen.rollMatch1 == self.dieOne) or (citizen.rollMatch1 == self.dieTwo) or (citizen.rollMatch1 == self.dieSum) or (citizen.rollMatch2 == self.dieSum):
                print(f"{citizen.name} Payout")
                self.playerList[0].goldScore = self.playerList[0].goldScore + citizen.goldPayoutOnTurn
                self.playerList[0].strengthScore = self.playerList[0].strengthScore + citizen.strengthPayoutOnTurn
                self.playerList[0].magicScore = self.playerList[0].magicScore + citizen.magicPayoutOnTurn
        listIterator = iter(self.playerList)
        next(listIterator)
        for player in listIterator:
            for citizen in player.ownedCitizens:
                if (citizen.rollMatch1 == self.dieOne) or (citizen.rollMatch1 == self.dieTwo) or (citizen.rollMatch1 == self.dieSum) or (citizen.rollMatch2 == self.dieSum):
                    print(f"{citizen.name} Payout")
                    player.goldScore = player.goldScore + citizen.goldPayoutOffTurn
                    player.strengthScore = player.strengthScore + citizen.strengthPayoutOffTurn
                    player.magicScore = player.magicScore + citizen.magicPayoutOffTurn
                    
    def play_turn(self):
        self.roll_phase()
            
    def end_check(self):
        if self.exhaustedCount <= (self.playerCount*2):
            return False