%%html
<style>
table.dataframe {
    font-size: 10px;               /* Adjust font size as necessary */
    overflow-x: auto;              /* Adds horizontal scroll to the table */
    width: auto;                   /* Adjust width settings */
    max-width: 100%;               /* Ensures the table does not exceed cell width */
    display: block;
}


/* Container width settings for responsiveness */
@media only screen and (max-width: 768px) {
    .container {
        width: 100% !important;
    }
}
@media only screen and (min-width: 769px) {
    .container {
        width: 80% !important;
    }
}

.container {
    max-width: 1920px !important;
    margin: auto !important;  /* This centers the container */
}

/* Ensuring images are responsive and do not exceed the container's width */
img {
    max-width: 100%;
    height: auto;
}

</style>

%load_ext pretty_jupyter

from plotly.offline import plot
import pandas as pd
from IPython.display import display, HTML
import plotly.express as px
import plotly.graph_objects as go
import plotly.io
import matplotlib.pyplot as plt
from pretty_jupyter.helpers import matplotlib_fig_to_html
import warnings
warnings.filterwarnings('ignore', category=FutureWarning)

# Data Exploration and Machine Learning Libraries:
import pandas as pd
import numpy as np
import ast 
import re
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.preprocessing import LabelEncoder
from collections import Counter
import colorsys
from keras.models import Sequential
from keras.layers import Dense, Input

# Visualization Libraries
import matplotlib.pyplot as plt
import seaborn as sns
import networkx as nx
from networkx.drawing.nx_agraph import graphviz_layout
import matplotlib.lines as mlines
from matplotlib.patches import Rectangle

# Defining the color scheme

# Reds color palette
red_palette = ['#001514', '#1B1110', '#290F0E', '#360D0C', '#440B0A', '#4B0A09', '#510908', '#5E0706', '#650605', '#6B0504']
sns.set_palette(sns.color_palette(red_palette))

# Green color palette
green_palette = ['#031911', '#042117', '#05291C', '#063122', '#073928', '#09422D', '#0A4A33', '#0B5239', '#0C5A3E', '#0D6244']
sns.set_palette(sns.color_palette(green_palette))

# General color palette
general_palette = ['#092217', '#1B1110', '#063122', '#360D0C', '#001514', '#09422D', '#2D483D', '#510908', '#650605']
sns.set_palette(sns.color_palette(general_palette))

# Smaller color palette
small_palette = ['#28251D', '#1B1110', '#001514', '#2D483D', '#510908']
sns.set_palette(sns.color_palette(small_palette))

# Blacks vs. Green palette
allegiance_palette = ['#28251D', '#092818']

# Set the maximum width of each column
pd.set_option('display.max_colwidth', 30) 

# Load the dataset
dragon_data = pd.read_csv('dragon_data.csv')

dragon_data.head(5)

dragon_data.info()

missing_values = dragon_data.isnull().sum()
missing_values

# Handling Missing Values
dragon_data['FirstRider'].fillna('Unknown', inplace=True)
dragon_data['Riders'].fillna('Unknown', inplace=True)
dragon_data['NotableEvents'].fillna('Unknown', inplace=True)
dragon_data['LastRider'].fillna('Unknown', inplace=True)
dragon_data['DanceAllegiance'].fillna('Unknown', inplace=True)
dragon_data['SurvivedTheDance'].fillna('Unknown', inplace=True)
dragon_data['BattlesDuringTheDance'].fillna('Unknown', inplace=True)
dragon_data['Outcome'].fillna('Unknown', inplace=True)
dragon_data['SurvivedTheBattle'].fillna('Unknown', inplace=True)
dragon_data['KilledBy'].fillna('Unknown', inplace=True)
dragon_data['DeathDate'].fillna('Unknown', inplace=True)

# Focus on relevant columns
relevant_columns = ['Name', 'HatchedFrom', 'Gender', 'BirthDate', 'DeathDate', 'Size', 'ScaleColor', 'WingMembraneColor', 'EyeColor', 'PersonalityTraits', 'FoughtInTheDance', 'DanceAllegiance', 'SurvivedTheDance', 'BattlesDuringTheDance', 'Outcome', 'SurvivedTheBattle', 'KilledBy']
cleaned_dragon_data = dragon_data[relevant_columns]
cleaned_dragon_data.to_csv('cleaned_dragon_data.csv', index=False)

# Saving cleaned data
dragon_data = pd.read_csv('cleaned_dragon_data.csv')

# Extract unique values for 'ScaleColor', 'WingMembraneColor', and 'EyeColor'
scale_colors = dragon_data['ScaleColor'].unique()
wing_colors = dragon_data['WingMembraneColor'].unique()
eye_colors = dragon_data['EyeColor'].unique()

# Data conversion to lists
dragon_data['PersonalityTraits'] = dragon_data['PersonalityTraits'].apply(lambda x: x.strip("[]").replace("'", "").split(', ') if isinstance(x, str) else [])

# Flatten the list of lists to extract unique values properly
flattened_traits = [trait for sublist in dragon_data['PersonalityTraits'] for trait in sublist]

# Sorting unique values
traits_list = sorted(set(flattened_traits))
scale_colors_list = sorted(scale_colors)
wing_colors_list = sorted(wing_colors)
eye_colors_list = sorted(eye_colors)

# Define scale colors
defined_scale_colors = {
  'Black': 'Black',
  'Bronze': 'Bronze',
  'Brown': 'Bronze',
  'Charcoal': 'Black',
  'Dark Cobalt Blue': 'Blue',
  'Dark Grey': 'Black',
  'Dark Grey-Blue': 'Blue',
  'Gold': 'Gold',
  'Jade Green': 'Green',
  'Olive Green': 'Green',
  'Pale Blue': 'Blue',
  'Pale Green': 'Green',
  'Pale Grey-White': 'White',
  'Pale Pink': 'Pink',
  'Pale Silver-White': 'White',
  'Pale Silver-Grey': 'Silver',
  'Pale White': 'White',
  'Pearl-White': 'White',
  'Red': 'Red',
  'Scarlet Red': 'Red',
  'Silver': 'Silver',
  'Yellow': 'Yellow',
}

defined_wing_colors = {    
  'Black': 'Black',
  'Brown': 'Bronze',
  'Copper': 'Copper',
  'Dark Grey': 'Grey', 
  'Gold': 'Gold', 
  'Green-Blue': 'Green',
  'Pale Grey': 'Grey',
  'Pale Grey-White': 'White',
  'Pale Orange': 'Yellow', 
  'Pale Pink': 'Pink',
  'Pearl-White': 'White',
  'Red': 'Red', 
  'Silver': 'Silver', 
  'Tan': 'Bronze',
  'White': 'White',
  'Yellow': 'Yellow'
}

defined_eye_colors = {
  'Bright Blue': 'Blue',
  'Bright Green': 'Green',
  'Copper': 'Bronze',
  'Dark Green': 'Green',
  'Gold': 'Gold',
  'Green': 'Green',
  'Pale Blue': 'Blue',
  'Pale Green': 'Green',
  'Red': 'Red',
  'Yellow': 'Yellow'
}

defined_traits = {    
    ' Aggressive': 'Aggressive',
    'Ferocious': 'Aggressive',
    'Fierce': 'Aggressive',
    'Vicious': 'Aggressive',
    'Gentle': 'Friendly',
    'Powerful': 'Formidable',
    'Strong': 'Formidable',
    'beautiful': 'Beautiful',
    'Brave': 'Willful',
    'Agile': 'Swift',
    'Protective': 'Loyal',
    'formidable': 'Formidable',
}

# Function to map colors and traits
def standardize_scale_color(color):
    return defined_scale_colors.get(color, color)
def standardize_wing_color(color):
    return defined_wing_colors.get(color, color)
def standardize_eye_color(color):
    return defined_eye_colors.get(color, color)
def standardize_traits(traits):
    return [defined_traits.get(trait.strip(), trait.strip()) for trait in traits]

# Function to remove duplicates
def remove_duplicates(traits):
    return list(set(traits))

# Create new columns for standardized colors
dragon_data['StandardizedScaleColor'] = dragon_data['ScaleColor'].apply(standardize_scale_color)
dragon_data['StandardizedWingColor'] = dragon_data['WingMembraneColor'].apply(standardize_wing_color)
dragon_data['StandardizedEyeColor'] = dragon_data['EyeColor'].apply(standardize_eye_color)

# Apply the function to each list in the 'PersonalityTraits' column
dragon_data['StandardizedPersonalityTraits'] = dragon_data['PersonalityTraits'].apply(standardize_traits)

# Remove duplicates in the 'StandardizedPersonalityTraits' column and clean up any characters
dragon_data['StandardizedPersonalityTraits'] = dragon_data['StandardizedPersonalityTraits'].apply(remove_duplicates)
dragon_data['StandardizedPersonalityTraits'] = dragon_data['StandardizedPersonalityTraits'].apply(lambda traits: [trait.strip("[]").replace("'", "") for trait in traits] if isinstance(traits, list) else [])

# Extract unique values for 'ScaleColor', 'WingMembraneColor', and 'EyeColor'
standardizedscale_colors = dragon_data['StandardizedScaleColor'].unique()
standardizedwing_colors = dragon_data['StandardizedWingColor'].unique()
standardizedeye_colors = dragon_data['StandardizedEyeColor'].unique()

# Flatten the list of lists to extract unique values properly
standardizedflattened_traits = [trait for sublist in dragon_data['StandardizedPersonalityTraits'] for trait in sublist]

# Sorting unique values
standardizedtraits_list = sorted(set(standardizedflattened_traits))
standardizedscale_colors_list = sorted(standardizedscale_colors)
standardizedwing_colors_list = sorted(standardizedwing_colors)
standardizedeye_colors_list = sorted(eye_colors)

dragon_data.to_csv('final_cleaned_dragon_data.csv', index = False)

def list_to_string(list_items):
    """Convert list to a comma-separated string."""
    return ', '.join(map(str, list_items))

# Converting the original lists of unique values to comma-separated strings
original_traits_str = list_to_string(traits_list)
original_scale_colors_str = list_to_string(scale_colors_list)
original_wing_colors_str = list_to_string(wing_colors_list)
original_eye_colors_str = list_to_string(eye_colors_list)

# Converting the standardized lists to comma-separated strings
standardized_traits_str = list_to_string(standardizedtraits_list)
standardized_scale_colors_str = list_to_string(standardizedscale_colors_list)
standardized_wing_colors_str = list_to_string(standardizedwing_colors_list)
standardized_eye_colors_str = list_to_string(standardizedeye_colors_list)

# Define the function to convert dates to numeric values
def convert_to_numeric_date(date_str):
    if pd.isna(date_str):
        return None
    if 'BC' in date_str:
        return -int(re.findall(r'\d+', date_str)[0])
    elif 'AC' in date_str:
        return int(re.findall(r'\d+', date_str)[0])
    return None

# Convert BirthDate and DeathDate to numeric values
dragon_data['BirthDate_numeric'] = dragon_data['BirthDate'].apply(convert_to_numeric_date)
dragon_data['DeathDate_numeric'] = dragon_data['DeathDate'].apply(convert_to_numeric_date)

# Filter only female dragons
female_dragons = dragon_data[dragon_data['Gender'] == 'Female']

# Define function 
def find_potential_mothers_corrected(dragon_name, birth_date, female_dragons):
    potential_mothers = []
    for _, row in female_dragons.iterrows():
        if row['Name'] != dragon_name and row['BirthDate_numeric'] < birth_date < row['DeathDate_numeric']:
            potential_mothers.append(row['Name'])
    return potential_mothers

#Apply the function to each dragon
dragon_data['PotentialMothers'] = dragon_data.apply(lambda row: find_potential_mothers_corrected(row['Name'], row['BirthDate_numeric'], female_dragons), axis=1)

potential_mothers = dragon_data[['Name', 'PotentialMothers']]

def format_potential_mothers_vertical(df):
    markdown_output = ""
    for _, row in df.iterrows():
        # Check if the list is non-empty and does not contain 'None'
        if row['PotentialMothers'] and 'None' not in row['PotentialMothers']:
            mothers_list = ', '.join(row['PotentialMothers'])
            markdown_output += f"**{row['Name']}**: {mothers_list}\n\n"
        else:
            continue  # Skip adding to markdown_output if mothers are 'None'
    return markdown_output

# Apply the function to the dataframe
potential_mothers_markdown = format_potential_mothers_vertical(potential_mothers)

dragon_data['BirthDate_numeric'] = dragon_data['BirthDate'].apply(convert_to_numeric_date)
dragon_data['DeathDate_numeric'] = dragon_data['DeathDate'].apply(convert_to_numeric_date)

# Plotting the timelines
plt.figure(figsize=(15, 6))
for index, row in dragon_data.iterrows():
    plt.plot([row['BirthDate_numeric'], row['DeathDate_numeric']], [index, index], marker='o')

# Adding labels
plt.yticks(range(len(dragon_data)), dragon_data['Name'])
plt.xlabel('Year')
plt.ylabel('Dragon')
plt.title('Timeline of Dragon Lifespans')
plt.grid(True)
plt.show()

# Update the 'HatchedFrom' column for Dreamfyre and Silverwing
dragon_data.loc[dragon_data['Name'].isin(['Dreamfyre', 'Silverwing']), 'HatchedFrom'] = 'Quicksilver'

dragon_data.to_csv('final_cleaned_dragon_data.csv', index = False)

# Load data
dragon_data = pd.read_csv('final_cleaned_dragon_data.csv')

# Filter out 'Unknown' nodes
dragon_data = dragon_data[dragon_data['HatchedFrom'] != 'Unknown']


# Calculate the number of offspring for each parent
offspring_counts = dragon_data['HatchedFrom'].value_counts()

# Make a directed graph
G = nx.DiGraph()

# Add edges based on parent-offspring relationships in the original dataset
for _, row in dragon_data.iterrows():
    parent = row['HatchedFrom']
    offspring = row['Name']
    G.add_edge(parent, offspring)

# Define node sizes and colors based on dragon name
node_sizes = []
node_colors = []

# Define a color map for the nodes
color_data = {
    'Name': ['Arrax', 'Caraxes', 'Cannibal', 'Dreamfyre', 'Meleys', 'Moondancer', 'Morghul', 'Morning', 'Seasmoke', 'Sheepstealer', 'Shrykos', 'Silverwing', 
             'Stormcloud', 'Sunfyre', 'Syrax', 'Tessarion', 'Tyraxes', 'Vermax', 'Vermithor', 'Vhagar', 'Balerion', 'Meraxes', 'Quicksilver', 'Grey Ghost'],
    'HexCode_Scales': ['#F4EFE6', '#C50016', '#181818', '#7A95C8', '#B22A30', '#8A9C74', '#2F2F2F', '#CC9E9B', '#DADADA', '#4A3931', '#245550', '#bcc6cc', '#354669', 
                       '#E5B347', '#F5D21E', '#2F37A8', '#181818', '#929151', '#A77F5B', '#9A835A', '#181818', '#D3D4DB', '#F3ECEA', '#F2F2F2']
}

color_map = dict(zip(color_data['Name'], color_data['HexCode_Scales']))

mother_node_size = 1500
offspring_node_size = 1000

for node in G.nodes():
    if node in offspring_counts:
        node_sizes.append(mother_node_size)  # Distinct size for mothers
        node_colors.append(color_map.get(node, '#611010'))  # Use color from the map or a default color
    else:
        node_sizes.append(offspring_node_size)  # Distinct size for offspring
        node_colors.append(color_map.get(node, '#123524'))  # Use color from the map or a default color

# Use an automatic layout to get initial positions
pos = nx.spring_layout(G, seed=42)



pos['Vermax'][1] += 0.9
pos['Vermax'][0] += 1.0

pos['Morning'][1] += .9
pos['Morning'][0] += .5

pos['Sheepstealer'][1] += 1.7
pos['Sheepstealer'][0] -= .9

pos['Tessarion'][1] -= 0.4
pos['Tessarion'][0] -= 0.6

pos['Shrykos'][1] -= 1.8
pos['Shrykos'][0] -= 0.5

pos['Morghul'][0] -= 0.7

pos['Vhagar'][1] += 0.2
pos['Vhagar'][0] -= 0.2

pos['Meraxes'][1] -= 0.3

pos['Grey Ghost'][0] -= 0.3
pos['Grey Ghost'][1] -= 0.4

pos['Sunfyre'][0] += 0.3
pos['Sunfyre'][1] -= 0.1

pos['Syrax'][0] += 0.2
pos['Syrax'][1] += 0.1

pos['Stormcloud'][0] -= 0.4

pos['Tyraxes'][0] -= 0.3
pos['Tyraxes'][1] -= 0.2

pos['Meraxes'][1] -= 0.1

pos['Arrax'][1] += 0.2
pos['Arrax'][0] -= 0.2

pos['Moondancer'][0] += 0.1

pos['Seasmoke'][1] -= 0.5

pos['Dreamfyre'][0] += 0.1

# Draw the graph with initial and manually adjusted positions
plt.figure(figsize=(12, 8))

# Draw edges with specified colors
edges = G.edges(data=True)
edge_colors = ['#8f8f8f' for _ in edges]
nx.draw_networkx_edges(G, pos, alpha=0.5, edge_color=edge_colors, min_source_margin=15, min_target_margin=15)

# Draw nodes with distinct sizes and colors
nx.draw_networkx_nodes(G, pos, node_size=node_sizes, node_color=node_colors, alpha=0.8)

# Draw labels with updated font size and weight
labels = {node: node for node in G.nodes()}
nx.draw_networkx_labels(G, pos, labels=labels, font_size=10)

plt.title("Dragon Lineage - Mother and Offspring", fontsize=14)
plt.axis('off')
plt.savefig('lineage_network_graph_updated.png')
plt.show()

# Scale Colors

scale_data = pd.DataFrame({
    'Name': ['Arrax', 'Caraxes', 'Cannibal', 'Dreamfyre', 'Meleys', 'Moondancer', 'Morghul', 'Morning', 'Seasmoke', 'Sheepstealer', 'Shrykos', 'Silverwing', 
             'Stormcloud', 'Sunfyre', 'Syrax', 'Tessarion', 'Tyraxes', 'Vermax', 'Vermithor', 'Vhagar', 'Balerion', 'Meraxes', 'Quicksilver', 'Grey Ghost'],
    'HexCode_Scales': ['#F4EFE6', '#632322', '#181818', '#7AA2D0', '#8E1000', '#75968F', '#616269', '#B98293', '#DADADA', '#46322A', '#245550', '#bcc6cc', '#354669', 
              '#F1BD59', '#E4BD57', '#2F37A8', '#181818', '#929151', '#814C32', '#9A835A', '#181818', '#D3D4DB', '#F3ECEA', '#F2F2F2'],
})


wingmembrane_data = pd.DataFrame({
    'Name': ['Arrax', 'Caraxes', 'Cannibal', 'Dreamfyre', 'Meleys', 'Moondancer', 'Morghul', 'Morning', 'Seasmoke', 'Sheepstealer', 'Shrykos', 'Silverwing', 
             'Stormcloud', 'Sunfyre', 'Syrax', 'Tessarion', 'Tyraxes', 'Vermax', 'Vermithor', 'Vhagar', 'Balerion', 'Meraxes', 'Quicksilver', 'Grey Ghost'],
    'HexCode_Accents': ['#E5B347', '#632322', '#181818', '#bcc6cc', '#B87333', '#F4EFE6', '#616269', '#181818', '#CC9E9B', '#46322A', '#B87333', '#bcc6cc', '#2F2F2F', 
              '#CC9E9B', '#E4BD57', '#B87333', '#C50016', '#C0712C', '#C56731', '#4F635A', '#181818', '#CC9E9B', '#E5B347', '#F2F2F2']
})

eye_data = pd.DataFrame({
   'Name': ['Arrax', 'Caraxes', 'Cannibal', 'Dreamfyre', 'Meleys', 'Moondancer', 'Morghul', 'Morning', 'Seasmoke', 'Sheepstealer', 'Shrykos', 'Silverwing', 
             'Stormcloud', 'Sunfyre', 'Syrax', 'Tessarion', 'Tyraxes', 'Vermax', 'Vermithor', 'Vhagar', 'Balerion', 'Meraxes', 'Quicksilver', 'Grey Ghost'],
    'HexCode_Eyes': ['#E5B347', '#F5D21E', '#59A630', '#A6C3DC', '#B87333', '#98AF05', '#B83A36', '#B83A36', '#A6C3DC', '#C48C55', '#B87333', '#A6C3DC', '#A6C3DC', 
              '#5E7B36', '#5E7B36', '#B87333', '#B83A36', '#F5D21E', '#C48C55', '#5E7B36', '#B83A36', '#E5B347', '#E5B347', '#98AF05'],
})

# Sort the DataFrame by the 'Name' column
scale_data = scale_data.sort_values(by='Name').reset_index(drop=True)
wingmembrane_data = wingmembrane_data.sort_values(by='Name').reset_index(drop=True)
eye_data = eye_data.sort_values(by='Name').reset_index(drop=True)

# Function to convert hex color code to RGB
def hex_to_rgb(hex_code):
    return tuple(int(hex_code[i:i+2], 16)/255.0 for i in (1, 3, 5))

# Function to plot colors with names
def plot_colors_from_hex(names, hex_codes, title):
    fig, ax = plt.subplots(figsize=(12, 2))
    ax.set_title(title)
    for i, (name, hex_code) in enumerate(zip(names, hex_codes)):
        color = hex_to_rgb(hex_code)
        ax.add_patch(plt.Rectangle((i, 0), 1, 1, color=color))
        ax.text(i + 0.5, -0.1, name, ha='center', va='center', fontsize=10, color='black', rotation=90)
    ax.set_xlim(0, len(hex_codes))
    ax.set_ylim(-0.2, 1)
    ax.axis('off')
    plt.show()
    
# Plot the hex colors for scales with names
scales = plot_colors_from_hex(scale_data['Name'], scale_data['HexCode_Scales'], 'Scale Colors')
# Plot the hex colors for scales with names
accents = plot_colors_from_hex(wingmembrane_data['Name'], wingmembrane_data['HexCode_Accents'], 'Wing Membrane & Accent Colors')
# Plot the hex colors for scales with names
eyes = plot_colors_from_hex(eye_data['Name'], eye_data['HexCode_Eyes'], 'Eye Colors')

# Initial dataframes
dragon_data = pd.read_csv('final_cleaned_dragon_data.csv')
color_data = dragon_data[['Name', 'HatchedFrom', 'ScaleColor', 'WingMembraneColor', 'EyeColor']]

scale_data = pd.DataFrame({
    'Name': ['Arrax', 'Caraxes', 'Cannibal', 'Dreamfyre', 'Meleys', 'Moondancer', 'Morghul', 'Morning', 'Seasmoke', 'Sheepstealer', 'Shrykos', 'Silverwing', 
             'Stormcloud', 'Sunfyre', 'Syrax', 'Tessarion', 'Tyraxes', 'Vermax', 'Vermithor', 'Vhagar', 'Balerion', 'Meraxes', 'Quicksilver', 'Grey Ghost'],
    'HexCode_Scales': ['#F4EFE6', '#632322', '#181818', '#7AA2D0', '#8E1000', '#75968F', '#616269', '#B98293', '#DADADA', '#46322A', '#245550', '#bcc6cc', '#354669', 
              '#F1BD59', '#E4BD57', '#2F37A8', '#181818', '#929151', '#814C32', '#9A835A', '#181818', '#D3D4DB', '#F3ECEA', '#F2F2F2'],
})


accent_data = pd.DataFrame({
    'Name': ['Arrax', 'Caraxes', 'Cannibal', 'Dreamfyre', 'Meleys', 'Moondancer', 'Morghul', 'Morning', 'Seasmoke', 'Sheepstealer', 'Shrykos', 'Silverwing', 
             'Stormcloud', 'Sunfyre', 'Syrax', 'Tessarion', 'Tyraxes', 'Vermax', 'Vermithor', 'Vhagar', 'Balerion', 'Meraxes', 'Quicksilver', 'Grey Ghost'],
    'HexCode_Accents': ['#E5B347', '#632322', '#181818', '#bcc6cc', '#B87333', '#F4EFE6', '#616269', '#181818', '#CC9E9B', '#46322A', '#B87333', '#bcc6cc', '#2F2F2F', 
              '#CC9E9B', '#E4BD57', '#B87333', '#C50016', '#C0712C', '#C56731', '#4F635A', '#181818', '#CC9E9B', '#E5B347', '#F2F2F2']
})

eye_data = pd.DataFrame({
   'Name': ['Arrax', 'Caraxes', 'Cannibal', 'Dreamfyre', 'Meleys', 'Moondancer', 'Morghul', 'Morning', 'Seasmoke', 'Sheepstealer', 'Shrykos', 'Silverwing', 
            'Stormcloud', 'Sunfyre', 'Syrax', 'Tessarion', 'Tyraxes', 'Vermax', 'Vermithor', 'Vhagar', 'Balerion', 'Meraxes', 'Quicksilver', 'Grey Ghost'],
    'HexCode_Eyes': ['#E5B347', '#F5D21E', '#59A630', '#A6C3DC', '#B87333', '#98AF05', '#B83A36', '#B83A36', '#A6C3DC', '#C48C55', '#B87333', '#A6C3DC', '#A6C3DC', 
              '#5E7B36', '#5E7B36', '#B87333', '#B83A36', '#F5D21E', '#C48C55', '#5E7B36', '#B83A36', '#E5B347', '#E5B347', '#98AF05'],
})

# Converting dictionaries to DataFrames
scale_df = pd.DataFrame(scale_data)
accent_df = pd.DataFrame(accent_data)
eye_df = pd.DataFrame(eye_data)

# Merging dataframes
merged_df = scale_df.merge(accent_df, on='Name', how='left').merge(eye_df, on='Name', how='left')
color_df = merged_df.merge(color_data, on='Name', how='left')

# Alphabetize by 'Name'
color_df = color_df.sort_values(by='Name').reset_index(drop=True)

df = pd.DataFrame(color_df)
    
# Define specific groups based on visual similarity
scale_assignments = {
    'Silver': 'Silver',
    'Charcoal': 'Black',
    'Gold': 'Gold',
    'Bronze': 'Bronze',
    'Pearl-White': 'White',
    'Pale Silver-Grey': 'Silver',
    'Pale Silver-White': 'White',
    'Pale Grey-White': 'White',
    'Pale Grey': 'Grey',
    'Red': 'Red',
    'Scarlet Red': 'Red',
    'Pale Pink': 'Pink',
    'Black': 'Black',
    'Dark Grey': 'Black',
    'Brown': 'Bronze',
    'Pale Green': 'Green',
    'Olive Green': 'Green',
    'Jade Green': 'Green',
    'Green-Blue': 'Green',
    'Yellow': 'Yellow',
    'Dark Cobalt Blue': 'Blue',
    'Pale Blue': 'Blue',
    'Dark Grey-Blue': 'Blue'
}

accent_assignments = {
    'Gold': 'Gold', 
    'Red': 'Red', 
    'Black': 'Black', 
    'Silver': 'Silver', 
    'Pale Pink': 'Pink', 
    'Pearl-White': 'White',
    'Dark Grey': 'Black', 
    'Grey': 'Grey', 
    'Brown': 'Bronze', 
    'Green': 'Green', 
    'Yellow': 'Yellow', 
    'Pale Orange': 'Yellow', 
    'Tan': 'Bronze', 
    'Pale Grey': 'Grey',
    'Green-Blue': 'Green',
    'Pink': 'Pink',
    'Bronze': 'Bronze',
    'Charcoal': 'Black',
    'Pale Grey-White': 'White',
    'Copper': 'Copper',
    'White': 'White'
}

eye_assignments = {
    'Gold': 'Gold', 
    'Yellow': 'Yellow', 
    'Green': 'Green', 
    'Pale Blue': 'Blue', 
    'Bright Blue': 'Blue',
    'Bright Green': 'Green',
    'Copper': 'Copper', 
    'Pale Green': 'Green',
    'Red': 'Red',
    'Dark Green': 'Green'
}

# Apply the group assignments
df['ScaleColorGroup'] = df['ScaleColor'].map(scale_assignments)
df['AccentColorGroup'] = df['WingMembraneColor'].map(accent_assignments)
df['EyeColorGroup'] = df['EyeColor'].map(eye_assignments)

# Ensure 'Mother' is mapped using 'HatchedFrom'
df['Mother'] = df['HatchedFrom']

# List of known bonded pairs 
bonded_pairs = [
    ('Balerion', 'Meraxes'), 
    ('Balerion', 'Vhagar'), 
    ('Vermithor', 'Dreamfyre'), 
    ('Vermithor', 'Silverwing'),
    ('Caraxes', 'Syrax'), 
]

# Create a DataFrame from bonded pairs
bonded_pairs_df = pd.DataFrame(bonded_pairs, columns=['Father', 'Mother'])

# Merge color group information for fathers and mothers
bonded_pairs_df = bonded_pairs_df.merge(df[['Name', 'ScaleColorGroup', 'AccentColorGroup', 'EyeColorGroup']], left_on='Father', right_on='Name', how='left').drop(columns=['Name'])
bonded_pairs_df = bonded_pairs_df.merge(df[['Name', 'ScaleColorGroup', 'AccentColorGroup', 'EyeColorGroup']], left_on='Mother', right_on='Name', how='left', suffixes=('_Father', '_Mother')).drop(columns=['Name'])

# Merge color data with bonded pairs to associate offspring with both parents
color_df = df.merge(bonded_pairs_df, left_on='Mother', right_on='Mother', how='left')

# Ensure no nulls by filling with 'Unknown'
color_df['ScaleColorGroup_Father'] = color_df['Father'].map(df.set_index('Name')['ScaleColorGroup']).fillna('Unknown')
color_df['ScaleColorGroup_Mother'] = color_df['Mother'].map(df.set_index('Name')['ScaleColorGroup']).fillna('Unknown')
color_df['AccentColorGroup_Father'] = color_df['Father'].map(df.set_index('Name')['AccentColorGroup']).fillna('Unknown')
color_df['AccentColorGroup_Mother'] = color_df['Mother'].map(df.set_index('Name')['AccentColorGroup']).fillna('Unknown')
color_df['EyeColorGroup_Father'] = color_df['Father'].map(df.set_index('Name')['EyeColorGroup']).fillna('Unknown')
color_df['EyeColorGroup_Mother'] = color_df['Mother'].map(df.set_index('Name')['EyeColorGroup']).fillna('Unknown')

# Display a sample of the merged data to ensure correctness
color_df[['Name', 'ScaleColor', 'ScaleColorGroup', 'HexCode_Scales', 'WingMembraneColor', 'AccentColorGroup', 'HexCode_Accents', 'EyeColor', 'EyeColorGroup', 'HexCode_Eyes', 'Father', 'Mother', 'ScaleColorGroup_Father', 
          'ScaleColorGroup_Mother', 'AccentColorGroup_Father', 'AccentColorGroup_Mother', 'EyeColorGroup_Father', 'EyeColorGroup_Mother']].head()

df = pd.DataFrame(color_df)

# Calculate the overall frequency of each trait in the entire dataset
scale_frequencies = df['ScaleColorGroup'].value_counts(normalize=True).to_dict()
accent_frequencies = df['AccentColorGroup'].value_counts(normalize=True).to_dict()
eye_frequencies = df['EyeColorGroup'].value_counts(normalize=True).to_dict()

# Calculate the frequency of each trait in parents
parent_scale_frequencies = df[['ScaleColorGroup_Father', 'ScaleColorGroup_Mother']].melt().value_counts(normalize=True).to_dict()
parent_accent_frequencies = df[['AccentColorGroup_Father', 'AccentColorGroup_Mother']].melt().value_counts(normalize=True).to_dict()
parent_eye_frequencies = df[['EyeColorGroup_Father', 'EyeColorGroup_Mother']].melt().value_counts(normalize=True).to_dict()

# Calculate the frequency of each trait in offspring
offspring_scale_frequencies = df['ScaleColorGroup'].value_counts(normalize=True).to_dict()
offspring_accent_frequencies = df['AccentColorGroup'].value_counts(normalize=True).to_dict()
offspring_eye_frequencies = df['EyeColorGroup'].value_counts(normalize=True).to_dict()

# Function to calculate generation span for each trait
def calculate_generation_span(df, trait_column, father_column, mother_column):
    generation_span = {}
    for name, group in df.groupby(trait_column):
        generations = set()
        for idx, row in group.iterrows():
            if row[father_column] == name or row[mother_column] == name:
                generations.add('parent')
            if row[trait_column] == name:
                generations.add('offspring')
        generation_span[name] = len(generations)
    return generation_span

# Calculate generation span for each trait
scale_generation_span = calculate_generation_span(df, 'ScaleColorGroup', 'ScaleColorGroup_Father', 'ScaleColorGroup_Mother')
accent_generation_span = calculate_generation_span(df, 'AccentColorGroup', 'AccentColorGroup_Father', 'AccentColorGroup_Mother')
eye_generation_span = calculate_generation_span(df, 'EyeColorGroup', 'EyeColorGroup_Father', 'EyeColorGroup_Mother')

# Function to determine dominance based on frequency and generation span
def determine_dominance(trait_frequencies, parent_trait_frequencies, offspring_trait_frequencies, generation_span):
    dominance_info = {}
    for trait, freq in trait_frequencies.items():
        parent_freq = parent_trait_frequencies.get(trait, 0)
        offspring_freq = offspring_trait_frequencies.get(trait, 0)
        gen_span = generation_span.get(trait, 0)
        
        if freq > 0.1 and gen_span > 1:  # Threshold for dominance
            dominance_info[trait] = 'Dominant'
        else:
            dominance_info[trait] = 'Recessive'
    return dominance_info

# Determine dominance for each trait type
scale_dominance_info = determine_dominance(scale_frequencies, parent_scale_frequencies, offspring_scale_frequencies, scale_generation_span)
accent_dominance_info = determine_dominance(accent_frequencies, parent_accent_frequencies, offspring_accent_frequencies, accent_generation_span)
eye_dominance_info = determine_dominance(eye_frequencies, parent_eye_frequencies, offspring_eye_frequencies, eye_generation_span)

def format_dominance_info(dominance_dict):
    dominant_colors = [color for color, dom in dominance_dict.items() if dom == 'Dominant']
    recessive_colors = [color for color, dom in dominance_dict.items() if dom == 'Recessive']
    return dominant_colors, recessive_colors

scale_dominant, scale_recessive = format_dominance_info(scale_dominance_info)
accent_dominant, accent_recessive = format_dominance_info(accent_dominance_info)
eye_dominant, eye_recessive = format_dominance_info(eye_dominance_info)

df = pd.DataFrame(color_df)

# Define the traits of Dreamfyre, Silverwing, and potential fathers
dreamfyre_traits = {'ScaleColorGroup': 'Blue', 'AccentColorGroup': 'Silver', 'EyeColorGroup': 'Blue'}
silverwing_traits = {'ScaleColorGroup': 'Silver', 'AccentColorGroup': 'Silver', 'EyeColorGroup': 'Blue'}

quicksilver_traits = {'ScaleColorGroup': 'White', 'AccentColorGroup': 'Gold', 'EyeColorGroup': 'Gold'}

potential_fathers = pd.DataFrame({
    'Name': ['Balerion', 'Cannibal'],
    'ScaleColorGroup': ['Black', 'Black'],
    'AccentColorGroup': ['Black', 'Black'],
    'EyeColorGroup': ['Red', 'Green']
})

# Dominance information
scale_dominance = scale_dominance_info
accent_dominance = accent_dominance_info
eye_dominance = eye_dominance_info

# Combine unique values from potential fathers and offspring traits
combined_values = {
    'ScaleColorGroup': list(set(potential_fathers['ScaleColorGroup'].unique()).union(['Blue', 'Silver'])),
    'AccentColorGroup': list(set(potential_fathers['AccentColorGroup'].unique()).union(['Silver', 'Silver'])),
    'EyeColorGroup': list(set(potential_fathers['EyeColorGroup'].unique()).union(['Blue', 'Blue']))
}

# Encode categorical traits into numerical values
label_encoders = {col: LabelEncoder().fit(combined_values[col]) for col in combined_values}

# Transform the traits of potential fathers
encoded_fathers = potential_fathers.copy()
for col, le in label_encoders.items():
    encoded_fathers[col] = le.transform(potential_fathers[col])

# Prepare feature matrix (X) and target vector (y)
X = encoded_fathers[['ScaleColorGroup', 'AccentColorGroup', 'EyeColorGroup']]
y = encoded_fathers['Name']

# Function to fit the model and predict using Random Forest
def fit_and_predict_rf(traits):
    clf = RandomForestClassifier(random_state=42)
    clf.fit(X, y)
    encoded_traits = {col: le.transform([traits[col]])[0] for col, le in label_encoders.items()}
    traits_features = pd.DataFrame([encoded_traits])
    return clf.predict(traits_features)[0]

# Fit the Random Forest model multiple times and collect predictions
def collect_predictions(traits, iterations=100):
    predictions = [fit_and_predict_rf(traits) for _ in range(iterations)]
    return pd.Series(predictions).mode()[0]

# Determine the most predicted father for each offspring
most_predicted_fathers = {
    'Dreamfyre': collect_predictions(dreamfyre_traits),
    'Silverwing': collect_predictions(silverwing_traits)
}

# Update color_df with the predicted fathers and their traits
for offspring, father in most_predicted_fathers.items():
    color_df.loc[color_df['Name'] == offspring, 'Father'] = father
    father_traits = potential_fathers[potential_fathers['Name'] == father].iloc[0]
    color_df.loc[color_df['Name'] == offspring, 'ScaleColorGroup_Father'] = father_traits['ScaleColorGroup']
    color_df.loc[color_df['Name'] == offspring, 'AccentColorGroup_Father'] = father_traits['AccentColorGroup']
    color_df.loc[color_df['Name'] == offspring, 'EyeColorGroup_Father'] = father_traits['EyeColorGroup']
    mother_traits = quicksilver_traits
    color_df.loc[color_df['Name'] == offspring, 'ScaleColorGroup_Mother'] = mother_traits['ScaleColorGroup']
    color_df.loc[color_df['Name'] == offspring, 'AccentColorGroup_Mother'] = mother_traits['AccentColorGroup']
    color_df.loc[color_df['Name'] == offspring, 'EyeColorGroup_Mother'] = mother_traits['EyeColorGroup']

# Show the results for Dreamfyre and Silverwing
dreamfyre_silverwing_result = color_df[color_df['Name'].isin(['Dreamfyre', 'Silverwing'])][['Name', 'Mother', 'Father']]

# Define the traits of Seasmoke, Meleys, and potential fathers
seasmoke_traits = {'ScaleColorGroup': 'Silver', 'AccentColorGroup': 'Pink', 'EyeColorGroup': 'Blue'}

meleys_traits = {'ScaleColorGroup': 'Red', 'AccentColorGroup': 'Copper', 'EyeColorGroup': 'Copper'}

potential_fathers = pd.DataFrame({
    'Name': ['Sheepstealer', 'Cannibal'],
    'ScaleColorGroup': ['Bronze', 'Black'],
    'AccentColorGroup': ['Bronze', 'Black'],
    'EyeColorGroup': ['Copper', 'Green']
})

# Grandparent traits data
grandparent_traits = {
    'Meleys': {'Father': {'ScaleColorGroup': 'Bronze', 'AccentColorGroup': 'Bronze', 'EyeColorGroup': 'Copper'},
                 'Mother': {'ScaleColorGroup': 'Blue', 'AccentColorGroup': 'Silver', 'EyeColorGroup': 'Blue'}},
    'Sheepstealer': {'Father': {'ScaleColorGroup': 'Black', 'AccentColorGroup': 'Black', 'EyeColorGroup': 'Red'},
                'Mother': {'ScaleColorGroup': 'Bronze', 'AccentColorGroup': 'Green', 'EyeColorGroup': 'Green'}},
    'Cannibal': {'Father': {'ScaleColorGroup': 'Black', 'AccentColorGroup': 'Black', 'EyeColorGroup': 'Red'},
                'Mother': {'ScaleColorGroup': 'Bronze', 'AccentColorGroup': 'Green', 'EyeColorGroup': 'Green'}}
}

# Dominance information
scale_dominance = scale_dominance_info
accent_dominance = accent_dominance_info
eye_dominance = eye_dominance_info


# Combine unique values from potential fathers and Seasmoke
combined_values = {
    'ScaleColorGroup': list(set(potential_fathers['ScaleColorGroup'].unique()).union(['Silver'])),
    'AccentColorGroup': list(set(potential_fathers['AccentColorGroup'].unique()).union(['Pink'])),
    'EyeColorGroup': list(set(potential_fathers['EyeColorGroup'].unique()).union(['Blue']))
}

# Encode categorical traits into numerical values
label_encoders = {col: LabelEncoder().fit(combined_values[col]) for col in combined_values}

# Transform the traits of potential fathers
encoded_fathers = potential_fathers.copy()
for col, le in label_encoders.items():
    encoded_fathers[col] = le.transform(potential_fathers[col])

# Prepare feature matrix (X) and target vector (y)
X = encoded_fathers[['ScaleColorGroup', 'AccentColorGroup', 'EyeColorGroup']]
y = encoded_fathers['Name']

# Function to fit the model and predict using Random Forest
def fit_and_predict_rf(traits):
    clf = RandomForestClassifier(random_state=42)
    clf.fit(X, y)
    encoded_traits = {col: le.transform([traits[col]])[0] for col, le in label_encoders.items()}
    traits_features = pd.DataFrame([encoded_traits])
    return clf.predict(traits_features)[0]

# Fit the Random Forest model multiple times and collect predictions
def collect_predictions(traits, iterations=100):
    predictions = [fit_and_predict_rf(traits) for _ in range(iterations)]
    return pd.Series(predictions).mode()[0]

# Determine the most predicted father for Seasmoke
most_predicted_father = collect_predictions(seasmoke_traits)

# Update color_df with the predicted father and traits for Seasmoke
color_df.loc[color_df['Name'] == 'Seasmoke', 'Father'] = most_predicted_father
father_traits = potential_fathers[potential_fathers['Name'] == most_predicted_father].iloc[0]
color_df.loc[color_df['Name'] == 'Seasmoke', 'ScaleColorGroup_Father'] = father_traits['ScaleColorGroup']
color_df.loc[color_df['Name'] == 'Seasmoke', 'AccentColorGroup_Father'] = father_traits['AccentColorGroup']
color_df.loc[color_df['Name'] == 'Seasmoke', 'EyeColorGroup_Father'] = father_traits['EyeColorGroup']
mother_traits = meleys_traits
color_df.loc[color_df['Name'] == 'Seasmoke', 'ScaleColorGroup_Mother'] = mother_traits['ScaleColorGroup']
color_df.loc[color_df['Name'] == 'Seasmoke', 'AccentColorGroup_Mother'] = mother_traits['AccentColorGroup']
color_df.loc[color_df['Name'] == 'Seasmoke', 'EyeColorGroup_Mother'] = mother_traits['EyeColorGroup']

# Show the results for Seasmoke
seasmoke_result = color_df[color_df['Name'].isin(['Seasmoke'])][['Name', 'Mother', 'Father']]