import os  # Added to check if the CSV file exists
import pandas as pd
import mysql.connector
import matplotlib.pyplot as plt
import seaborn as sns
 
# Connect to MySQL Database
def connect_to_database():
    try:
        return mysql.connector.connect(
            host="localhost",
            user="your_username", 
            password="your_password",
            database="personality_db" 
        )
    except mysql.connector.Error as e:
        print(f"Error connecting to MySQL: {e}")
        exit()
 
# Create a table for storing data
def create_table():
    try:
        db = connect_to_database()
        cursor = db.cursor()
        cursor.execute("""
        CREATE TABLE IF NOT EXISTS personality_data (
            id INT AUTO_INCREMENT PRIMARY KEY,
            personality_type VARCHAR(255) UNIQUE,
            count INT DEFAULT 1
        )
        """)
        db.commit()
        db.close()
    except Exception as e:
        print(f"Error creating table: {e}")
        exit()
 
# Update personality counts in the database
def update_personality_count(personality):
    try:
        db = connect_to_database()
        cursor = db.cursor()
        cursor.execute("""
        INSERT INTO personality_data (personality_type, count)
        VALUES (%s, 1)
        ON DUPLICATE KEY UPDATE count = count + 1
        """, (personality,))
        db.commit()
        db.close()
    except Exception as e:
        print(f"Error updating personality count: {e}")
 
# Fetch all data from the database
def fetch_personality_data():
    try:
        db = connect_to_database()
        cursor = db.cursor(dictionary=True)
        cursor.execute("SELECT * FROM personality_data")
        result = cursor.fetchall()
        db.close()
        return result
    except Exception as e:
        print(f"Error fetching data: {e}")
        return []
 
# Save responses to CSV
def save_to_csv(answers, personality):
    try:
        file_exists = os.path.isfile("responses.csv")
        data = pd.DataFrame([answers + [personality]], columns=["Q1", "Q2", "Q3", "Personality"])
        data.to_csv("responses.csv", mode='a', header=not file_exists, index=False)
    except Exception as e:
        print(f"Error saving to CSV: {e}")
 
# Ask questions function
def ask_question(question, options):
    while True:
        print(f"\n{question}")
        for index, option in enumerate(options, start=1):
            print(f"{index}. {option}")
        try:
            answer = int(input("Enter the number corresponding to your choice: "))
            if 1 <= answer <= len(options):
                return options[answer - 1]
            else:
                print("Invalid choice. Please select a valid option.")
        except ValueError:
            print("Invalid input. Please enter a number.")
 
# Determine personality
def determine_personality(answers):
    personality_map = {
        ("I prefer spending time alone", "I enjoy thinking logically", "I avoid taking risks"): "Introverted, Logical, Cautious",
        ("I enjoy socializing", "I enjoy thinking creatively", "I love taking risks"): "Extroverted, Creative, Risk-taking",
        ("I prefer spending time alone", "I enjoy thinking creatively", "I avoid taking risks"): "Introverted, Creative, Cautious",
        ("I enjoy socializing", "I enjoy thinking logically", "I love taking risks"): "Extroverted, Logical, Risk-taking"}
    return personality_map.get(tuple(answers), "Unique Personality Type")
 
# Display personality description
def display_personality_description(personality):
    descriptions = {
        "Introverted, Logical, Cautious": "...values solitude, enjoys logical thinking, and tends to avoid risks.",
        "Extroverted, Creative, Risk-taking": "...loves socializing, thinks outside the box, and takes bold decisions.",
        "Introverted, Creative, Cautious": "...prefers alone time, enjoys creativity, and is careful with decisions.",
        "Extroverted, Logical, Risk-taking": "...loves social settings, enjoys logical problem-solving, and is open to new experiences.",
        "Unique Personality Type": "...has a distinct combination of traits that don't fit typical categories."}
 
    print(f"\nYour Personality Type is: {personality}")
    print("Personality Description: Based on your answers, you're a person who...")
    print(descriptions.get(personality, "...has an undefined personality type."))
 
# Plot personality distribution
def plot_personality_distribution():
    data = fetch_personality_data()
    if not data:
        print("No data available to plot.")
        return
 
    df = pd.DataFrame(data)
    sns.barplot(x='personality_type', y='count', data=df, palette='viridis')
    plt.title("Personality Type Distribution")
    plt.xlabel("Personality Type")
    plt.ylabel("Count")
    plt.xticks(rotation=45)
    plt.show()
 
# Main function
def main():
    create_table() 
 
    print("Welcome to the Personality Type Identifier!")
 
    questions = [
        ("Do you prefer spending time alone or with others?", 
         ["I prefer spending time alone", "I enjoy socializing"]),
        ("Do you prefer thinking logically or creatively?", 
         ["I enjoy thinking logically", "I enjoy thinking creatively"]),
        ("Do you like to take risks or play it safe?", 
         ["I avoid taking risks", "I love taking risks"])
    ]
 
    # Collect answers
    answers = [ask_question(question, options) for question, options in questions]
 
    # Determine personality type
    personality = determine_personality(answers)
    display_personality_description(personality)
 
    # Save results
    save_to_csv(answers, personality)
    update_personality_count(personality)
 
    # Plot personality distribution
    plot_personality_distribution()
 
if __name__ == "__main__":
    main()
 

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