mtg_python_deckbuilder/deck_builder.py

from __future__ import annotations

import logging
import inquirer.prompt # type: ignore
import keyboard # type: ignore
import math
import numpy as np
import pandas as pd # type: ignore
import pprint # type: ignore
import random
import time

from functools import lru_cache
from fuzzywuzzy import process # type: ignore

from settings import basic_lands, card_types, csv_directory, multiple_copy_cards
from setup import determine_commanders

try:
    import scrython # type: ignore
    use_scrython = True
except ImportError:
    scrython = None
    use_scrython = False
    logging.warning("Scrython is not installed. Some pricing features will be unavailable.")

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s'
)

pd.set_option('display.max_columns', None)
pd.set_option('display.max_rows', None)
pd.set_option('display.max_colwidth', 50)

"""
Basic deck builder, primarily intended for building Kindred decks.
Logic for other themes (such as Spellslinger or Wheels), is added.
I plan to also implement having it recommend a commander or themes.

Currently, the script will ask questions to determine number of 
creatures, lands, interaction, ramp, etc... then add cards and 
adjust from there.

Land spread will ideally be handled based on pips and some adjustment
is planned based on mana curve and ramp added.
"""

def new_line(num_lines: int = 1) -> None:
    """Print specified number of newlines for formatting output.

    Args:
        num_lines (int): Number of newlines to print. Defaults to 1.

    Returns:
        None
    """
    if num_lines < 0:
        raise ValueError("Number of lines cannot be negative")
    print('\n' * num_lines)

class DeckBuilder:

    def __init__(self):
        self.card_library = pd.DataFrame()
        self.card_library['Card Name'] = pd.Series(dtype='str')
        self.card_library['Card Type'] = pd.Series(dtype='str')
        self.card_library['Mana Cost'] = pd.Series(dtype='str')
        self.card_library['Mana Value'] = pd.Series(dtype='int')
        self.card_library['Commander'] = pd.Series(dtype='bool')
        
        self.set_max_deck_price = False
        self.set_max_card_price = False
        self.card_prices = {} if use_scrython else None
        
    def pause_with_message(self, message="Press Enter to continue..."):
        """Helper function to pause execution with a message."""
        print(f"\n{message}")
        input()
        
    def validate_text(self, result: str) -> bool:
        """Validate text input is not empty.
        
        Args:
            result (str): Text input to validate
        
        Returns:
            bool: True if text is not empty after stripping whitespace
        """
        return bool(result and result.strip())
    
    def validate_number(self, result: str) -> float | None:
        """Validate and convert string input to float.
        
        Args:
            result (str): Number input to validate
        
        Returns:
            float | None: Converted float value or None if invalid
        """
        try:
            return float(result)
        except (ValueError, TypeError):
            return None
    def validate_confirm(self, result):
        return bool(result)
        
    def questionnaire(self, question_type, default_value='', choices_list=[]):
        MAX_ATTEMPTS = 3
        
        if question_type == 'Text':
            question = [inquirer.Text('text')]
            result = inquirer.prompt(question)['text']
            while not result.strip():
                question = [
                    inquirer.Text('text', message='Input cannot be empty')
                ]
                result = inquirer.prompt(question)['text']
            return result
            
        elif question_type == 'Number':
            attempts = 0
            question = [
                inquirer.Text('number', default=default_value)
            ]
            result = inquirer.prompt(question)['number']
            
            while attempts < MAX_ATTEMPTS:
                try:
                    result = float(result)
                    break
                except ValueError:
                    attempts += 1
                    if attempts < MAX_ATTEMPTS:
                        question = [
                            inquirer.Text('number', 
                                message='Input must be a valid number',
                                default=default_value)
                        ]
                        result = inquirer.prompt(question)['number']
                    else:
                        logging.error("Maximum input attempts reached for Number type.")
                        raise ValueError("Invalid number input.")
            return result
            
        elif question_type == 'Confirm':
            question = [
                inquirer.Confirm('confirm', default=default_value)
            ]
            result = inquirer.prompt(question)['confirm']
            return self.validate_confirm(result)
            
        elif question_type == 'Choice':
            question = [
                inquirer.List('selection',
                    choices=choices_list,
                    carousel=True)
            ]
            result = inquirer.prompt(question)['selection']
            return result
            
        raise ValueError(f"Unsupported question type: {question_type}")
    
    @lru_cache(maxsize=128)
    def price_check(self, card_name):
        try:
            time.sleep(0.1)
            card = scrython.cards.Named(fuzzy=card_name)
            card_price = card.prices('usd')
            if card_price is not None and isinstance(card_price, (int, float)):
                try:
                    self.card_prices[card_name] = card_price
                    return float(card_price)
                except ValueError:
                    logging.error(f"Invalid price format for '{card_name}': {card_price}")
                    return 0.0
            return 0.0
        except (scrython.foundation.ScryfallError, scrython.foundation.ScryfallRequestError) as e:
            logging.error(f"Scryfall API error for '{card_name}': {e}")
            return 0.0
        except TimeoutError:
            logging.error(f"Request timed out while fetching price for '{card_name}'")
            return 0.0
        except Exception as e:
            logging.error(f"Unexpected error fetching price for '{card_name}': {e}")
            return 0.0
        
    def determine_commander(self):
        # Setup dataframe
        try:
            df = pd.read_csv('csv_files/commander_cards.csv', converters={'themeTags': pd.eval, 'creatureTypes': pd.eval})
        except FileNotFoundError:
            determine_commanders()
            df = pd.read_csv('csv_files/commander_cards.csv', converters={'themeTags': pd.eval, 'creatureTypes': pd.eval})
        # Determine the commander of the deck
        # Set frames that have nothing for color identity to be 'COLORLESS' instead
        df['colorIdentity'] = df['colorIdentity'].fillna('COLORLESS')
        df['colors'] = df['colors'].fillna('COLORLESS')
        commander_chosen = False
        while not commander_chosen:
            print('Enter a card name to be your commander, note that at this time only cards that have the \'Creature\' type may be chosen')
            card_choice = self.questionnaire('Text', '')

            # Logic to find the card in the commander_cards csv, then display it's information
            # If the card can't be found, or doesn't have enough of a match score, display a 
            # list to choose from
            fuzzy_chosen = False
            while not fuzzy_chosen:
                match, score, _ = process.extractOne(card_choice, df['name'])
                if score >= 90:
                    fuzzy_card_choice = match
                    print(fuzzy_card_choice)
                    fuzzy_chosen = True
                else:
                    logging.warning('Multiple options found, which is correct?')
                    fuzzy_card_choices = process.extract(card_choice, df['name'], limit=5)
                    fuzzy_card_choices.append('Neither')
                    print(fuzzy_card_choices)
                    fuzzy_card_choice = self.questionnaire('Choice', choices_list=fuzzy_card_choices)
                    if isinstance(fuzzy_card_choice, tuple):
                        fuzzy_card_choice = fuzzy_card_choice[0]
                    if fuzzy_card_choice != 'Neither':
                        print(fuzzy_card_choice)
                        fuzzy_chosen = True

                    else:
                        break

                filtered_df = df[df['name'] == fuzzy_card_choice]
                df_dict = filtered_df.to_dict('list')
                print('Is this the card you chose?')
                pprint.pprint(df_dict, sort_dicts=False)
                self.commander_df = pd.DataFrame(df_dict)

                # Confirm if card entered was correct
                commander_confirmed = self.questionnaire('Confirm', True)
                # If correct, set it as the commander
                if commander_confirmed:
                    commander_chosen = True
                    self.commander_info = df_dict
                    self.commander = self.commander_df.at[0, 'name']
                    self.price_check(self.commander)
                    logging.info(f"Commander selected: {self.commander}")
                    break
                else:
                    commander_chosen = False

        # Send commander info to setup commander, including extracting info on colors, color identity,
        # creature types, and other information, like keywords, abilities, etc...
        self.commander_setup()
                
    def commander_setup(self):
        # Load commander info into a dataframe
        df = self.commander_df

        # Set type line
        self.commander_type = str(df.at[0, 'type'])

        # Set text line
        self.commander_text = str(df.at[0, 'text'])

        # Set Power
        self.commander_power = int(df.at[0, 'power'])

        # Set Toughness
        self.commander_toughness = int(df.at[0, 'toughness'])

        # Set Mana Cost
        self.commander_mana_cost = str(df.at[0, 'manaCost'])
        self.commander_mana_value = int(df.at[0, 'manaValue'])

        # Set color identity
        try:
            self.color_identity = df.at[0, 'colorIdentity']
            if pd.isna(self.color_identity):
                self.color_identity = 'COLORLESS'
            self.color_identity_full = ''
            self.determine_color_identity()
        except Exception as e:
            logging.error(f"Failed to set color identity: {e}")
            raise ValueError("Could not determine color identity") from e

        # Set creature colors
        if pd.notna(df.at[0, 'colors']) and df.at[0, 'colors'].strip():
            self.colors = [color.strip() for color in df.at[0, 'colors'].split(',') if color.strip()]
            if not self.colors:
                self.colors = ['COLORLESS']
        else:
            self.colors = ['COLORLESS']

        # Set creature types
        self.creature_types = str(df.at[0, 'creatureTypes'])

        # Set deck theme tags
        self.commander_tags = list(df.at[0, 'themeTags'])

        self.determine_themes()
        

        self.commander_dict = {
            'Commander Name': self.commander,
            'Mana Cost': self.commander_mana_cost,
            'Mana Value': self.commander_mana_value,
            'Color Identity': self.color_identity_full,
            'Colors': self.colors,
            'Type': self.commander_type,
            'Creature Types': self.creature_types,
            'Text': self.commander_text,
            'Power': self.commander_power,
            'Toughness': self.commander_toughness,
            'Themes': self.themes
        }
        self.add_card(self.commander, self.commander_type, self.commander_mana_cost, self.commander_mana_value, True)

        # Begin Building the Deck
        self.setup_dataframes()
        self.determine_ideals()
        self.add_lands()
        self.add_creatures()
        self.add_ramp()
        self.add_board_wipes()
        self.add_interaction()
        self.add_card_advantage()
        if len(self.card_library) < 100:
            self.fill_out_deck()
        self.card_library.to_csv(f'{csv_directory}/test_deck_presort.csv', index=False)
        self.organize_library()
        self.card_library.to_csv(f'{csv_directory}/test_deck_preconcat.csv', index=False)
        logging.info(f'Creature cards (including commander): {self.creature_cards}')
        logging.info(f'Planeswalker cards: {self.planeswalker_cards}')
        logging.info(f'Battle cards: {self.battle_cards}')
        logging.info(f'Instant cards: {self.instant_cards}')
        logging.info(f'Sorcery cards: {self.sorcery_cards}')
        logging.info(f'Artifact cards: {self.artifact_cards}')
        logging.info(f'Enchantment cards: {self.enchantment_cards}')
        logging.info(f'Land cards cards: {self.land_cards}')
        logging.info(f'Number of cards in Library: {len(self.card_library)}')
        self.get_cmc()
        self.count_pips()
        self.concatenate_duplicates()
        self.organize_library()
        self.sort_library()
        self.commander_to_top()
        self.card_library.to_csv(f'{csv_directory}/test_deck_done.csv', index=False)
        self.full_df.to_csv(f'{csv_directory}/test_all_after_done.csv', index=False)
    
    def determine_color_identity(self) -> None:
        """Determine the deck's color identity and set related attributes."""
        # Single color mapping
        mono_color_map = {
            'COLORLESS': ('Colorless', ['colorless']),
            'B': ('Black', ['colorless', 'black']),
            'G': ('Green', ['colorless', 'green']),
            'R': ('Red', ['colorless', 'red']),
            'U': ('Blue', ['colorless', 'blue']),
            'w': ('White', ['colorless', 'white'])
        }
        
        # Two-color mapping
        dual_color_map = {
            'B, G': ('Golgari: Black/Green', ['B', 'G', 'B, G'], ['colorless', 'black', 'green', 'golgari']),
            'B, R': ('Rakdos: Black/Red', ['B', 'R', 'B, R'], ['colorless', 'black', 'red', 'rakdos']),
            'B, U': ('Dimir: Black/Blue', ['B', 'U', 'B, U'], ['colorless', 'black', 'blue', 'dimir']),
            'B, W': ('Orzhov: Black/White', ['B', 'W', 'B, W'], ['colorless', 'black', 'white', 'orzhov']),
            'G, R': ('Gruul: Green/Red', ['G', 'R', 'G, R'], ['colorless', 'green', 'red', 'gruul']),
            'G, U': ('Simic: Green/Blue', ['G', 'U', 'G, U'], ['colorless', 'green', 'blue', 'simic']),
            'G, W': ('Selesnya: Green/White', ['G', 'W', 'G, W'], ['colorless', 'green', 'white', 'selesnya']),
            'R, U': ('Izzet: Blue/Red', ['U', 'R', 'U, R'], ['colorless', 'blue', 'red', 'izzet']),
            'U, W': ('Azorius: Blue/White', ['U', 'W', 'U, W'], ['colorless', 'blue', 'white', 'azorius']),
            'R, W': ('Boros: Red/White', ['R', 'W', 'R, W'], ['colorless', 'red', 'white', 'boros'])
        }
        
        # Three-color mapping
        tri_color_map = {
            'B, G, U': ('Sultai: Black/Blue/Green', ['B', 'G', 'U', 'B, G', 'B, U', 'G, U', 'B, G, U'],
                        ['colorless', 'black', 'blue', 'green', 'dimir', 'golgari', 'simic', 'sultai']),
            'B, G, R': ('Jund: Black/Red/Green', ['B', 'G', 'R', 'B, G', 'B, R', 'G, R', 'B, G, R'],
                        ['colorless', 'black', 'green', 'red', 'golgari', 'rakdos', 'gruul', 'jund']),
            'B, G, W': ('Abzan: Black/Green/White', ['B', 'G', 'W', 'B, G', 'B, W', 'G, W', 'B, G, W'],
                        ['colorless', 'black', 'green', 'white', 'golgari', 'orzhov', 'selesnya', 'abzan']),
            'B, R, U': ('Grixis: Black/Blue/Red', ['B', 'R', 'U', 'B, R', 'B, U', 'R, U', 'B, R, U'],
                        ['colorless', 'black', 'blue', 'red', 'dimir', 'rakdos', 'izzet', 'grixis']),
            'B, R, W': ('Mardu: Black/Red/White', ['B', 'R', 'W', 'B, R', 'B, W', 'R, W', 'B, R, W'],
                        ['colorless', 'black', 'red', 'white', 'rakdos', 'orzhov', 'boros', 'mardu']),
            'B, U, W': ('Esper: Black/Blue/White', ['B', 'U', 'W', 'B, U', 'B, W', 'U, W', 'B, U, W'],
                        ['colorless', 'black', 'blue', 'white', 'dimir', 'orzhov', 'azorius', 'esper']),
            'G, R, U': ('Temur: Blue/Green/Red', ['G', 'R', 'U', 'G, R', 'G, U', 'R, U', 'G, R, U'],
                        ['colorless', 'green', 'red', 'blue', 'simic', 'izzet', 'gruul', 'temur']),
            'G, R, W': ('Naya: Green/Red/White', ['G', 'R', 'W', 'G, R', 'G, W', 'R, W', 'G, R, W'],
                        ['green', 'red', 'white', 'gruul', 'selesnya', 'boros', 'naya']),
            'G, U, W': ('Bant: Blue/Green/White', ['G', 'U', 'W', 'G, U', 'G, W', 'U, W', 'G, U, W'],
                        ['colorless', 'green', 'blue', 'white', 'simic', 'azorius', 'selesnya', 'bant']),
            'R, U, W': ('Jeskai: Blue/Red/White', ['R', 'U', 'W', 'R, U', 'U, W', 'R, W', 'R, U, W'],
                        ['colorless', 'blue', 'red', 'white', 'izzet', 'azorius', 'boros', 'jeskai'])
        }
        
        other_color_map ={
            'B, G, R, U': ('Glint: Black/Blue/Green/Red',
                           ['B', 'G', 'R', 'U', 'B, G', 'B, R', 'B, U','G, R', 'G, U', 'R, U', 'B, G, R',
                            'B, G, U', 'B, R, U', 'G, R, U' , 'B, G, R, U'],
                           ['colorless', 'black', 'blue', 'green', 'red', 'golgari', 'rakdos', 'dimir',
                            'gruul','simic', 'izzet', 'jund', 'sultai', 'grixis', 'temur', 'glint']),
            'B, G, R, W': ('Dune: Black/Green/Red/White',
                           ['B', 'G', 'R', 'W', 'B, G', 'B, R', 'B, W', 'G, R', 'G, W', 'R, W', 'B, G, R',
                            'B, G, W', 'B, R, W', 'G, R, W' , 'B, G, R, W'],
                           ['colorless', 'black', 'green', 'red', 'white', 'golgari', 'rakdos', 'orzhov',
                            'gruul', 'selesnya', 'boros', 'jund', 'abzan', 'mardu', 'naya', 'dune']),
            'B, G, U, W': ('Witch: Black/Blue/Green/White',
                           ['B', 'G', 'U', 'W', 'B, G', 'B, U', 'B, W', 'G, U', 'G, W', 'U, W', 'B, G, U',
                            'B, G, W', 'B, U, W', 'G, U, W' , 'B, G, U, W'],
                           ['colorless', 'black', 'blue', 'green', 'white', 'golgari', 'dimir', 'orzhov',
                            'simic', 'selesnya', 'azorius', 'sultai', 'abzan', 'esper', 'bant', 'witch']),
            'B, R, U, W': ('Yore: Black/Blue/Red/White',
                           ['B', 'R', 'U', 'W', 'B, R', 'B, U', 'B, W', 'R, U', 'R, W', 'U, W', 'B, R, U',
                            'B, R, W', 'B, U, W', 'R, U, W' , 'B, R, U, W'],
                           ['colorless', 'black', 'blue', 'red', 'white', 'rakdos', 'dimir', 'orzhov',
                            'izzet', 'boros', 'azorius', 'grixis', 'mardu', 'esper', 'mardu', 'yore']),
            'G, R, U, W': ('Ink: Blue/Green/Red/White',
                           ['G', 'R', 'U', 'W', 'G, R', 'G, U', 'G, W', 'R, U', 'R, W', 'U, W', 'G, R, U',
                            'G, R, W', 'G, U, W', 'R, U, W', 'G, R, U, W'],
                           ['colorless', 'blue', 'green', 'red', 'white', 'gruul', 'simic', 'selesnya',
                            'izzet', 'boros', 'azorius', 'temur', 'naya', 'bant', 'jeskai', 'ink']),
            'B, G, R, U, W': ('WUBRG: All colors',
                              ['B', 'G', 'R', 'U', 'W', 'B, G', 'B, R', 'B, U', 'B, W', 'G, R', 'G, U',
                               'G, W', 'R, U', 'R, W', 'U, W', 'B, G, R', 'B, G, U', 'B, G, W', 'B, R, U',
                               'B, R, W', 'B, U, W', 'G, R, U', 'G, R, W', 'B, U ,W', 'R, U, W',
                               'B, G, R, U', 'B, G, R, W', 'B, G, U, W', 'B, R, U, W', 'G, R, U, W',
                               'B, G, R, U, W'],
                              ['colorless', 'black', 'green', 'red', 'blue', 'white', 'golgari', 'rakdos',
                               'dimir', 'orzhov', 'gruul', 'simic', 'selesnya', 'izzet', 'boros', 'azorius',
                               'jund', 'sultai', 'abzan', 'grixis', 'mardu', 'esper', 'temur', 'naya',
                               'bant', 'jeskai', 'glint', 'dune','witch', 'yore', 'ink', 'wubrg'])
        }
        
        try:
            # Handle mono-color identities
            if self.color_identity in mono_color_map:
                self.color_identity_full, self.files_to_load = mono_color_map[self.color_identity]
                return
                
            # Handle two-color identities
            if self.color_identity in dual_color_map:
                identity_info = dual_color_map[self.color_identity]
                self.color_identity_full = identity_info[0]
                self.color_identity_options = identity_info[1]
                self.files_to_load = identity_info[2]
                return
            
            # Handle three-color identities
            if self.color_identity in tri_color_map:
                identity_info = tri_color_map[self.color_identity]
                self.color_identity_full = identity_info[0]
                self.color_identity_options = identity_info[1]
                self.files_to_load = identity_info[2]
                return
            
            # Handle four-color/five-color identities
            if self.color_identity in other_color_map:
                identity_info = other_color_map[self.color_identity]
                self.color_identity_full = identity_info[0]
                self.color_identity_options = identity_info[1]
                self.files_to_load = identity_info[2]
                return
                
            # If we get here, it's an unknown color identity
            logging.warning(f"Unknown color identity: {self.color_identity}")
            self.color_identity_full = 'Unknown'
            self.files_to_load = ['colorless']
            
        except Exception as e:
            logging.error(f"Error in determine_color_identity: {e}")
            raise
    
    def read_csv(self, filename: str, converters: dict | None = None) -> pd.DataFrame:
        """Read CSV file with error handling and logging.
        
        Args:
            filename: Name of the CSV file without extension
            converters: Dictionary of converters for specific columns
        
        Returns:
            DataFrame from CSV file
        """
        try:
            filepath = f'{csv_directory}/{filename}_cards.csv'
            df = pd.read_csv(filepath, converters=converters or {'themeTags': pd.eval, 'creatureTypes': pd.eval})
            logging.debug(f"Successfully read {filename}_cards.csv")
            return df
        except FileNotFoundError as e:
            logging.error(f"File {filename}_cards.csv not found: {e}")
            raise
        except Exception as e:
            logging.error(f"Error reading {filename}_cards.csv: {e}")
            raise

    def write_csv(self, df: pd.DataFrame, filename: str) -> None:
        """Write DataFrame to CSV with error handling and logging.
        
        Args:
            df: DataFrame to write
            filename: Name of the CSV file without extension
        """
        try:
            filepath = f'{csv_directory}/{filename}.csv'
            df.to_csv(filepath, index=False)
            logging.debug(f"Successfully wrote {filename}.csv")
        except Exception as e:
            logging.error(f"Error writing {filename}.csv: {e}")
            raise

    def setup_dataframes(self):
        """Initialize and setup all required DataFrames."""
        all_df = []
        for file in self.files_to_load:
            df = self.read_csv(file)
            all_df.append(df)
        self.full_df = pd.concat(all_df, ignore_index=True)
        self.full_df.sort_values(by='edhrecRank', inplace=True)
        
        self.land_df = self.full_df[self.full_df['type'].str.contains('Land')].copy()
        self.land_df.sort_values(by='edhrecRank', inplace=True)
        self.land_df.to_csv(f'{csv_directory}/test_lands.csv', index=False)
        
        self.full_df = self.full_df[~self.full_df['type'].str.contains('Land')]
        self.full_df.to_csv(f'{csv_directory}/test_all.csv', index=False)
        
        self.artifact_df = self.full_df[self.full_df['type'].str.contains('Artifact')].copy()
        self.artifact_df.sort_values(by='edhrecRank', inplace=True)
        self.artifact_df.to_csv(f'{csv_directory}/test_artifacts.csv', index=False)
        
        self.battle_df = self.full_df[self.full_df['type'].str.contains('Battle')].copy()
        self.battle_df.sort_values(by='edhrecRank', inplace=True)
        self.battle_df.to_csv(f'{csv_directory}/test_battles.csv', index=False)
        
        self.creature_df = self.full_df[self.full_df['type'].str.contains('Creature')].copy()
        self.creature_df.sort_values(by='edhrecRank', inplace=True)
        self.creature_df.to_csv(f'{csv_directory}/test_creatures.csv', index=False)
        
        self.noncreature_df = self.full_df[~self.full_df['type'].str.contains('Creature')].copy()
        self.noncreature_df.sort_values(by='edhrecRank', inplace=True)
        self.noncreature_df.to_csv(f'{csv_directory}/test_noncreatures.csv', index=False)
        
        self.noncreature_nonplaneswaker_df = self.noncreature_df[~self.noncreature_df['type'].str.contains('Planeswalker')].copy()
        self.noncreature_nonplaneswaker_df.sort_values(by='edhrecRank', inplace=True)
        self.noncreature_nonplaneswaker_df.to_csv(f'{csv_directory}/test_noncreatures.csv', index=False)
        
        self.enchantment_df = self.full_df[self.full_df['type'].str.contains('Enchantment')].copy()
        self.enchantment_df.sort_values(by='edhrecRank', inplace=True)
        self.enchantment_df.to_csv(f'{csv_directory}/test_enchantments.csv', index=False)
        
        self.instant_df = self.full_df[self.full_df['type'].str.contains('Instant')].copy()
        self.instant_df.sort_values(by='edhrecRank', inplace=True)
        self.instant_df.to_csv(f'{csv_directory}/test_instants.csv', index=False)
        
        self.planeswalker_df = self.full_df[self.full_df['type'].str.contains('Planeswalker')].copy()
        self.planeswalker_df.sort_values(by='edhrecRank', inplace=True)
        self.planeswalker_df.to_csv(f'{csv_directory}/test_planeswalkers.csv', index=False)
        
        self.sorcery_df = self.full_df[self.full_df['type'].str.contains('Sorcery')].copy()
        self.sorcery_df.sort_values(by='edhrecRank', inplace=True)
        self.sorcery_df.to_csv(f'{csv_directory}/test_sorcerys.csv', index=False)
    
    def determine_themes(self):
        themes = self.commander_tags
        print('Your commander deck will likely have a number of viable themes, but you\'ll want to narrow it down for focus.\n'
                'This will go through the process of choosing up to three themes for the deck.\n')
        while True:
            # Choose a primary theme
            print('Choose a primary theme for your commander deck.\n'
                'This will be the "focus" of the deck, in a kindred deck this will typically be a creature type for example.')
            choice = self.questionnaire('Choice', choices_list=themes)
            self.primary_theme = choice
            weights_default = {
                'primary': 1.0,
                'secondary': 0.0,
                'tertiary': 0.0,
                'hidden': 0.0
                }
            weights = weights_default.copy()
            themes.remove(choice)
            themes.append('Stop Here')
            self.primary_weight = weights['primary']

            secondary_theme_chosen = False
            tertiary_theme_chosen = False
            self.hidden_theme = False

            while not secondary_theme_chosen:
                # Secondary theme
                print('Choose a secondary theme for your commander deck.\n'
                    'This will typically be a secondary focus, like card draw for Spellslinger, or +1/+1 counters for Aggro.')
                choice = self.questionnaire('Choice', choices_list=themes)
                while True:
                    if choice == 'Stop Here':
                        logging.warning('You\'ve only selected one theme, are you sure you want to stop?\n')
                        confirm_done = self.questionnaire('Confirm', False)
                        if confirm_done:
                            secondary_theme_chosen = True
                            self.secondary_theme = False
                            tertiary_theme_chosen = True
                            self.tertiary_theme = False
                            themes.remove(choice)
                            break
                        else:
                            pass

                    else:
                        weights = weights_default.copy() # primary = 1.0, secondary = 0.0, tertiary = 0.0
                        self.secondary_theme = choice
                        themes.remove(choice)
                        secondary_theme_chosen = True
                        # Set weights for primary/secondary themes
                        if 'Kindred' in self.primary_theme and 'Kindred' not in self.secondary_theme:
                            weights['primary'] -= 0.1 # 0.8
                            weights['secondary'] += 0.1 # 0.1
                        elif 'Kindred' in self.primary_theme and 'Kindred' in self.secondary_theme:
                            weights['primary'] -= 0.7 # 0.7
                            weights['secondary'] += 0.3 # 0.3
                        else:
                            weights['primary'] -= 0.4 # 0.6
                            weights['secondary'] += 0.4 # 0.4
                        self.primary_weight = weights['primary']
                        self.secondary_weight = weights['secondary']
                        break

            while not tertiary_theme_chosen:
                # Tertiary theme
                print('Choose a tertiary theme for your commander deck.\n'
                    'This will typically be a tertiary focus, or just something else to do that your commander is good at.')
                choice = self.questionnaire('Choice', choices_list=themes)
                while True:
                    if choice == 'Stop Here':
                        logging.warning('You\'ve only selected two themes, are you sure you want to stop?\n')
                        confirm_done = self.questionnaire('Confirm', False)
                        if confirm_done:
                            tertiary_theme_chosen = True
                            self.tertiary_theme = False
                            themes.remove(choice)
                            break
                        else:
                            pass

                    else:
                        weights = weights_default.copy() # primary = 1.0, secondary = 0.0, tertiary = 0.0
                        self.tertiary_theme = choice
                        tertiary_theme_chosen = True
                        
                        # Set weights for themes:
                        if 'Kindred' in self.primary_theme and 'Kindred' not in self.secondary_theme and 'Kindred' not in self.tertiary_theme:
                            weights['primary'] -= 0.2 # 0.8
                            weights['secondary'] += 0.1 # 0.1
                            weights['tertiary'] += 0.1 # 0.1
                        elif 'Kindred' in self.primary_theme and 'Kindred' in self.secondary_theme and 'Kindred' not in self.tertiary_theme:
                            weights['primary'] -= 0.3 # 0.7
                            weights['secondary'] += 0.2 # 0.2
                            weights['tertiary'] += 0.1 # 0.1
                        elif 'Kindred' in self.primary_theme and 'Kindred' in self.secondary_theme and 'Kindred' in self.tertiary_theme:
                            weights['primary'] -= 0.5 # 0.5
                            weights['secondary'] += 0.3 # 0.3
                            weights['tertiary'] += 0.2 # 0.2
                        else:
                            weights['primary'] -= 0.6 # 0.4
                            weights['secondary'] += 0.3 # 0.3
                            weights['tertiary'] += 0.3 # 0.3
                        self.primary_weight = weights['primary']
                        self.secondary_weight = weights['secondary']
                        self.tertiary_weight = weights['tertiary']
                        break
            
            self.themes = [self.primary_theme]
            if not self.secondary_theme:
                pass
            else:
                self.themes.append(self.secondary_theme)
            if not self.tertiary_theme:
                pass
            else:
                self.themes.append(self.tertiary_theme)
                
            """
            Setting 'Hidden' themes for multiple-copy cards, such as 'Hare Apparent' or 'Shadowborn Apostle'.
            These are themes that will be prompted for under specific conditions, such as a matching Kindred theme or a matching color combination and Spellslinger theme for example.
            Typically a hidden theme won't come up, but if it does, it will take priority with theme weights to ensure a decent number of the specialty cards are added.
            """
            # Setting hidden theme for Kindred-specific themes
            hidden_themes = ['Advisor Kindred', 'Demon Kindred', 'Dwarf Kindred', 'Rabbit Kindred', 'Rat Kindred', 'Wraith Kindred']
            theme_cards = ['Persistent Petitioners', 'Shadowborn Apostle', 'Seven Dwarves', 'Hare Apparent', ['Rat Colony', 'Relentless Rats'], 'Nazgûl']
            color = ['B', 'B', 'R', 'W', 'B', 'B']
            for i in range(min(len(hidden_themes), len(theme_cards), len(color))):
                if (hidden_themes[i] in self.themes
                    and hidden_themes[i] != 'Rat Kindred'
                    and color[i] in self.colors):
                    logging.info(f'Looks like you\'re making a {hidden_themes[i]} deck, would you like it to be a {theme_cards[i]} deck?')
                    choice = self.questionnaire('Confirm', False)
                    if choice:
                        self.hidden_theme = theme_cards[i]
                        self.themes.append(self.hidden_theme)
                        weights['primary'] = round(weights['primary'] / 3, 2)
                        weights['secondary'] = round(weights['secondary'] / 2, 2)
                        weights['tertiary'] = weights['tertiary'] 
                        weights['hidden'] = round(1.0 - weights['primary'] - weights['secondary'] - weights['tertiary'], 2)
                        self.primary_weight = weights['primary']
                        self.secondary_weight = weights['secondary']
                        self.tertiary_weight = weights['tertiary']
                        self.hidden_weight = weights['hidden']
                    else:
                        continue
                    
                elif (hidden_themes[i] in self.themes
                      and hidden_themes[i] == 'Rat Kindred'
                      and color[i] in self.colors):
                    logging.info(f'Looks like you\'re making a {hidden_themes[i]} deck, would you like it to be a {theme_cards[i][0]} or {theme_cards[i][1]} deck?')
                    choice = self.questionnaire('Confirm', False)
                    if choice:
                        print('Which one?')
                        choice = self.questionnaire('Choice', choices_list=theme_cards[i])
                        if choice:
                            self.hidden_theme = choice
                            self.themes.append(self.hidden_theme)
                            weights['primary'] = round(weights['primary'] / 3, 2)
                            weights['secondary'] = round(weights['secondary'] / 2, 2)
                            weights['tertiary'] = weights['tertiary'] 
                            weights['hidden'] = round(1.0 - weights['primary'] - weights['secondary'] - weights['tertiary'], 2)
                            self.primary_weight = weights['primary']
                            self.secondary_weight = weights['secondary']
                            self.tertiary_weight = weights['tertiary']
                            self.hidden_weight = weights['hidden']
                    else:
                        continue
            
            # Setting the hidden theme for non-Kindred themes
            hidden_themes = ['Little Fellas', 'Mill', 'Spellslinger', 'Spells Matter', 'Spellslinger', 'Spells Matter',]
            theme_cards = ['Hare Apparent', 'Persistent Petitions', 'Dragon\'s Approach', 'Dragon\'s Approach', 'Slime Against Humanity', 'Slime Against Humanity']
            color = ['W', 'B', 'R', 'R', 'G', 'G']
            for i in range(min(len(hidden_themes), len(theme_cards), len(color))):
                if (hidden_themes[i] in self.themes
                    and color[i] in self.colors):
                    logging.info(f'Looks like you\'re making a {hidden_themes[i]} deck, would you like it to be a {theme_cards[i]} deck?')
                    choice = self.questionnaire('Confirm', False)
                    if choice:
                        self.hidden_theme = theme_cards[i]
                        self.themes.append(self.hidden_theme)
                        weights['primary'] = round(weights['primary'] / 3, 2)
                        weights['secondary'] = round(weights['secondary'] / 2, 2)
                        weights['tertiary'] = weights['tertiary'] 
                        weights['hidden'] = round(1.0 - weights['primary'] - weights['secondary'] - weights['tertiary'], 2)
                        self.primary_weight = weights['primary']
                        self.secondary_weight = weights['secondary']
                        self.tertiary_weight = weights['tertiary']
                        self.hidden_weight = weights['hidden']
                    else:
                        continue
            
            break
    
    def determine_ideals(self):
        # "Free" slots that can be used for anything that isn't the ideals
        self.free_slots = 99
        
        if use_scrython:
            print('Would you like to set an intended max price of the deck?\n'
                  'There will be some leeway of ~10%, with a couple alternative options provided.')
            choice = self.questionnaire('Confirm', False)
            if choice:
                self.set_max_deck_price = True
                self.deck_cost = 0.0
                print('What would you like the max price to be?')
                self.max_deck_price = float(self.questionnaire('Number', 400))
                new_line()
            else:
                self.set_max_deck_price = False
                new_line()
            
            print('Would you like to set a max price per card?\n'
                  'There will be some leeway of ~10% when choosing cards and you can choose to keep it or not.')
            choice = self.questionnaire('Confirm', False)
            if choice:
                self.set_max_card_price = True
                print('What would you like the max price to be?')
                answer = float(self.questionnaire('Number', 20))
                self.max_card_price = answer
                self.card_library['Card Price'] = pd.Series(dtype='float')
                new_line()
            else:
                self.set_max_card_price = False
                new_line()
        
        # Determine ramp
        print('How many pieces of ramp would you like to include?\n'
              'This includes mana rocks, mana dorks, and land ramp spells.\n'
              'A good baseline is 8-12 pieces, scaling up with higher average CMC\n'
              'Default: 8')
        answer = self.questionnaire('Number', 8)
        self.ideal_ramp = int(answer)
        self.free_slots -= self.ideal_ramp
        new_line()
        
        # Determine ideal land count
        print('How many total lands would you like to include?\n'
              'Before ramp is considered, 38-40 lands is typical for most decks.\n'
              "For landfall decks, consider starting at 40 lands before ramp.\n"
              'As a guideline, each mana source from ramp can reduce land count by ~1.\n'
              'Default: 35')
        answer = self.questionnaire('Number', 35)
        self.ideal_land_count = int(answer)
        self.free_slots -= self.ideal_land_count
        new_line()
        
        # Determine minimum basics to have
        print('How many basic lands would you like to have at minimum?\n'
              'This can vary widely depending on your commander, colors in color identity, and what you want to do.\n'
              'Some decks may be fine with as low as 10, others may want 25.\n'
              'Default: 20')
        answer = self.questionnaire('Number', 20)
        self.min_basics = int(answer)
        new_line()
        
        # Determine ideal creature count
        print('How many creatures would you like to include?\n'
              'Something like 25-30 would be a good starting point.\n'
              "If you're going for a kindred theme, going past 30 is likely normal.\n"
              "Also be sure to take into account token generation, but remember you'll want enough to stay safe\n"
              'Default: 25')
        answer = self.questionnaire('Number', 25)
        self.ideal_creature_count = int(answer)
        self.free_slots -= self.ideal_creature_count
        new_line()
        
        # Determine spot/targetted removal
        print('How many spot removal pieces would you like to include?\n'
              'A good starting point is about 8-12 pieces of spot removal.\n'
              'Counterspells can be considered proactive removal and protection.\n'
              'If you\'re going spellslinger, more would be a good idea as you might have less cretaures.\n'
              'Default: 10')
        answer = self.questionnaire('Number', 10)
        self.ideal_removal = int(answer)
        self.free_slots -= self.ideal_removal
        new_line()

        # Determine board wipes
        print('How many board wipes would you like to include?\n'
              'Somewhere around 2-3 is good to help eliminate threats, but also prevent the game from running long\n.'
              'This can include damaging wipes like "Blasphemous Act" or toughness reduction like "Meathook Massacre".\n'
              'Default: 2')
        answer = self.questionnaire('Number', 2)
        self.ideal_wipes = int(answer)
        self.free_slots -= self.ideal_wipes
        new_line()
        
        # Determine card advantage
        print('How many pieces of card advantage would you like to include?\n'
              '10 pieces of card advantage is good, up to 14 is better.\n'
              'Try to have a majority of it be non-conditional, and only have a couple of "Rhystic Study" style effects.\n'
              'Default: 10')
        answer = self.questionnaire('Number', 10)
        self.ideal_card_advantage = int(answer)
        self.free_slots -= self.ideal_card_advantage
        new_line()
        
        # Determine how many protection spells
        print('How many protection spells would you like to include?\n'
              'This can be individual protection, board protection, fogs, or similar effects.\n'
              'Things that grant indestructible, hexproof, phase out, or even just counterspells.\n'
              'It\'s recommended to have 5 to 15, depending on your commander and preferred strategy.\n'
              'Default: 8')
        answer = self.questionnaire('Number', 8)
        self.ideal_protection = int(answer)
        self.free_slots -= self.ideal_protection
        new_line()
        
        print(f'Free slots that aren\'t part of the ideals: {self.free_slots}')
        print('Keep in mind that many of the ideals can also cover multiple roles, but this will give a baseline POV.')
    
    def add_card(self, card: str, card_type: str, mana_cost: str, mana_value: int, is_commander: bool = False) -> None:
        """Add a card to the deck library with price checking if enabled.

        Args:
            card (str): Name of the card to add
            card_type (str): Type of the card (e.g., 'Creature', 'Instant')
            mana_cost (str): Mana cost string representation
            mana_value (int): Converted mana cost/mana value
            is_commander (bool, optional): Whether this card is the commander. Defaults to False.

        Returns:
            None

        Raises:
            ValueError: If card price exceeds maximum allowed price when price checking is enabled
        """
        multiple_copies = basic_lands + multiple_copy_cards

        # Skip if card already exists and isn't allowed multiple copies
        if card in pd.Series(self.card_library['Card Name']).values and card not in multiple_copies:
            return

        # Handle price checking
        card_price = 0.0
        if use_scrython and self.set_max_card_price:
            # Get price from cache or API
            if card in self.card_prices:
                card_price = self.card_prices[card]
            else:
                card_price = self.price_check(card)
                
            # Skip if card is too expensive
            if card_price is not None and card_price > self.max_card_price * 1.1:
                logging.info(f"Skipping {card} - price {card_price} exceeds maximum")
                return

        # Create card entry
        card_entry = [card, card_type, mana_cost, mana_value, is_commander]
        if use_scrython and self.set_max_card_price:
            card_entry.append(card_price)

        # Add to library
        self.card_library.loc[len(self.card_library)] = card_entry

        # Update deck cost if tracking
        if self.set_max_deck_price:
            self.deck_cost += card_price

        logging.debug(f"Added {card} to deck library")
    
    def organize_library(self):
        # Initialize counters dictionary dynamically from card_types including Kindred
        all_types = card_types + ['Kindred'] if 'Kindred' not in card_types else card_types
        card_counters = {card_type: 0 for card_type in all_types}

        # Count cards by type
        for card_type in card_types:
            type_df = self.card_library[self.card_library['Card Type'].apply(lambda x: card_type in x)]
            card_counters[card_type] = len(type_df)

        # Assign counts to instance variables
        self.artifact_cards = card_counters['Artifact']
        self.battle_cards = card_counters['Battle']
        self.creature_cards = card_counters['Creature']
        self.enchantment_cards = card_counters['Enchantment']
        self.instant_cards = card_counters['Instant']
        self.kindred_cards = card_counters.get('Kindred', 0)  # Use get() with default value
        self.land_cards = card_counters['Land']
        self.planeswalker_cards = card_counters['Planeswalker']
        self.sorcery_cards = card_counters['Sorcery']
    
    def sort_library(self):
        self.card_library['Sort Order'] = pd.Series(dtype='str')
        for index, row in self.card_library.iterrows():
            for card_type in card_types:
                if card_type in row['Card Type']:
                    if row['Sort Order'] == 'Creature':
                        continue
                    if row['Sort Order'] != 'Creature':
                        self.card_library.loc[index, 'Sort Order'] = card_type

        custom_order = ['Planeswalker', 'Battle', 'Creature', 'Instant', 'Sorcery', 'Artifact', 'Enchantment', 'Land']
        self.card_library['Sort Order'] = pd.Categorical(
            self.card_library['Sort Order'], 
            categories=custom_order, 
            ordered=True
        )
        self.card_library = (self.card_library
            .sort_values(by=['Sort Order', 'Card Name'], ascending=[True, True])
            .drop(columns=['Sort Order'])
            .reset_index(drop=True)
        )

    def commander_to_top(self) -> None:
        """Move commander card to the top of the library while preserving commander status."""
        try:
            commander_row = self.card_library[self.card_library['Commander']].copy()
            if commander_row.empty:
                logging.warning("No commander found in library")
                return
            
            self.card_library = self.card_library[~self.card_library['Commander']]
            
            self.card_library = pd.concat([commander_row, self.card_library], ignore_index=True)
            
            commander_name = commander_row['Card Name'].iloc[0]
            logging.info(f"Successfully moved commander '{commander_name}' to top")
        except Exception as e:
            logging.error(f"Error moving commander to top: {str(e)}")
    def concatenate_duplicates(self):
        """Handle duplicate cards in the library while maintaining data integrity."""
        duplicate_lists = basic_lands + multiple_copy_cards
        
        # Create a count column for duplicates
        self.card_library['Card Count'] = 1
        
        for duplicate in duplicate_lists:
            mask = self.card_library['Card Name'] == duplicate
            count = mask.sum()
            
            if count > 0:
                logging.info(f'Found {count} copies of {duplicate}')
                
                # Keep first occurrence with updated count
                first_idx = mask.idxmax()
                self.card_library.loc[first_idx, 'Card Count'] = count
                
                # Drop other occurrences
                self.card_library = self.card_library.drop(
                    self.card_library[mask & (self.card_library.index != first_idx)].index
                )
        
        # Update card names with counts where applicable
        mask = self.card_library['Card Count'] > 1
        self.card_library.loc[mask, 'Card Name'] = (
            self.card_library.loc[mask, 'Card Name'] + 
            ' x ' + 
            self.card_library.loc[mask, 'Card Count'].astype(str)
        )
        
        # Clean up
        self.card_library = self.card_library.drop(columns=['Card Count'])
        self.card_library = self.card_library.reset_index(drop=True)
    def drop_card(self, dataframe: pd.DataFrame, index: int) -> None:
        """Safely drop a card from the dataframe by index.
        
        Args:
            dataframe: DataFrame to modify
            index: Index to drop
        """
        try:
            dataframe.drop(index, inplace=True)
        except KeyError:
            logging.warning(f"Attempted to drop non-existent index {index}")
    def add_lands(self):
        """
        Add lands to the deck based on ideal count and deck requirements.
        
        The process follows these steps:
        1. Add basic lands distributed by color identity
        2. Add utility/staple lands
        3. Add fetch lands if requested
        4. Add theme-specific lands (e.g., Kindred)
        5. Add multi-color lands based on color count
        6. Add miscellaneous utility lands
        7. Adjust total land count to match ideal count
        """
        MAX_ADJUSTMENT_ATTEMPTS = 10
        self.total_basics = 0
        
        try:
            # Add lands in sequence
            self.add_basics()
            self.check_basics()
            self.add_standard_non_basics()
            self.add_fetches()
            
            # Add theme and color-specific lands
            if any('Kindred' in theme for theme in self.themes):
                self.add_kindred_lands()
            if len(self.colors) >= 2:
                self.add_dual_lands()
            if len(self.colors) >= 3:
                self.add_triple_lands()
            
            self.add_misc_lands()
            
            # Clean up land database
            mask = self.land_df['name'].isin(self.card_library['Card Name'])
            self.land_df = self.land_df[~mask]
            self.land_df.to_csv(f'{csv_directory}/test_lands.csv', index=False)
            
            # Adjust to ideal land count
            self.check_basics()
            logging.info('Adjusting total land count to match ideal count...')
            self.organize_library()
            
            attempts = 0
            while self.land_cards > int(self.ideal_land_count) and attempts < MAX_ADJUSTMENT_ATTEMPTS:
                logging.info(f'Current lands: {self.land_cards}, Target: {self.ideal_land_count}')
                self.remove_basic()
                self.organize_library()
                attempts += 1
            
            if attempts >= MAX_ADJUSTMENT_ATTEMPTS:
                logging.warning(f"Could not reach ideal land count after {MAX_ADJUSTMENT_ATTEMPTS} attempts")
            
            logging.info(f'Final land count: {self.land_cards}')
            
        except Exception as e:
            logging.error(f"Error during land addition: {e}")
            raise
    
    def add_basics(self):
        base_basics = self.ideal_land_count - 10  # Reserve 10 slots for non-basic lands
        basics_per_color = base_basics // len(self.colors)
        remaining_basics = base_basics % len(self.colors)

        color_to_basic = {
            'W': 'Plains',
            'U': 'Island', 
            'B': 'Swamp',
            'R': 'Mountain',
            'G': 'Forest',
            'COLORLESS': 'Wastes'
        }

        if 'Snow' in self.commander_tags:
            color_to_basic = {
            'W': 'Snow-Covered Plains',
            'U': 'Snow-Covered Island', 
            'B': 'Snow-Covered Swamp',
            'R': 'Snow-Covered Mountain',
            'G': 'Snow-Covered Forest',
            'COLORLESS': 'Snow-Covered Wastes'
            }

        print(f'Adding {base_basics} basic lands distributed across {len(self.colors)} colors')

        # Add equal distribution first
        for color in self.colors:
            basic = color_to_basic.get(color)
            if basic:
                # Add basics with explicit commander flag and track count
                for _ in range(basics_per_color):
                    self.add_card(basic, 'Basic Land', None, 0, is_commander=False)

        # Distribute remaining basics based on color requirements
        if remaining_basics > 0:
            for color in self.colors[:remaining_basics]:
                basic = color_to_basic.get(color)
                if basic:
                    self.add_card(basic, 'Basic Land', None, 0, is_commander=False)

        lands_to_remove = []
        for key in color_to_basic:
            basic = color_to_basic.get(key)
            lands_to_remove.append(basic)
        
        self.land_df = self.land_df[~self.land_df['name'].isin(lands_to_remove)]
        self.land_df.to_csv(f'{csv_directory}/test_lands.csv', index=False)

    def add_standard_non_basics(self):
        """Add staple utility lands based on deck requirements."""
        logging.info('Adding staple non-basic lands')
        
        # Define staple lands and their conditions
        staple_lands = {
            'Reliquary Tower': lambda: True,  # Always include
            'Ash Barrens': lambda: 'Landfall' not in self.commander_tags,
            'Command Tower': lambda: len(self.colors) > 1,
            'Exotic Orchard': lambda: len(self.colors) > 1,
            'War Room': lambda: len(self.colors) <= 2,
            'Rogue\'s Passage': lambda: self.commander_power >= 5
        }
        
        self.staples = []
        try:
            # Add lands that meet their conditions
            for land, condition in staple_lands.items():
                if condition():
                    if land not in self.card_library['Card Name'].values:
                        self.add_card(land, 'Land', None, 0)
                        self.staples.append(land)
                        logging.debug(f"Added staple land: {land}")
            
            # Update land database
            self.land_df = self.land_df[~self.land_df['name'].isin(self.staples)]
            self.land_df.to_csv(f'{csv_directory}/test_lands.csv', index=False)
            
            logging.info(f'Added {len(self.staples)} staple lands')
            
        except Exception as e:
            logging.error(f"Error adding staple lands: {e}")
            raise
    def add_fetches(self):
        # Determine how many fetches in total
        print('How many fetch lands would you like to include?\n'
              'For most decks you\'ll likely be good with 3 or 4, just enough to thin the deck and help ensure the color availability.\n'
              'If you\'re doing Landfall, more fetches would be recommended just to get as many Landfall triggers per turn.')
        answer = self.questionnaire('Number', 2)
        MAX_ATTEMPTS = 50  # Maximum attempts to prevent infinite loops
        attempt_count = 0
        desired_fetches = int(answer)
        chosen_fetches = []
        
        generic_fetches = [
            'Evolving Wilds', 'Terramorphic Expanse', 'Shire Terrace', 
            'Escape Tunnel', 'Promising Vein', 'Myriad Landscape', 
            'Fabled Passage', 'Terminal Moraine'
        ]
        fetches = generic_fetches.copy()
        lands_to_remove = generic_fetches.copy()
        
        # Adding in expensive fetches
        if (use_scrython and self.set_max_card_price):
            if self.price_check('Prismatic Vista') <= self.max_card_price * 1.1:
                lands_to_remove.append('Prismatic Vista')
                fetches.append('Prismatic Vista')
            else:
                lands_to_remove.append('Prismatic Vista')
                pass
        else:
            lands_to_remove.append('Prismatic Vista')
            fetches.append('Prismatic Vista')
        
        color_to_fetch = {
            'W': ['Flooded Strand', 'Windswept Heath', 'Marsh Flats', 'Arid Mesa', 'Brokers Hideout', 'Obscura Storefront', 'Cabaretti Courtyard'],
            'U': ['Flooded Strand', 'Polluted Delta', 'Scalding Tarn', 'Misty Rainforest', 'Brokers Hideout', 'Obscura Storefront', 'Maestros Theater'], 
            'B': ['Polluted Delta', 'Bloodstained Mire', 'Marsh Flats', 'Verdant Catacombs', 'Obscura Storefront', 'Maestros Theater', 'Riveteers Overlook'],
            'R': ['Bloodstained Mire', 'Wooded Foothills', 'Scalding Tarn', 'Arid Mesa', 'Maestros Theater', 'Riveteers Overlook', 'Cabaretti Courtyard'],
            'G': ['Wooded Foothills', 'Windswept Heath', 'Verdant Catacombs', 'Misty Rainforest', 'Brokers Hideout', 'Riveteers Overlook', 'Cabaretti Courtyard']
        }
        
        for color in self.colors:
            fetch = color_to_fetch.get(color)
            if fetch not in fetches:
                fetches.extend(fetch)
                if fetch not in lands_to_remove:
                    lands_to_remove.extend(fetch)
        for color in color_to_fetch:
            fetch = color_to_fetch.get(color)
            if fetch not in fetches:
                fetches.extend(fetch)
                if fetch not in lands_to_remove:
                    lands_to_remove.extend(fetch)
        
        # Randomly choose fetches up to the desired number
        while len(chosen_fetches) < desired_fetches + 3 and attempt_count < MAX_ATTEMPTS:
            if not fetches:  # If we run out of fetches to choose from
                break
                
            fetch_choice = random.choice(fetches)
            if use_scrython and self.set_max_card_price:
                if self.price_check(fetch_choice) <= self.max_card_price * 1.1:
                    chosen_fetches.append(fetch_choice)
                    fetches.remove(fetch_choice)
            else:
                chosen_fetches.append(fetch_choice)
                fetches.remove(fetch_choice)
                
            attempt_count += 1

        # Select final fetches to add
        fetches_to_add = []
        available_fetches = chosen_fetches[:desired_fetches]
        for fetch in available_fetches:
            if fetch not in fetches_to_add:
                fetches_to_add.append(fetch)

        if attempt_count >= MAX_ATTEMPTS:
            logging.warning(f"Reached maximum attempts ({MAX_ATTEMPTS}) while selecting fetch lands")

        for card in fetches_to_add:
            self.add_card(card, 'Land', None, 0)
            
        self.land_df = self.land_df[~self.land_df['name'].isin(lands_to_remove)]
        self.land_df.to_csv(f'{csv_directory}/test_lands.csv', index=False)
    
    def add_kindred_lands(self):
        """Add lands that support tribal/kindred themes."""
        logging.info('Adding Kindred-themed lands')
        
        # Standard Kindred support lands
        KINDRED_STAPLES = [
            {'name': 'Path of Ancestry', 'type': 'Land'},
            {'name': 'Three Tree City', 'type': 'Legendary Land'},
            {'name': 'Cavern of Souls', 'type': 'Land'}
        ]
        
        kindred_lands = KINDRED_STAPLES.copy()
        lands_to_remove = set()
        
        try:
            # Process each Kindred theme
            for theme in self.themes:
                if 'Kindred' in theme:
                    creature_type = theme.replace(' Kindred', '')
                    logging.info(f'Searching for {creature_type}-specific lands')
                    
                    # Filter lands by creature type
                    type_specific = self.land_df[
                        self.land_df['text'].notna() & 
                        (self.land_df['text'].str.contains(creature_type, case=False) |
                         self.land_df['type'].str.contains(creature_type, case=False))
                    ]
                    
                    # Add matching lands to pool
                    for _, row in type_specific.iterrows():
                        kindred_lands.append({
                            'name': row['name'],
                            'type': row['type'],
                            'manaCost': row['manaCost'],
                            'manaValue': row['manaValue']
                        })
                        lands_to_remove.add(row['name'])
            
            # Add lands to deck
            for card in kindred_lands:
                if card['name'] not in self.card_library['Card Name'].values:
                    self.add_card(card['name'], card['type'], 
                                None, 0)
                    lands_to_remove.add(card['name'])
            
            # Update land database
            self.land_df = self.land_df[~self.land_df['name'].isin(lands_to_remove)]
            self.land_df.to_csv(f'{csv_directory}/test_lands.csv', index=False)
            
            logging.info(f'Added {len(lands_to_remove)} Kindred-themed lands')
            
        except Exception as e:
            logging.error(f"Error adding Kindred lands: {e}")
            raise
    def add_dual_lands(self):
        # Determine dual-color lands available 
        
        # Determine if using the dual-type lands
        print('Would you like to include Dual-type lands (i.e. lands that count as both a Plains and a Swamp for example)?')
        choice = self.questionnaire('Confirm', True)
        color_filter = []
        color_dict = {
            'azorius': 'Plains Island',
            'dimir': 'Island Swamp',
            'rakdos': 'Swamp Mountain',
            'gruul': 'Mountain Forest',
            'selesnya': 'Forest Plains',
            'orzhov': 'Plains Swamp',
            'golgari': 'Swamp Forest',
            'simic': 'Forest Island',
            'izzet': 'Island Mountain',
            'boros': 'Mountain Plains'
        }
        
        if choice:
            for key in color_dict:
                if key in self.files_to_load:
                    color_filter.extend([f'Land — {color_dict[key]}', f'Snow Land — {color_dict[key]}'])
            
            dual_df = self.land_df[self.land_df['type'].isin(color_filter)].copy()
            
            # Convert to list of card dictionaries
            card_pool = []
            for _, row in dual_df.iterrows():
                card = {
                    'name': row['name'],
                    'type': row['type'],
                    'manaCost': row['manaCost'],
                    'manaValue': row['manaValue']
                }
                card_pool.append(card)
            
            lands_to_remove = []
            for card in card_pool:
                self.add_card(card['name'], card['type'], 
                            card['manaCost'], card['manaValue'])
                lands_to_remove.append(card['name'])

            self.land_df = self.land_df[~self.land_df['name'].isin(lands_to_remove)]
            self.land_df.to_csv(f'{csv_directory}/test_lands.csv', index=False)
            
            logging.info(f'Added {len(card_pool)} Dual-type land cards.')
            
        if not choice:
            logging.info('Skipping adding Dual-type land cards.')
    
    def add_triple_lands(self):
        # Determine if using Triome lands
        print('Would you like to include triome lands (i.e. lands that count as a Mountain, Forest, and Plains for example)?')
        choice = self.questionnaire('Confirm', True)
        
        color_filter = []
        color_dict = {
            'bant': 'Forest Plains Island',
            'esper': 'Plains Island Swamp',
            'grixis': 'Island Swamp Mountain',
            'jund': 'Swamp Mountain Forest',
            'naya': 'Mountain Forest Plains',
            'mardu': 'Mountain Plains Swamp',
            'abzan': 'Plains Swamp Forest',
            'sultai': 'Swamp Forest Island',
            'temur': 'Forest Island Mountain',
            'jeska': 'Island Mountain Plains'
        }
        
        if choice:
            for key in color_dict:
                if key in self.files_to_load:
                    color_filter.extend([f'Land — {color_dict[key]}'])
            
            triome_df = self.land_df[self.land_df['type'].isin(color_filter)].copy()
        
            # Convert to list of card dictionaries
            card_pool = []
            for _, row in triome_df.iterrows():
                card = {
                    'name': row['name'],
                    'type': row['type'],
                    'manaCost': row['manaCost'],
                    'manaValue': row['manaValue']
                }
                card_pool.append(card)
            
            lands_to_remove = []
            for card in card_pool:
                self.add_card(card['name'], card['type'], 
                            card['manaCost'], card['manaValue'])
                lands_to_remove.append(card['name'])

            self.land_df = self.land_df[~self.land_df['name'].isin(lands_to_remove)]
            self.land_df.to_csv(f'{csv_directory}/test_lands.csv', index=False)
            
            logging.info(f'Added {len(card_pool)} Triome land cards.')
            
        if not choice:
            logging.info('Skipping adding Triome land cards.')
    
    def add_misc_lands(self):
        """Add additional utility lands that fit the deck's color identity."""
        logging.info('Adding miscellaneous utility lands')
        
        MIN_MISC_LANDS = 5
        MAX_MISC_LANDS = 15
        MAX_POOL_SIZE = 100
        
        try:
            # Create filtered pool of candidate lands
            land_pool = (self.land_df
                        .head(MAX_POOL_SIZE)
                        .copy()
                        .reset_index(drop=True))
            
            # Convert to card dictionaries
            card_pool = [
                {
                    'name': row['name'],
                    'type': row['type'],
                    'manaCost': row['manaCost'],
                    'manaValue': row['manaValue']
                }
                for _, row in land_pool.iterrows()
                if row['name'] not in self.card_library['Card Name'].values
            ]
            
            if not card_pool:
                logging.warning("No eligible misc lands found")
                return
            
            # Randomly select lands within constraints
            target_count = random.randint(MIN_MISC_LANDS, MAX_MISC_LANDS)
            cards_to_add = []
            
            while card_pool and len(cards_to_add) < target_count:
                card = random.choice(card_pool)
                card_pool.remove(card)
                
                # Check price if enabled
                if use_scrython and self.set_max_card_price:
                    price = self.price_check(card['name'])
                    if price > self.max_card_price * 1.1:
                        continue
                
                cards_to_add.append(card)
            
            # Add selected lands
            lands_to_remove = set()
            for card in cards_to_add:
                self.add_card(card['name'], card['type'],
                            card['manaCost'], card['manaValue'])
                lands_to_remove.add(card['name'])
            
            # Update land database
            self.land_df = self.land_df[~self.land_df['name'].isin(lands_to_remove)]
            self.land_df.to_csv(f'{csv_directory}/test_lands.csv', index=False)
            
            logging.info(f'Added {len(cards_to_add)} miscellaneous lands')
            
        except Exception as e:
            logging.error(f"Error adding misc lands: {e}")
            raise
    def check_basics(self):
        """Check and display counts of each basic land type."""
        basic_lands = {
            'Plains': 0,
            'Island': 0, 
            'Swamp': 0,
            'Mountain': 0,
            'Forest': 0,
            'Snow-Covered Plains': 0,
            'Snow-Covered Island': 0,
            'Snow-Covered Swamp': 0,
            'Snow-Covered Mountain': 0,
            'Snow-Covered Forest': 0
        }
        
        self.total_basics = 0
        for land in basic_lands:
            count = len(self.card_library[self.card_library['Card Name'] == land])
            basic_lands[land] = count
            self.total_basics += count
        
        logging.info("\nBasic Land Counts:")
        for land, count in basic_lands.items():
            if count > 0:
                logging.info(f"{land}: {count}")
        logging.info(f"Total basic lands: {self.total_basics}\n")
   
    def remove_basic(self, max_attempts: int = 3):
        """
        Remove a basic land while maintaining color balance.
        Attempts to remove from colors with more basics first.
        
        Args:
            max_attempts: Maximum number of removal attempts before falling back to non-basics
        """
        logging.info('Land count over ideal count, removing a basic land.')
        
        color_to_basic = {
            'W': 'Plains', 'U': 'Island', 'B': 'Swamp',
            'R': 'Mountain', 'G': 'Forest'
        }
        
        # Get current basic land counts using vectorized operations
        basic_counts = {
            basic: len(self.card_library[self.card_library['Card Name'] == basic])
            for color, basic in color_to_basic.items()
            if color in self.colors
        }
        
        sum_basics = sum(basic_counts.values())
        attempts = 0
        
        while attempts < max_attempts and sum_basics > self.min_basics:
            if not basic_counts:
                logging.warning("No basic lands found to remove")
                break
                
            basic_land = max(basic_counts.items(), key=lambda x: x[1])[0]
            try:
                # Use boolean indexing for efficiency
                mask = self.card_library['Card Name'] == basic_land
                if not mask.any():
                    basic_counts.pop(basic_land)
                    continue
                    
                index_to_drop = self.card_library[mask].index[0]
                self.card_library = self.card_library.drop(index_to_drop).reset_index(drop=True)
                logging.info(f'{basic_land} removed successfully')
                return
                
            except (IndexError, KeyError) as e:
                logging.error(f"Error removing {basic_land}: {e}")
                basic_counts.pop(basic_land)
            
            attempts += 1
            
        # If we couldn't remove a basic land, try removing a non-basic
        logging.warning("Could not remove basic land, attempting to remove non-basic")
        self.remove_land()
    
    def remove_land(self):
        """Remove a random non-basic, non-staple land from the deck."""
        logging.info('Removing a random nonbasic land.')

        # Define basic lands including snow-covered variants
        basic_lands = [
            'Plains', 'Island', 'Swamp', 'Mountain', 'Forest',
            'Snow-Covered Plains', 'Snow-Covered Island', 'Snow-Covered Swamp',
            'Snow-Covered Mountain', 'Snow-Covered Forest'
        ]

        try:
            # Filter for non-basic, non-staple lands
            library_filter = self.card_library[
                (self.card_library['Card Type'].str.contains('Land')) & 
                (~self.card_library['Card Name'].isin(basic_lands + self.staples))
            ].copy()

            if len(library_filter) == 0:
                logging.warning("No suitable non-basic lands found to remove.")
                return

            # Select random land to remove
            card_index = np.random.choice(library_filter.index)
            card_name = self.card_library.loc[card_index, 'Card Name']

            logging.info(f"Removing {card_name}")
            self.card_library.drop(card_index, inplace=True)
            self.card_library.reset_index(drop=True, inplace=True)
            logging.info("Card removed successfully.")

        except Exception as e:
            logging.error(f"Error removing land: {e}")
            logging.warning("Failed to remove land card.")
    
    def count_pips(self):
        """Count and display the number of colored mana symbols in casting costs using vectorized operations."""
        logging.info('Analyzing color pip distribution...')
        
        # Define colors to check
        colors = ['W', 'U', 'B', 'R', 'G']
        
        # Use vectorized string operations
        mana_costs = self.card_library['Mana Cost'].dropna()
        pip_counts = {color: mana_costs.str.count(color).sum() for color in colors}
        
        total_pips = sum(pip_counts.values())
        if total_pips == 0:
            logging.error("No colored mana symbols found in casting costs.")
            return
        
        logging.info("\nColor Pip Distribution:")
        for color, count in pip_counts.items():
            if count > 0:
                percentage = (count / total_pips) * 100
                print(f"{color}: {count} pips ({percentage:.1f}%)")
        logging.info(f"Total colored pips: {total_pips}\n")
        
    def get_cmc(self):
        """Calculate average converted mana cost of non-land cards."""
        logging.info('Calculating average mana value of non-land cards.')
        
        try:
            # Filter non-land cards
            non_land = self.card_library[
                ~self.card_library['Card Type'].str.contains('Land')
            ].copy()
            
            if non_land.empty:
                logging.warning("No non-land cards found")
                self.cmc = 0.0
            else:
                total_cmc = non_land['Mana Value'].sum()
                self.cmc = round(total_cmc / len(non_land), 2)
            
            self.commander_dict.update({'CMC': float(self.cmc)})
            logging.info(f"Average CMC: {self.cmc}")
            
        except Exception as e:
            logging.error(f"Error calculating CMC: {e}")
            self.cmc = 0.0
    
    def weight_by_theme(self, tag, ideal=1, weight=1, df=None):
        # First grab the first 50/30/20 cards that match each theme
        """Add cards with specific tag up to ideal_value count"""
        ideal_value = math.ceil(ideal * weight * 0.9)
        print(f'Finding {ideal_value} cards with the "{tag}" tag...')
        if 'Kindred' in tag:
            tags = [tag, 'Kindred Support']
        else:
            tags = [tag]
        # Filter cards with the given tag
        tag_df = df.copy()
        tag_df.sort_values(by='edhrecRank', inplace=True)
        tag_df = tag_df[tag_df['themeTags'].apply(lambda x: any(tag in x for tag in tags))]
        # Take top cards based on ideal value
        pool_size = int(ideal_value * random.randint(15, 20) /10)
        tag_df = tag_df.head(pool_size)
        
        # Convert to list of card dictionaries
        card_pool = [
            {
                'name': row['name'],
                'type': row['type'],
                'manaCost': row['manaCost'],
                'manaValue': row['manaValue']
            }
            for _, row in tag_df.iterrows()
        ]

        # Randomly select cards up to ideal value
        cards_to_add = []
        while len(cards_to_add) < ideal_value and card_pool:
            card = random.choice(card_pool)
            card_pool.remove(card)
            
            # Check price constraints if enabled
            if use_scrython and self.set_max_card_price:
                price = self.price_check(card['name'])
                if price > self.max_card_price * 1.1:
                    continue
                    
            # Add card if not already in library
            
            if card['name'] in multiple_copy_cards:
                if card['name'] == 'Nazgûl':
                    for _ in range(9):
                        cards_to_add.append(card)
                elif card['name'] == 'Seven Dwarves':
                    for _ in range(7):
                        cards_to_add.append(card)
                else:
                    num_to_add = ideal_value - len(cards_to_add)
                    for _ in range(num_to_add):
                        cards_to_add.append(card)
            
            elif (card['name'] not in multiple_copy_cards
                  and card['name'] not in self.card_library['Card Name'].values):
                cards_to_add.append(card)
                
            elif (card['name'] not in multiple_copy_cards
                  and card['name'] in self.card_library['Card Name'].values):
                logging.warning(f"{card['name']} already in Library, skipping it.")
                continue
        
        # Add selected cards to library
        for card in cards_to_add:
            self.add_card(card['name'], card['type'], 
                         card['manaCost'], card['manaValue'])
        
        card_pool_names = [item['name'] for item in card_pool]
        self.full_df = self.full_df[~self.full_df['name'].isin(card_pool_names)]
        self.noncreature_df = self.noncreature_df[~self.noncreature_df['name'].isin(card_pool_names)]
        logging.info(f'Added {len(cards_to_add)} {tag} cards')
        #tag_df.to_csv(f'{csv_directory}/test_{tag}.csv', index=False)
    
    def add_by_tags(self, tag, ideal_value=1, df=None):
        """Add cards with specific tag up to ideal_value count"""
        print(f'Finding {ideal_value} cards with the "{tag}" tag...')

        # Filter cards with the given tag
        skip_creatures = self.creature_cards > self.ideal_creature_count * 1.1
        tag_df = df.copy()
        tag_df.sort_values(by='edhrecRank', inplace=True)
        tag_df = tag_df[tag_df['themeTags'].apply(lambda x: tag in x)]
        # Take top cards based on ideal value
        pool_size = int(ideal_value * random.randint(2, 3))
        tag_df = tag_df.head(pool_size)

        # Convert to list of card dictionaries
        card_pool = [
            {
                'name': row['name'],
                'type': row['type'],
                'manaCost': row['manaCost'],
                'manaValue': row['manaValue']
            }
            for _, row in tag_df.iterrows()
        ]

        # Randomly select cards up to ideal value
        cards_to_add = []
        while len(cards_to_add) < ideal_value and card_pool:
            card = random.choice(card_pool)
            card_pool.remove(card)

            # Check price constraints if enabled
            if use_scrython and self.set_max_card_price:
                price = self.price_check(card['name'])
                if price > self.max_card_price * 1.1:
                    continue

            # Add card if not already in library
            if card['name'] not in self.card_library['Card Name'].values:
                if 'Creature' in card['type'] and skip_creatures:
                    continue
                else:
                    if 'Creature' in card['type']:
                        self.creature_cards += 1
                        skip_creatures = self.creature_cards > self.ideal_creature_count * 1.1
                    cards_to_add.append(card)

        # Add selected cards to library
        for card in cards_to_add:
            if len(self.card_library) < 100:
                self.add_card(card['name'], card['type'], 
                            card['manaCost'], card['manaValue'])
            else:
                continue

        card_pool_names = [item['name'] for item in card_pool]
        self.full_df = self.full_df[~self.full_df['name'].isin(card_pool_names)]
        self.noncreature_df = self.noncreature_df[~self.noncreature_df['name'].isin(card_pool_names)]
        logging.info(f'Added {len(cards_to_add)} {tag} cards')
        #tag_df.to_csv(f'{csv_directory}/test_{tag}.csv', index=False)
        
    def add_creatures(self):
        """
        Add creatures to the deck based on themes and weights.
        
        This method processes the primary, secondary, and tertiary themes to add
        creatures proportionally according to their weights. The total number of
        creatures added will approximate the ideal_creature_count.
        
        Themes are processed in order of importance (primary -> secondary -> tertiary)
        with error handling to ensure the deck building process continues even if
        a particular theme encounters issues.
        """
        print(f'Adding creatures to deck based on the ideal creature count of {self.ideal_creature_count}...')
        
        try:
            if self.hidden_theme:
                print(f'Processing Hidden theme: {self.hidden_theme}')
                self.weight_by_theme(self.hidden_theme, self.ideal_creature_count, self.hidden_weight, self.creature_df)
            
            print(f'Processing primary theme: {self.primary_theme}')
            self.weight_by_theme(self.primary_theme, self.ideal_creature_count, self.primary_weight, self.creature_df)
            
            if self.secondary_theme:
                print(f'Processing secondary theme: {self.secondary_theme}')
                self.weight_by_theme(self.secondary_theme, self.ideal_creature_count, self.secondary_weight, self.creature_df)
            
            if self.tertiary_theme:
                print(f'Processing tertiary theme: {self.tertiary_theme}')
                self.weight_by_theme(self.tertiary_theme, self.ideal_creature_count, self.tertiary_weight, self.creature_df)
                
        except Exception as e:
            logging.error(f"Error while adding creatures: {e}")
        finally:
            self.organize_library()
            logging.info(f'Creature addition complete. Total creatures (including commander): {self.creature_cards}')
    
    def add_ramp(self):
        try:
            self.add_by_tags('Mana Rock', math.ceil(self.ideal_ramp / 3), self.noncreature_df)
            self.add_by_tags('Mana Dork', math.ceil(self.ideal_ramp / 4), self.creature_df)
            self.add_by_tags('Ramp', math.ceil(self.ideal_ramp / 2), self.noncreature_df)
        except Exception as e:
            logging.error(f"Error while adding Ramp: {e}")
        finally:
            logging.info('Adding Ramp complete.')
    
    def add_interaction(self):
        try:
            self.add_by_tags('Removal', self.ideal_removal, self.noncreature_nonplaneswaker_df)
            self.add_by_tags('Protection', self.ideal_protection, self.noncreature_nonplaneswaker_df)
        except Exception as e:
            logging.error(f"Error while adding Interaction: {e}")
        finally:
            logging.info('Adding Interaction complete.')
        
    def add_board_wipes(self):
        try:
            self.add_by_tags('Board Wipes', self.ideal_wipes, self.full_df)
        except Exception as e:
            logging.error(f"Error while adding Board Wipes: {e}")
        finally:
            logging.info('Adding Board Wipes complete.')
        
    def add_card_advantage(self):
        try:
            self.add_by_tags('Conditional Draw', math.ceil(self.ideal_card_advantage * 0.2), self.full_df)
            self.add_by_tags('Unconditional Draw', math.ceil(self.ideal_card_advantage * 0.8), self.noncreature_nonplaneswaker_df)
        except Exception as e:
            logging.error(f"Error while adding Card Draw: {e}")
        finally:
            logging.info('Adding Card Draw complete.')
    
    def fill_out_deck(self):
        """Fill out the deck to 100 cards with theme-appropriate cards."""
        logging.info('Filling out the Library to 100 with cards fitting the themes.')
        
        cards_needed = 100 - len(self.card_library)
        if cards_needed <= 0:
            return
        
        logging.info(f"Need to add {cards_needed} more cards")
        
        # Define maximum attempts and timeout
        MAX_ATTEMPTS = max(20, cards_needed * 2)
        MAX_TIME = 60  # Maximum time in seconds
        start_time = time.time()
        attempts = 0
        
        while len(self.card_library) < 100 and attempts < MAX_ATTEMPTS:
            # Check timeout
            if time.time() - start_time > MAX_TIME:
                logging.error("Timeout reached while filling deck")
                break
                
            initial_count = len(self.card_library)
            remaining = 100 - len(self.card_library)
            
            # Adjust weights based on remaining cards needed
            weight_multiplier = remaining / cards_needed
            
            try:
                # Add cards from each theme with adjusted weights
                if self.tertiary_theme:
                    self.add_by_tags(self.tertiary_theme, 
                        math.ceil(self.tertiary_weight * 10 * weight_multiplier),
                        self.noncreature_df)
                if self.secondary_theme:
                    self.add_by_tags(self.secondary_theme, 
                        math.ceil(self.secondary_weight * 3 * weight_multiplier),
                        self.noncreature_df)
                self.add_by_tags(self.primary_theme, 
                    math.ceil(self.primary_weight * 2 * weight_multiplier),
                    self.noncreature_df)
                
                # Check if we made progress
                if len(self.card_library) == initial_count:
                    attempts += 1
                    if attempts % 5 == 0:
                        logging.warning(f"Made {attempts} attempts, still need {100 - len(self.card_library)} cards")
                        
                # Break early if we're stuck
                if attempts >= MAX_ATTEMPTS / 2 and len(self.card_library) < initial_count + (cards_needed / 4):
                    logging.warning("Insufficient progress being made, breaking early")
                    break
                    
            except Exception as e:
                logging.error(f"Error while adding cards: {e}")
                attempts += 1
        
        final_count = len(self.card_library)
        if final_count < 100:
            message = f"\nWARNING: Deck is incomplete with {final_count} cards. Manual additions may be needed."
            logging.warning(message)
        else:
            logging.info(f"Successfully filled deck to {final_count} cards in {attempts} attempts")
def main():
    """Main entry point for deck builder application."""
    build_deck = DeckBuilder()
    build_deck.determine_commander()
    pprint.pprint(build_deck.commander_dict, sort_dicts=False)

if __name__ == '__main__':
    main()