app.py

import os
import requests
import json
from datetime import datetime
from functools import wraps
from dotenv import load_dotenv
from flask import Flask, render_template, request, redirect, url_for, flash, jsonify
from flask_login import LoginManager, login_user, logout_user, login_required, current_user
from flask_bcrypt import Bcrypt
from flask_restful import Api, Resource, fields, marshal_with
from models import db, User, CompProf, StudProf, Drive, App

# Load theenvironment
load_dotenv()
AIPIPE_TOKEN = os.getenv('AIPIPE_TOKEN')
AIPIPE_URL = 'https://aipipe.org/openai/v1/chat/completions'

# Flask setup
app = Flask(__name__)
app.config['SECRET_KEY'] = 'sec123'
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///database.sqlite3'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config['UPLOAD_FOLDER'] = 'static/uploads'

api = Api(app)
os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)

db.init_app(app)
bcr = Bcrypt(app)
lmang = LoginManager(app)
lmang.login_view = 'login'

@lmang.user_loader
def load_u(uid):
    return User.query.get(int(uid))

# ========== AI FUNCTIONS ==========
def call_ai(prompt, temp=0.7):
    """Call AI Pipe API"""
    if not AIPIPE_TOKEN:
        return {'error': 'AI token not configured'}
    try:
        response = requests.post(AIPIPE_URL, headers={
            'Authorization': f'Bearer {AIPIPE_TOKEN}',
            'Content-Type': 'application/json'
        }, json={'model': 'gpt-4o-mini', 'messages': [{'role': 'user', 'content': prompt}], 'temperature': temp}, timeout=60)
        
        if response.status_code == 200:
            try:
                content = response.json()['choices'][0]['message']['content']
                # Try to parse as JSON, if it fails return as content
                try:
                    return json.loads(content)
                except:
                    # If not JSON, wrap in content key
                    return {'content': content}
            except (KeyError, IndexError, ValueError) as e:
                return {'error': f'Response parsing error: {str(e)}'}
        elif response.status_code == 429:
            return {'error': 'API rate limit reached. Please try again in a moment.'}
        elif response.status_code == 401:
            return {'error': 'Invalid or expired API token'}
        else:
            return {'error': f'API Error: {response.status_code}'}
    except requests.Timeout:
        return {'error': 'Request timed out. Please try again.'}
    except requests.ConnectionError:
        return {'error': 'Connection error. Please check your internet.'}
    except Exception as e:
        return {'error': f'Error: {str(e)}'}

def analyze_resume(resume, job):
    """Analyze resume vs job"""
    if not resume or not job:
        return {'error': 'Resume and job description required'}
    prompt = f"""Analyze how well this resume matches the job. Be concise and return valid JSON.

Resume: {resume}
Job: {job}

Return ONLY valid JSON (no markdown, no backticks): {{"score": 0-100, "strengths": ["list"], "gaps": ["list"], "recommendation": "text"}}"""
    return call_ai(prompt, 0.3)

def enhance_job_description(title, desc, budget):
    """Improve job description"""
    if not title or not desc:
        return {'error': 'Title and description required'}
    prompt = f"""Improve this job description to be more appealing. Return valid JSON only (no markdown).

Title:{title}
Description:{desc}
Budget/Perks:  {budget}

Return ONLY valid JSON: {{"responsibilities": ["list"], "required_skills": ["list"], "nice_to_have_skills": ["list"]}}"""
    return call_ai(prompt, 0.3)

def score_application(resume, requirements, company):
    """Score an application"""
    if not resume or not requirements:
        return {'error': 'Resume and requirements required'}
    prompt = f"""Score this job application. Be concise and return valid JSON only (no markdown, no backticks).

Resume: {resume}
Job Requirements: {requirements}
Company: {company}

Return ONLY valid JSON: {{"technical_skills": 1-10, "experience": 1-10, "communication": 1-10, "cultural_fit": 1-10, "overall_fit": 1-10, "next_steps": "analysis"}}"""
    return call_ai(prompt, 0.3)

def generate_interview_questions(title, desc, num):
    """Generate interview questions"""
    if not title or not desc:
        return {'error': 'Title and description required'}
    prompt = f"""Generate {num} interview questions for this role. Return valid JSON only (no markdown).

Position: {title}
Description: {desc}

Return ONLY valid JSON array: [{{"question": "text", "difficulty": "easy|medium|hard"}}]"""
    return call_ai(prompt, 0.5)

# ========== AUTH & ROLE ==========
def chk_role(r):
    def dec(f):
        @wraps(f)
        @login_required
        def wrap(*a,**kw):
            if current_user.role != r:
                return redirect(url_for('idx'))
            return f(*a, **kw)
        return wrap
    return dec

with app.app_context():
    db.create_all()
    if not User.query.filter_by(username='admin').first():
        hpw = bcr.generate_password_hash('admin123').decode('utf-8')
        db.session.add(User(username='admin', password=hpw, role='admin', status='approved'))
        db.session.commit()

# ========== ROUTES ==========
@app.route('/')
def idx():
    if current_user.is_authenticated:
        rdir = {'admin': 'ad_dash', 'company': 'co_dash', 'student': 'st_dash'}
        return redirect(url_for(rdir.get(current_user.role, 'idx')))
    return render_template('login.html')

@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'POST':
        u = User.query.filter_by(username=request.form.get('un')).first()
        if u and bcr.check_password_hash(u.password, request.form.get('pw')):
            if u.status == 'pending':
                flash("Pending admin approval")
            elif u.status == 'blacklisted':
                flash("Account blacklisted")
            else:
                login_user(u)
                return redirect(url_for('idx'))
        else:
            flash("Wrong credentials")
    return render_template('login.html')

@app.route('/logout')
@login_required
def logout():
    logout_user()
    return redirect(url_for('login'))

@app.route('/register', methods=['GET', 'POST'])
def reg():
    if request.method == 'POST':
        un = request.form.get('un', '').strip()
        pw = request.form.get('pw', '').strip()
        rl =request.form.get('rl', 'student')
        
        # validate tthe username
        if not un or len(un) < 3:
            flash("Username must be at least 3 characters")
            return redirect(url_for('reg'))
        if User.query.filter_by(username=un).first():
            flash("Username already exists")
            return redirect(url_for('reg'))
        
        # validate password for the User
        if not pw or len(pw) < 4:
            flash("Password must be at least 4 characters")
            return redirect(url_for('reg'))
        
        pw_hash = bcr.generate_password_hash(pw).decode('utf-8')
        u = User(username=un, password=pw_hash, role=rl, status='pending')
        
        try:
            if rl == 'company':
                cn = request.form.get('cn', '').strip()
                hr = request.form.get('hr', '').strip()
                wb = request.form.get('wb', '').strip()
                if not cn or not hr:
                    flash("Company name and HR contact are mandatory")
                    return redirect(url_for('reg'))
                u.cp = CompProf(cname=cn, hr=hr, web=wb)
                u.status = 'pending'
            elif rl == 'student':
                nm = request.form.get('nm', '').strip()
                rn = request.form.get('rn', '').strip()
                ph = request.form.get('ph', '').strip()
                dg = request.form.get('dg', '').strip()
                
                if not nm or not rn or not ph or not dg:
                    flash("Name, roll number, phone, and degree are mandatory")
                    return redirect(url_for('reg'))
                
                if StudProf.query.filter_by(rno=rn).first():
                    flash("Roll number already registered")
                    return redirect(url_for('reg'))
                
                u.sp = StudProf(name=nm, rno=rn, contact=ph, degree=dg)
                u.status = 'active'
            
            db.session.add(u)
            db.session.commit()
            flash("Registration successful! Redirecting to login...")
            return redirect(url_for('login'))
        except Exception as e:
            db.session.rollback()
            flash(f"Registration error: {str(e)}")
            return redirect(url_for('reg'))
    return render_template('register.html')

# ===-====== ADMIN ======
@app.route('/admin')
@chk_role('admin')
def ad_dash():
    return render_template('admin/dashboard.html',
        st=User.query.filter_by(role='student').count(),
        co=User.query.filter_by(role='company').count(),
        dr=Drive.query.count(),
        ap=App.query.count(),
        pc=User.query.filter_by(role='company', status='pending').all(),
        pd=Drive.query.filter_by(status='pending').all())

@app.route('/admin/std')
@chk_role('admin')
def m_std():
    q =request.args.get('q', '')
    if q:
        ls =User.query.join(User.sp).filter(User.role == 'student', (StudProf.name.ilike(f'%{q}%')) | (StudProf.rno.ilike(f'%{q}%'))).all()
    else:
        ls= User.query.filter_by(role='student').all()
    return render_template('admin/manage_students.html', ls=ls)

@app.route('/admin/co')
@chk_role('admin')
def m_co():
    q = request.args.get('q', '')
    if q:
        ls = User.query.join(User.cp).filter(User.role == 'company', CompProf.cname.ilike(f'%{q}%')).all()
    else:
        ls = User.query.filter_by(role='company').all()
    return render_template('admin/manage_companies.html', ls=ls)

@app.route('/admin/act_u/<int:id>/<string:act>')
@chk_role('admin')
def act_u(id, act):
    u = User.query.get(id)
    status_map = {'app': 'approved', 'blk': 'blacklisted', 'sus': 'pending', 'act': 'active'}
    new_status = status_map.get(act, u.status)
    u.status = new_status
    db.session.commit()
    flash(f"User {u.username} is now {new_status}", 'success')
    return redirect(request.referrer or url_for('ad_dash'))

@app.route('/admin/act_d/<int:id>/<string:act>')
@chk_role('admin')
def act_d(id, act):
    d = Drive.query.get(id)
    d.status = 'approved' if act == 'app' else 'rejected'
    db.session.commit()
    return redirect(request.referrer or url_for('ad_dash'))

@app.route('/admin/drives')
@chk_role('admin')
def ad_drives():
    q = request.args.get('q', '')
    status = request.args.get('status', '')
    drives = Drive.query
    
    if q:
        drives = drives.filter(Drive.title.ilike(f'%{q}%'))
    if status:
        drives = drives.filter_by(status=status)
    
    drives = drives.all()
    return render_template('admin/drives.html', drives=drives, q=q, status=status)

@app.route('/admin/applications')
@chk_role('admin')
def ad_applications():
    q = request.args.get('q', '')
    status = request.args.get('status', '')
    drive_id = request.args.get('drive_id', '')
    
    applications = App.query.join(User).join(StudProf).join(Drive, App.did == Drive.id)
    
    if q:
        applications = applications.filter(
            (StudProf.name.ilike(f'%{q}%')) | (Drive.title.ilike(f'%{q}%'))
        )
    if status:
        applications = applications.filter(App.status == status)
    if drive_id:
        applications = applications.filter(App.did == drive_id)
    
    applications = applications.all()
    return render_template('admin/applications.html', applications=applications, q=q, status=status, drive_id=drive_id)

# ====== COMPANY======
@app.route('/company')
@chk_role('company')
def co_dash():
    if current_user.status != 'approved':
        return render_template('company/pending.html')
    return render_template('company/dashboard.html', dvs=Drive.query.filter_by(cid=current_user.cp.id).all())


@app.route('/company/mk_drv', methods=['GET', 'POST'])
@chk_role('company')
def mk_drv():
    if request.method == 'POST':
        db.session.add(Drive(cid=current_user.cp.id, title=request.form.get('tl'), desc=request.form.get('ds'),
            el=request.form.get('eg'), deadline=datetime.strptime(request.form.get('dl'), '%Y-%m-%dT%H:%M'), status='pending'))
        db.session.commit()
        return redirect(url_for('co_dash'))
    return render_template('company/create_drive.html')

@app.route('/company/drv/<int:id>/apps')
@chk_role('company')
def vw_apps(id):
    return render_template('company/applications.html', d=Drive.query.get(id), als=App.query.filter_by(did=id).all())

@app.route('/company/app/<int:id>/<string:st>')
@chk_role('company')
def upd_app(id, st):
    a = App.query.get(id)
    if a:
        a.status = st
        db.session.commit()
        flash(f"Application {st}: {a.student.sp.name}", 'success')
    return redirect(url_for('vw_apps', id=a.did))

@app.route('/admin/app/<int:id>/<string:st>')
@chk_role('admin')
def admin_upd_app(id, st):
    a = App.query.get(id)
    if a:
        a.status = st
        db.session.commit()
        flash(f"Application {st}", 'success')
    return redirect(request.referrer or url_for('ad_applications'))

# ====== STUDENT ====
@app.route('/student')
@chk_role('student')
def st_dash():
    apps =App.query.filter_by(sid=current_user.id).all()
    return render_template('student/dashboard.html', dvs=Drive.query.filter_by(status='approved').all(),
        apps=apps, aids=[x.did for x in apps])

@app.route('/student/app/<int:id>', methods=['POST'])
@chk_role('student')
def apply(id):
    if not App.query.filter_by(sid=current_user.id, did=id).first():
        db.session.add(App(sid=current_user.id, did=id, status='applied'))
        db.session.commit()
    return redirect(url_for('st_dash'))

@app.route('/student/prof', methods=['GET', 'POST'])
@chk_role('student')
def prof():
    if request.method == 'POST':
        s =current_user.sp
        nm = request.form.get('nm', '').strip()
        ph =request.form.get('ph', '').strip()
        dg = request.form.get('dg', '').strip()
        
        if not nm or not ph or not dg:
            flash("Name, phone, and degree are mandatory")
            return redirect(url_for('prof'))
        
        s.name = nm
        s.contact = ph
        s.degree = dg
        r = request.files.get('rs')
        if r and r.filename:
            fn = f"rs_{current_user.id}_{r.filename}"
            r.save(os.path.join(app.config['UPLOAD_FOLDER'], fn))
            s.resume = fn
        db.session.commit()
        flash("Profile updated successfully!")
    return render_template('student/profile.html')

# ========== API ==========
class DrvApi(Resource):
    @marshal_with({'id': fields.Integer, 'title': fields.String, 'cname': fields.String(attribute='comp.cname'),
        'status': fields.String, 'dl': fields.String(attribute=lambda x: x.deadline.isoformat())})
    def get(self):
        return Drive.query.filter_by(status='approved').all()


class StdApi(Resource):
    @marshal_with({'name': fields.String(attribute='sp.name'), 'rno': fields.String(attribute='sp.rno'), 'status': fields.String})
    def get(self):
        return User.query.filter_by(role='student').all()

api.add_resource(DrvApi, '/api/drives')
api.add_resource(StdApi, '/api/students')



# ========== AI ROUTES ==========
@app.route('/ai/analyze-resume', methods=['POST'])
@login_required
def ai_analyze_resume():
    data = request.get_json()
    if not data.get('resume') or not data.get('job_description'):
        return jsonify({'error': 'Missing data'}), 400
    return jsonify(analyze_resume(data['resume'], data['job_description']))

@app.route('/ai/enhance-job', methods=['POST'])
@chk_role('company')
def ai_enhance_job():
    data = request.get_json()
    if not data.get('title') or not data.get('description'):
        return jsonify({'error': 'Missing data'}), 400
    return jsonify(enhance_job_description(data['title'], data['description'], data.get('budget', 'Competitive')))



@app.route('/ai/score-app', methods=['POST'])
@chk_role('company')
def ai_score_app():
    data = request.get_json()
    if not data.get('resume') or not data.get('requirements'):
        return jsonify({'error': 'Missing data'}), 400
    company = current_user.cp.cname if current_user.role == 'company' else 'Company'
    return jsonify(score_application(data['resume'], data['requirements'], company))

@app.route('/ai/generate-questions', methods=['POST'])
@chk_role('company')
def ai_generate_questions():
    data = request.get_json()
    if not data.get('job_title') or not data.get('job_description'):
        return jsonify({'error': 'Missing data'}), 400
    return jsonify(generate_interview_questions(data['job_title'], data['job_description'], int(data.get('num_questions', 5))))




if __name__ == '__main__':
    app.run(debug=True)