app.py

from flask import Flask, render_template, request, redirect, url_for
import json
import math
from collections import OrderedDict
import joblib
import os
import pickle
app = Flask(__name__)
import os
import joblib
import json
from flask import Flask
import sqlite3
import csv
from flask import make_response


app = Flask(__name__)

# ✅ Database setup
DB_FILE = 'database.db'

def init_db():
    conn = sqlite3.connect(DB_FILE)
    cursor = conn.cursor()
    cursor.execute('''
        CREATE TABLE IF NOT EXISTS user_results (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            name TEXT,
            gender TEXT,
            location TEXT,
            academic_level TEXT,
            percentage REAL,
            scaled_academic REAL,
            interests TEXT,
            quiz_scores TEXT,
            top_careers TEXT,
            ml_prediction TEXT,
            ml_confidence REAL
        )
    ''')
    conn.commit()
    conn.close()

# Call once when Flask starts
init_db()

# ✅ Load model and encoders
from flask import Flask, render_template, request, redirect, url_for
import json
import joblib
import os

app = Flask(__name__)
global MODEL, LE_INTEREST, LE_TARGET

# ✅ Load model and encoders
try:
    MODEL = joblib.load(os.path.join(os.getcwd(), 'career_model.pkl'))
    LE_INTEREST = joblib.load(os.path.join(os.getcwd(), 'le_interest.pkl'))
    LE_TARGET = joblib.load(os.path.join(os.getcwd(), 'le_target.pkl'))
    print("✅ Model and encoders loaded successfully!")
    print("MODEL FEATURES COUNT:", MODEL.n_features_in_)
    print("MODEL CLASSES:", MODEL.classes_)
except Exception as e:
    MODEL = None
    LE_INTEREST = None
    LE_TARGET = None
    print("⚠️ Model or encoders not found. ML predictions disabled.")
    print("Error details:", e)

# ✅ Load career data file
with open('career_data.json', 'r', encoding='utf-8') as f:
    CAREER_DATA = json.load(f)
    # ===== build lookup maps from career_data.json (works for all levels & streams) =====
interest_to_roadmap = {}
interest_to_jobtrend = {}
career_to_details = {}  # map career name -> detail dict (roadmap, job_trend, from_interest)

for level_key, level_dict in CAREER_DATA.items():
    # level_key is "10th" or "12th", level_dict is the dict of interests
    for interest_key, interest_obj in level_dict.items():
        # normalize interest label (we used uppercase in templates before)
        interest_label = interest_key.upper()
        # interest_obj might be a dict containing 'roadmap', 'job_trend', 'careers', 'title', etc.
        if isinstance(interest_obj, dict):
            interest_to_roadmap[interest_label] = interest_obj.get('roadmap', [])
            interest_to_jobtrend[interest_label] = interest_obj.get('job_trend', {})
            title = interest_obj.get('title', interest_label)
            careers = interest_obj.get('careers', [])
            # If careers is a dict (rare) or list, handle both
            if isinstance(careers, dict):
                # some files might incorrectly store a mapping; flatten keys
                careers_list = list(careers.keys())
            else:
                careers_list = list(careers)
            for career in careers_list:
                # only add if string / valid
                if isinstance(career, str) and career.strip():
                    career_to_details[career] = {
                        'career': career,
                        'from_interest': title,
                        'roadmap': interest_obj.get('roadmap', []),
                        'job_trend': interest_obj.get('job_trend', {})
                    }
        else:
            # fallback: interest_obj is not dict (unlikely) — leave empty defaults
            interest_to_roadmap[interest_label] = []
            interest_to_jobtrend[interest_label] = {}


@app.route('/')
def index():
    return render_template('index.html')

@app.route('/interests', methods=['POST'])
def interests():
    # collect user basic info and show interests based on level
    name = request.form.get('name', '').strip()
    gender = request.form.get('gender', '')
    location = request.form.get('location', '')
    academic_level = request.form.get('academic_level', '')  # '10th' or '12th'
    try:
        percentage = float(request.form.get('percentage', 0))
    except:
        percentage = 0.0

    # load interest list for level
    level_data = CAREER_DATA.get(academic_level, {})
    
    # level_data is dict keyed by interest keys; convert to ordered for template
    return render_template('interests.html',
                           name=name, gender=gender, location=location,
                           academic_level=academic_level, percentage=percentage,
                           interests=level_data)

@app.route('/assessment', methods=['POST'])
def assessment():
    # carry forward user info and selected interests
    name = request.form.get('name', '').strip()
    gender = request.form.get('gender', '')
    location = request.form.get('location', '')
    academic_level = request.form.get('academic_level', '')
    try:
        percentage = float(request.form.get('percentage', 0))
    except:
        percentage = 0.0

    selected = request.form.getlist('selected_interests')
    if not selected:
        return redirect(url_for('index'))

    # Build quiz items from career data
    selected_interests = request.form.getlist("selected_interests")
    level_data = CAREER_DATA.get(academic_level, {})
    quiz_items = []

    for key in selected_interests:
        if key in level_data:
           quiz_items.append({
            "key": key,
            "title": level_data[key]["title"],
            "questions": level_data[key]["questions"]
        })


    return render_template('assessment.html',
                           name=name, gender=gender, location=location,
                           academic_level=academic_level, percentage=percentage,
                           quiz_items=quiz_items)

# 🧠 ML prediction (only if model is available)
@app.route('/result', methods=['POST'])
def result():
    name = request.form.get('name', '').strip()
    academic_level = request.form.get('academic_level', '')
    try:
        percentage = float(request.form.get('percentage', 0))
    except:
        percentage = 0.0

    # scale to 50
    scaled_academic = (percentage / 100.0) * 50.0

    # ✅ Only use the interests user selected
    interest_keys = request.form.getlist('selected_interests')
    level_data = CAREER_DATA.get(academic_level, {})

    if not interest_keys:
        # fallback — only if somehow none were selected
        interest_keys = list(level_data.keys())

    # Grade each interest's quiz (each question maps to categories 1..5)
    interest_results = []
    cat_totals = {'logic': 0.0, 'subject': 0.0, 'problem': 0.0, 'personality': 0.0, 'creativity': 0.0}
    cat_counts = 0  # number of interests that had questions

    for key in interest_keys:
        item = level_data.get(key, {})
        questions = item.get('questions', [])
        correct_count = 0
        q_cat_scores = {'logic': 0, 'subject': 0, 'problem': 0, 'personality': 0, 'creativity': 0}

        for i, q in enumerate(questions, start=1):
            selected = request.form.get(f'ans_{key}_{i}', '')
            correct = request.form.get(f'correct_{key}_{i}', '')
            if selected == correct:
                correct_count += 1
                # map Q1..Q5 to categories
                if i == 1:
                    q_cat_scores['logic'] += 10
                elif i == 2:
                    q_cat_scores['subject'] += 10
                elif i == 3:
                    q_cat_scores['problem'] += 10
                elif i == 4:
                    q_cat_scores['personality'] += 10
                elif i == 5:
                    q_cat_scores['creativity'] += 10

        # accumulate per-interest category totals (for averages later)
        if questions:
            cat_counts += 1
            for c in cat_totals:
                cat_totals[c] += q_cat_scores.get(c, 0)

        quiz_score = correct_count * 10  # out of 50
        total = round(scaled_academic + quiz_score, 2)

        interest_results.append({
            'key': key,
            'title': item.get('title', key),
            'quiz_score': quiz_score,
            'total': total,
            'careers': item.get('careers', []),
            'roadmap': item.get('roadmap', []),
            'job_trend': item.get('job_trend', {})
        })

    # Sort interests by total descending
    interest_results.sort(key=lambda x: x['total'], reverse=True)

    # Dedup careers in order of best interests
    ordered_careers = []
    for res in interest_results:
        for c in res.get('careers', []):
            if c not in ordered_careers:
                ordered_careers.append(c)
            if len(ordered_careers) >= 10:
                break
        if len(ordered_careers) >= 10:
            break
    top_3_careers = ordered_careers[:3]

    # Build career_cards for result UI
    career_cards = []
    for career in top_3_careers:
        found = False
        for lvl, lvl_dict in CAREER_DATA.items():
            for ik, io in lvl_dict.items():
                if isinstance(io, dict) and 'careers' in io and career in io['careers']:
                    career_cards.append({
                        'career': career,
                        'from_interest': io.get('title', ik),
                        'roadmap': io.get('roadmap', []),
                        'job_trend': io.get('job_trend', {})
                    })
                    found = True
                    break
            if found:
                break
        if not found:
            career_cards.append({
                'career': career,
                'from_interest': 'Unknown',
                'roadmap': [],
                'job_trend': {}
            })

    # ==================== ML Prediction ====================
    ml_prediction = None
    ml_confidence = None
    if MODEL is not None:
        try:
            if cat_counts > 0:
                avg_logic = cat_totals['logic'] / cat_counts
                avg_subject = cat_totals['subject'] / cat_counts
                avg_problem = cat_totals['problem'] / cat_counts
                avg_personality = cat_totals['personality'] / cat_counts
                avg_creativity = cat_totals['creativity'] / cat_counts
            else:
                avg_logic = avg_subject = avg_problem = avg_personality = avg_creativity = 0.0

            n_features = getattr(MODEL, "n_features_in_", None)
            candidates = [
                [avg_logic, avg_subject, avg_problem, avg_personality, avg_creativity, scaled_academic],
                [avg_logic, avg_subject, avg_problem, avg_personality, avg_creativity],
                [scaled_academic, avg_logic, avg_subject, avg_problem, avg_personality]
            ]
            if n_features is not None:
                # prefer vectors whose length matches the model
                candidates = [c for c in candidates if len(c) == n_features] + [c for c in candidates if len(c) != n_features]

            for feat in candidates:
                # Debug print to terminal
                print("\n====== ML DEBUG ======")
                print("Model expects:", getattr(MODEL, "n_features_in_", None))
                print("Features used for this user:", feat)
                print("Scaled academic:", scaled_academic)
                print("Category averages:", avg_logic, avg_subject, avg_problem, avg_personality, avg_creativity)
                print("======================\n")

                try:
                    pred = MODEL.predict([feat])[0]
                    if LE_TARGET is not None:
                        try:
                            ml_prediction = LE_TARGET.inverse_transform([pred])[0]
                        except Exception:
                            ml_prediction = pred
                    else:
                        ml_prediction = pred

                    if hasattr(MODEL, 'predict_proba'):
                        try:
                            prob = MODEL.predict_proba([feat])
                            if prob is not None:
                                if hasattr(MODEL, 'classes_'):
                                    cls_index = list(MODEL.classes_).index(pred)
                                    ml_confidence = float(prob[0][cls_index])
                                else:
                                    ml_confidence = float(max(prob[0]))
                        except Exception:
                            ml_confidence = None
                    break  # success; stop trying candidates
                except Exception:
                    continue

        except Exception as e:
            print("⚠️ ML prediction failed:", e)
            ml_prediction = "Prediction unavailable"
    else:
        ml_prediction = "ML model not available"
    # ======================================================

    # Roadmaps & simple placeholder trends
    career_roadmaps = {}
    for result_item in interest_results:
        for career in result_item.get('careers', []):
            career_roadmaps[career] = result_item.get('roadmap', [])

    job_trends = {}
    for career in top_3_careers:
        job_trends[career] = "Growing demand and opportunities"

        # ✅ Save results to SQLite
    try:
        conn = sqlite3.connect(DB_FILE)
        cursor = conn.cursor()
        cursor.execute('''
            INSERT INTO user_results 
            (name, gender, location, academic_level, percentage, scaled_academic, interests, quiz_scores, top_careers, ml_prediction, ml_confidence)
            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
        ''', (
            name,
            request.form.get('gender', ''),
            request.form.get('location', ''),
            academic_level,
            percentage,
            scaled_academic,
            ', '.join(interest_keys),
            str([r['quiz_score'] for r in interest_results]),
            ', '.join(top_3_careers),
            ml_prediction,
            ml_confidence if ml_confidence else 0.0
        ))
        conn.commit()
        conn.close()
        print("✅ User result saved successfully!")
    except Exception as e:
        print("⚠️ Failed to save result:", e)

    # Final render must be inside the function (same indent as above lines)
    return render_template(
        'result.html',
        name=name,
        academic_level=academic_level,
        percentage=percentage,
        scaled_academic=round(scaled_academic, 2),
        interest_results=interest_results,
        top_careers=top_3_careers,
        career_cards=career_cards,
        career_roadmaps=career_roadmaps,
        job_trends=job_trends,
        ml_prediction=ml_prediction,
        ml_confidence=ml_confidence
    )
@app.route('/view_results')
def view_results():
    import sqlite3, collections
    conn = sqlite3.connect("database.db")
    cursor = conn.cursor()
    cursor.execute("SELECT * FROM user_results ORDER BY id DESC")
    rows = cursor.fetchall()
    conn.close()

    # Convert to dicts
    results = []
    career_counter = collections.Counter()
    level_counter = collections.Counter()

    for r in rows:
        results.append({
            'id': r[0],
            'name': r[1],
            'gender': r[2],
            'location': r[3],
            'academic_level': r[4],
            'percentage': r[5],
            'scaled_academic': r[6],
            'interests': r[7],
            'quiz_scores': r[8],
            'top_careers': r[9],
            'ml_prediction': r[10],
            'ml_confidence': r[11],
        })
        career_counter[r[10]] += 1
        level_counter[r[4]] += 1

    # Prepare chart data
    career_labels = list(career_counter.keys())[:8]
    career_counts = list(career_counter.values())[:8]
    level_labels = list(level_counter.keys())
    level_counts = list(level_counter.values())

    return render_template(
        'view_results.html',
        results=results,
        career_labels=career_labels,
        career_counts=career_counts,
        level_labels=level_labels,
        level_counts=level_counts
    )
@app.route('/job_trends')
def job_trends():
    trends = []
    for level_key, level_dict in CAREER_DATA.items():
        for interest_key, interest_obj in level_dict.items():
            if isinstance(interest_obj, dict):
                for career in interest_obj.get('careers', []):
                    jt = interest_obj.get('job_trend', {})
                    if jt:
                        trends.append({
                            'career': career,
                            'demand': jt.get('demand', 'N/A'),
                            'avg_salary': jt.get('avg_salary', 'N/A'),
                            'future_scope': jt.get('future_scope', 'N/A')
                        })
    return render_template('job_trends.html', trends=trends)

    output.seek(0)

    from flask import Response
    return Response(
        output.getvalue(),
        mimetype="text/csv",
        headers={"Content-Disposition": "attachment;filename=user_results.csv"}
    )
@app.route('/download_csv')
def download_csv():
    import sqlite3
    conn = sqlite3.connect('database.db')
    cursor = conn.cursor()
    cursor.execute("SELECT * FROM user_results")
    rows = cursor.fetchall()
    headers = [description[0] for description in cursor.description]
    conn.close()

    # create the CSV response
    si = []
    si.append(','.join(headers))
    for row in rows:
        si.append(','.join(str(v) for v in row))

    output = make_response('\n'.join(si))
    output.headers["Content-Disposition"] = "attachment; filename=user_results.csv"
    output.headers["Content-type"] = "text/csv"
    return output
@app.route('/clear_data')
def clear_data():
    import sqlite3
    conn = sqlite3.connect("database.db")
    cursor = conn.cursor()
    cursor.execute("DELETE FROM user_results")
    cursor.execute("DELETE FROM sqlite_sequence WHERE name='user_results'")
    conn.commit()
    conn.close()
    print("✅ All user data deleted.")
    return "<h2 style='color:green;'>All user data deleted successfully!</h2><a href='/view_results'>Back to Dashboard</a>"

if __name__ == "__main__":
    app.run()