from flask import Flask, render_template, request, redirect, url_for, session, flash, render_template_string
from flask_sqlalchemy import SQLAlchemy
from werkzeug.security import generate_password_hash, check_password_hash

app = Flask(__name__)

# --- KONFIGURATION ---
app.secret_key = 'super_geheimes_kanzlei_passwort'
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///kanzlei.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

db = SQLAlchemy(app)

# --- ROLLEN DEFINITION ---
# Hier legen wir fest, welche Rollen es gibt. Das hilft uns später bei Tippfehlern.
ROLES = {
    'FOUNDING_PARTNER': 'Founding Partner',
    'NAME_PARTNER': 'Name Partner',
    'SENIOR_PARTNER': 'Senior Partner',
    'JUNIOR_PARTNER': 'Junior Partner',
    'ASSOCIATE': 'Associate',
    'JUNIOR_ASSOCIATE': 'Junior Associate',
    'LEGAL_ASSISTANT': 'Legal Assistant',
    'LEGAL_ADVISOR': 'Legal Advisor',
    'ADMIN_ASSISTANT': 'Administrative Assistant',
    'TRAINEE': 'Trainee'
}

# --- DATENBANK MODELL ---
class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    # Login Daten
    username = db.Column(db.String(50), unique=True, nullable=False)
    password_hash = db.Column(db.String(150), nullable=False)
    role = db.Column(db.String(50), nullable=False, default=ROLES['TRAINEE'])
    
    # NEUE Stammdaten
    firstname = db.Column(db.String(100), nullable=True)
    lastname = db.Column(db.String(100), nullable=True)
    phone = db.Column(db.String(50), nullable=True)
    ic_email = db.Column(db.String(120), unique=True, nullable=True) # Kanzlei-Email

    # Relation: Ein User hat viele Dokumente
    documents = db.relationship('PersonnelDoc', backref='employee', lazy=True, cascade="all, delete-orphan")

    def can_delete_files(self):
        return self.role == ROLES['FOUNDING_PARTNER']
    
    def get_full_name(self):
        if self.firstname and self.lastname:
            return f"{self.lastname}, {self.firstname}"
        return self.username
# --- HILFSFUNKTIONEN ---
def get_current_user():
    if 'user_id' in session:
        return User.query.get(session['user_id'])
    return None

from datetime import datetime

class PersonnelDoc(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
    
    title = db.Column(db.String(150), nullable=False)
    doc_type = db.Column(db.String(20), nullable=False) # 'upload' oder 'code'
    
    # Für Uploads speichern wir den Dateinamen
    filename = db.Column(db.String(200), nullable=True)
    
    # Für "Code Dokumente" speichern wir den HTML-Code direkt hier
    content_code = db.Column(db.Text, nullable=True)
    
    created_at = db.Column(db.DateTime, default=datetime.utcnow)





# --- ROUTEN ---

@app.route('/')
def home():
    # Nur weiterleiten, wenn User AUCH in der DB existiert
    if 'user_id' in session:
        user = User.query.get(session['user_id'])
        if user:
            return redirect(url_for('dashboard'))
        else:
            # Falls Cookie da, aber User weg -> Cookie löschen
            session.pop('user_id', None)
            
    return render_template('index.html')
@app.route('/login', methods=['POST'])
def login():
    # Wir holen 'username' aus dem Formular
    username = request.form.get('username') 
    password = request.form.get('password')
    
    # Suche nach Benutzername
    user = User.query.filter_by(username=username).first()

    if user and check_password_hash(user.password_hash, password):
        session['user_id'] = user.id
        return redirect(url_for('dashboard'))
    
    return "Login fehlgeschlagen! <a href='/'>Zurück</a>"

@app.route('/dashboard')
def dashboard():
    user = get_current_user()
    
    # Wenn User-ID im Cookie steht, aber nicht in der Datenbank gefunden wird:
    if not user:
        # WICHTIG: Die ungültige Session zerstören!
        session.pop('user_id', None)
        return redirect(url_for('home'))
    
    return render_template('dashboard.html', user=user)

# --- BEISPIEL: EINE GESCHÜTZTE LÖSCH-FUNKTION ---
@app.route('/delete-file')
def delete_something():
    user = get_current_user()
    
    # 1. Erstmal prüfen, ob überhaupt eingeloggt
    if not user:
        return redirect(url_for('home'))

    # 2. DER RECHTE-CHECK (Ganz wichtig!)
    if not user.can_delete_files():
        # Fehler 403: Forbidden (Verboten)
        return "<h1>ZUGRIFF VERWEIGERT</h1><p>Nur der Founding Partner darf Daten löschen.</p><a href='/dashboard'>Zurück</a>", 403

    # Wenn wir hier ankommen, ist er Founding Partner
    return "<h1>DATEI GELÖSCHT</h1><p>Vorgang erfolgreich durchgeführt.</p><a href='/dashboard'>Zurück</a>"

@app.route('/mitarbeiter')
def mitarbeiter_list():
    user = get_current_user()
    
    # SICHERHEIT: Nur Founding Partner darf hier rein!
    if not user or user.role != ROLES['FOUNDING_PARTNER']:
        return "<h1>Zugriff verweigert</h1><p>Nur der Founding Partner hat Zugriff auf die Personalakte.</p>", 403
    
    # Alle Nutzer aus der DB holen
    all_users = User.query.all()
    
    # Wir übergeben die User, die Rollen (fürs Dropdown) und den aktuellen User
    return render_template('mitarbeiter.html', users=all_users, roles=ROLES, current_user=user)

# --- MITARBEITER HINZUFÜGEN ROUTE ---
@app.route('/mitarbeiter/add', methods=['POST'])
def add_mitarbeiter():
    user = get_current_user()
    if not user or user.role != ROLES['FOUNDING_PARTNER']:
        return "Zugriff verweigert", 403

    # Login Daten
    username = request.form.get('username')
    password = request.form.get('password')
    role = request.form.get('role')
    
    # Neue Stammdaten
    firstname = request.form.get('firstname')
    lastname = request.form.get('lastname')
    phone = request.form.get('phone')
    ic_email = request.form.get('ic_email')

    existing_user = User.query.filter((User.username == username) | (User.ic_email == ic_email)).first()
    if existing_user:
        flash('Fehler: Benutzername oder IC-Email existiert bereits!')
        return redirect(url_for('mitarbeiter_list'))

    new_user = User(
        username=username,
        password_hash=generate_password_hash(password),
        role=role,
        firstname=firstname,
        lastname=lastname,
        phone=phone,
        ic_email=ic_email
    )
    
    db.session.add(new_user)
    db.session.commit()
    
    flash(f'Personalakte für {lastname}, {firstname} angelegt.')
    return redirect(url_for('mitarbeiter_list'))

@app.route('/mitarbeiter/delete/<int:id>')
def delete_mitarbeiter(id):
    user = get_current_user()
    # Sicherheitscheck
    if not user or user.role != ROLES['FOUNDING_PARTNER']:
        return "Zugriff verweigert", 403
        
    user_to_delete = User.query.get(id)
    
    if user_to_delete:
        if user_to_delete.id == user.id:
            flash('Warnung: Du kannst dich nicht selbst löschen.')
        else:
            db.session.delete(user_to_delete)
            db.session.commit()
            flash('Mitarbeiter wurde entfernt.')
            
    return redirect(url_for('mitarbeiter_list'))







@app.route('/logout')
def logout():
    session.pop('user_id', None)
    return redirect(url_for('home'))

if __name__ == '__main__':
    with app.app_context():
        db.create_all()
    # Host 0.0.0.0 für deinen Root Server
    app.run(host='0.0.0.0', port=5000, debug=True)



from flask import render_template_string

# Detailansicht der Personalakte
# --- PERSONALAKTE & DOKUMENTE ---

# 1. Die Akte anzeigen
@app.route('/mitarbeiter/akte/<int:id>')
def mitarbeiter_akte(id):
    current_user = get_current_user()
    # Sicherheitscheck
    if not current_user or current_user.role != ROLES['FOUNDING_PARTNER']:
        return "Nur für Founding Partner", 403
        
    employee = User.query.get_or_404(id)
    return render_template('mitarbeiter_akte.html', employee=employee, user=current_user)

# 2. Ein Dokument (Code) speichern
@app.route('/mitarbeiter/doc/create/<int:user_id>', methods=['POST'])
def create_personnel_doc(user_id):
    title = request.form.get('title')
    code_content = request.form.get('code_content') # HTML Code aus dem Formular
    
    new_doc = PersonnelDoc(
        user_id=user_id,
        title=title,
        doc_type='code',
        content_code=code_content
    )
    db.session.add(new_doc)
    db.session.commit()
    return redirect(url_for('mitarbeiter_akte', id=user_id))

# 3. Das Dokument RENDERN (anzeigen)
@app.route('/render/doc/<int:doc_id>')
def render_personnel_doc(doc_id):
    doc = PersonnelDoc.query.get_or_404(doc_id)
    # Hier wird der gespeicherte HTML-Code zu einer echten Seite
    return render_template_string(doc.content_code)

# RENDER FUNKTION: Macht aus dem Code in der DB eine echte Webseite
@app.route('/render/doc/<int:doc_id>')
def render_personnel_doc(doc_id):
    doc = PersonnelDoc.query.get_or_404(doc_id)
    
    # Wir nehmen den gespeicherten Code und rendern ihn als HTML
    # ACHTUNG: render_template_string führt den Code aus. 
    # Da nur DU (Founding Partner) den Code schreibst, ist das okay.
    return render_template_string(doc.content_code)