app.py

from flask import Flask, render_template, request, redirect, send_file, send_from_directory, flash, url_for
from werkzeug.utils import secure_filename
from werkzeug.security import generate_password_hash, check_password_hash
from flask_sqlalchemy import SQLAlchemy
from flask_login import (
    LoginManager,
    UserMixin,
    login_user,
    login_required,
    logout_user,
    current_user,
)

import os
import json
import io
import secrets
import shutil

app = Flask(__name__)
app.secret_key = "noteify_secret"

# ----------------- Config -----------------
BASE_DIR = os.path.abspath(os.path.dirname(__file__))
app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///" + \
    os.path.join(BASE_DIR, "noteify.db")
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False

UPLOAD_FOLDER = os.path.join(BASE_DIR, "uploads")
os.makedirs(UPLOAD_FOLDER, exist_ok=True)

db = SQLAlchemy(app)
login_manager = LoginManager(app)
login_manager.login_view = "login"


# ----------------- Models -----------------
class User(db.Model, UserMixin):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(80), unique=True, nullable=False)
    password_hash = db.Column(db.String(200), nullable=False)

    notes = db.relationship("Note", backref="user", lazy=True)
    subjects = db.relationship("Subject", backref="user", lazy=True)


class Note(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(150), nullable=False)
    content = db.Column(db.Text, nullable=False)
    user_id = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=False)


class Subject(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(150), nullable=False)
    user_id = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=False)


class SharedNote(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    token = db.Column(db.String(64), unique=True, nullable=False)
    note_id = db.Column(db.Integer, db.ForeignKey("note.id"), nullable=False)

    note = db.relationship("Note")


# ----------------- Login manager -----------------
@login_manager.user_loader
def load_user(user_id):
    return User.query.get(int(user_id))


# ----------------- Helper functions -----------------
def get_user_subject_folder(subject_name, user_id):
    # uploads/<user_id>/<subject_name>/
    folder = os.path.join(UPLOAD_FOLDER, str(user_id), subject_name)
    os.makedirs(folder, exist_ok=True)
    return folder


def count_user_files(user_id):
    base = os.path.join(UPLOAD_FOLDER, str(user_id))
    if not os.path.exists(base):
        return 0
    total = 0
    for root, dirs, files in os.walk(base):
        total += len(files)
    return total


# ----------------- Auth routes -----------------
@app.route("/register", methods=["GET", "POST"])
def register():
    if current_user.is_authenticated:
        return redirect(url_for("index"))

    if request.method == "POST":
        username = request.form.get("username", "").strip()
        password = request.form.get("password", "").strip()
        confirm = request.form.get("confirm", "").strip()

        if not username or not password:
            flash("Username and password are required.")
            return redirect(url_for("register"))

        if password != confirm:
            flash("Passwords do not match.")
            return redirect(url_for("register"))

        existing = User.query.filter_by(username=username).first()
        if existing:
            flash("Username already taken.")
            return redirect(url_for("register"))

        user = User(
            username=username,
            password_hash=generate_password_hash(password),
        )
        db.session.add(user)
        db.session.commit()
        flash("Registration successful. Please log in.")
        return redirect(url_for("login"))

    return render_template("register.html")


@app.route("/login", methods=["GET", "POST"])
def login():
    if current_user.is_authenticated:
        return redirect(url_for("index"))

    if request.method == "POST":
        username = request.form.get("username", "").strip()
        password = request.form.get("password", "").strip()

        user = User.query.filter_by(username=username).first()
        if user and check_password_hash(user.password_hash, password):
            login_user(user)
            flash("Logged in successfully.")
            next_page = request.args.get("next")
            return redirect(next_page or url_for("index"))
        else:
            flash("Invalid username or password.")
            return redirect(url_for("login"))

    return render_template("login.html")


@app.route("/logout")
@login_required
def logout():
    logout_user()
    flash("Logged out.")
    return redirect(url_for("login"))


# ----------------- Notes routes -----------------
@app.route("/")
@login_required
def index():
    user_notes = Note.query.filter_by(
        user_id=current_user.id).order_by(Note.id.desc()).all()
    subjects = Subject.query.filter_by(
        user_id=current_user.id).order_by(Subject.name.asc()).all()
    return render_template("index.html", notes=user_notes, subjects=[s.name for s in subjects])


@app.route("/add", methods=["POST"])
@login_required
def add_note():
    title = request.form.get("title", "").strip()
    content = request.form.get("content", "").strip()
    if not title:
        flash("Note title required.")
        return redirect(url_for("index"))

    # unique title per user
    existing = Note.query.filter_by(
        user_id=current_user.id, title=title).first()
    if existing:
        flash("Note title already exists.")
        return redirect(url_for("index"))

    note = Note(title=title, content=content, user_id=current_user.id)
    db.session.add(note)
    db.session.commit()
    flash("Note saved.")
    return redirect(url_for("index"))


@app.route("/edit/<int:note_id>")
@login_required
def edit_note(note_id):
    note = Note.query.filter_by(id=note_id, user_id=current_user.id).first()
    if not note:
        flash("Note not found.")
        return redirect(url_for("index"))
    return render_template("add_edit.html", title=note.title, content=note.content, note_id=note.id)


@app.route("/update/<int:note_id>", methods=["POST"])
@login_required
def update_note(note_id):
    note = Note.query.filter_by(id=note_id, user_id=current_user.id).first()
    if not note:
        flash("Note not found.")
        return redirect(url_for("index"))

    content = request.form.get("content", "").strip()
    note.content = content
    db.session.commit()
    flash("Note updated.")
    return redirect(url_for("index"))


@app.route("/delete_note/<int:note_id>")
@login_required
def delete_note(note_id):
    note = Note.query.filter_by(id=note_id, user_id=current_user.id).first()
    if not note:
        flash("Note not found.")
    else:
        db.session.delete(note)
        db.session.commit()
        flash("Note deleted.")
    return redirect(url_for("index"))


@app.route("/download_notes")
@login_required
def download_notes():
    notes = Note.query.filter_by(user_id=current_user.id).all()
    data = {n.title: n.content for n in notes}
    json_bytes = json.dumps(data, indent=2).encode("utf-8")
    return send_file(
        io.BytesIO(json_bytes),
        as_attachment=True,
        download_name="notes.json",
        mimetype="application/json",
    )


@app.route("/reset_notes")
@login_required
def reset_notes():
    Note.query.filter_by(user_id=current_user.id).delete()
    db.session.commit()
    flash("All notes cleared.")
    return redirect(url_for("index"))


# ----------------- Share note routes -----------------
@app.route("/share_note/<int:note_id>")
@login_required
def share_note(note_id):
    note = Note.query.filter_by(id=note_id, user_id=current_user.id).first()
    if not note:
        flash("Note not found.")
        return redirect(url_for("index"))

    token = secrets.token_urlsafe(16)
    shared = SharedNote(token=token, note=note)
    db.session.add(shared)
    db.session.commit()

    share_url = url_for("view_shared_note", token=token, _external=True)
    flash(f"Shareable link: {share_url}")
    return redirect(url_for("index"))


@app.route("/s/<token>")
def view_shared_note(token):
    shared = SharedNote.query.filter_by(token=token).first()
    if not shared:
        flash("Shared note not found or link expired.")
        return redirect(url_for("login"))

    note = shared.note
    return render_template("shared_note.html", title=note.title, content=note.content)


# ----------------- Subjects / files -----------------
@app.route("/add_subject", methods=["POST"])
@login_required
def add_subject():
    subject_name = request.form.get("subject", "").strip()
    if not subject_name:
        flash("Subject name required.")
        return redirect(url_for("index"))

    existing = Subject.query.filter_by(
        user_id=current_user.id, name=subject_name).first()
    if existing:
        flash("Subject already exists.")
        return redirect(url_for("index"))

    subject = Subject(name=subject_name, user_id=current_user.id)
    db.session.add(subject)
    db.session.commit()

    # folder per user + subject
    get_user_subject_folder(subject_name, current_user.id)

    flash("Subject added.")
    return redirect(url_for("index"))


@app.route("/subject/<subject>")
@login_required
def subject_page(subject):
    subject_obj = Subject.query.filter_by(
        user_id=current_user.id, name=subject).first()
    if not subject_obj:
        flash("Subject not found.")
        return redirect(url_for("index"))

    folder = get_user_subject_folder(subject, current_user.id)
    files = sorted(os.listdir(folder)) if os.path.exists(folder) else []
    return render_template("subject.html", subject=subject, files=files)


@app.route("/upload/<subject>", methods=["POST"])
@login_required
def upload_file(subject):
    subject_obj = Subject.query.filter_by(
        user_id=current_user.id, name=subject).first()
    if not subject_obj:
        flash("Subject not found.")
        return redirect(url_for("index"))

    if "file" not in request.files:
        flash("No file part.")
        return redirect(url_for("subject_page", subject=subject))

    file = request.files["file"]
    if file.filename == "":
        flash("No selected file.")
        return redirect(url_for("subject_page", subject=subject))

    filename = secure_filename(file.filename)
    folder = get_user_subject_folder(subject, current_user.id)
    save_path = os.path.join(folder, filename)
    file.save(save_path)
    flash("File uploaded.")
    return redirect(url_for("subject_page", subject=subject))


@app.route("/download/<subject>/<filename>")
@login_required
def download_file(subject, filename):
    subject_obj = Subject.query.filter_by(
        user_id=current_user.id, name=subject).first()
    if not subject_obj:
        flash("Subject not found.")
        return redirect(url_for("index"))

    folder = get_user_subject_folder(subject, current_user.id)
    return send_from_directory(folder, filename, as_attachment=True)


@app.route("/delete_file/<subject>/<filename>")
@login_required
def delete_file(subject, filename):
    subject_obj = Subject.query.filter_by(
        user_id=current_user.id, name=subject).first()
    if not subject_obj:
        flash("Subject not found.")
        return redirect(url_for("index"))

    folder = get_user_subject_folder(subject, current_user.id)
    file_path = os.path.join(folder, filename)
    if os.path.exists(file_path):
        os.remove(file_path)
        flash("File deleted.")
    else:
        flash("File not found.")
    return redirect(url_for("subject_page", subject=subject))


@app.route("/delete_subject/<subject>")
@login_required
def delete_subject(subject):
    subject_obj = Subject.query.filter_by(
        user_id=current_user.id, name=subject).first()
    if not subject_obj:
        flash("Subject not found.")
        return redirect(url_for("index"))

    db.session.delete(subject_obj)
    db.session.commit()

    folder = get_user_subject_folder(subject, current_user.id)
    if os.path.exists(folder):
        shutil.rmtree(folder, ignore_errors=True)

    flash(f"Subject '{subject}' deleted successfully.")
    return redirect(url_for("index"))


# ----------------- Analytics dashboard -----------------
@app.route("/dashboard")
@login_required
def dashboard():
    total_notes = Note.query.filter_by(user_id=current_user.id).count()
    total_subjects = Subject.query.filter_by(user_id=current_user.id).count()
    total_files = count_user_files(current_user.id)
    total_shared = (
        SharedNote.query.join(Note).filter(
            Note.user_id == current_user.id).count()
    )

    stats = {
        "total_notes": total_notes,
        "total_subjects": total_subjects,
        "total_files": total_files,
        "total_shared": total_shared,
    }

    return render_template("dashboard.html", stats=stats)


# ----------------- run -----------------
if __name__ == "__main__":
    with app.app_context():
        db.create_all()
    app.run(host="0.0.0.0", debug=True)