#!/usr/bin/env python3.6
from flask import make_response
from flask import render_template, url_for, redirect, request
from flask_login import login_user, login_required, current_user, logout_user
from werkzeug.exceptions import HTTPException
from werkzeug.security import generate_password_hash, check_password_hash
import hashlib
import datetime
import time
import random

import fetchDUALIS
import fetchRAPLA
import requesthelpers
from fetchRAPLA import *
from calendar_generation import getWeek
from init import *


@app.route("/")
def index():
    """
    Leitet den normalen Website-Aufruf zum Login weiter.
    :return HTML:
    """
    return redirect(url_for("login"))


@app.route("/dashboard")
@login_required
def welcome():
    """
    Dashboard
    :return HTML:
    """
    if not current_user.kurs:
        return redirect(url_for("getKurs", next=url_for(request.endpoint)))
    sel = request.args.get("sel")
    if not sel:
        sel = "theorie"
    kurs = current_user.kurs
    name = current_user.name
    if sel == "theorie":
        t = ""
        p = "hidden"
    else:
        t = "hidden"
        p = ""
    return render_template('dashboard.html', kurs=kurs, name=name, theorie=t, praxis=p)


@app.route("/theorie/noten", methods=["GET", "POST"])
@login_required
async def displayNoten():
    """
    Zeigt die Noten aus Dualis an. Hierfür ist ein aktives Token nötig.
    :return HTML:
    """
    d = Dualis.query.filter_by(uid=current_user.id).first()
    if request.method == "POST":
        d.semester = request.form.get("sem")
        db.session.commit()
    if not d.semester:
        return redirect(url_for("getSemester", next=url_for(request.endpoint)))
    t = d.token
    chosensemester = d.semester
    c = request.cookies.get("cnsc")
    timeout = fetchDUALIS.timeOut(d, c, "displayNoten")
    if timeout:
        return timeout
    semester = requesthelpers.semesterlist(current_user.id)
    noten = await fetchDUALIS.getResults(t, c, chosensemester)
    return render_template("noten.html", noten=noten, semester=semester, sel=chosensemester, s="n", praxis="hidden")


@app.route("/plan", methods=["GET"])
@login_required
def displayRapla():
    """
    Zeigt den Stundenplan für eingeloggte User an. \n
    TODO: Persönliche Filter, Notizen, Essensvorlieben etc. berücksichtigen.
    :return HTML:
    """
    if not current_user.kurs:
        return redirect(url_for("getKurs", next=url_for(request.endpoint)))
    week = request.args.get("week")
    if week:
        week = datetime.datetime.strptime(week, "%Y-%m-%d")
    else:
        week = "today"
    samstag = request.args.get("samstag")
    if not samstag:
        samstag = False
    events = getWeek(week, fetchRAPLA.getIcal(current_user.kurs), samstag)
    return render_template("plan-user.html", events=events[0], eventdays=events[1],
                           name=current_user.name, prev=str(events[2])[:10], next=str(events[3])[:10], mon=events[4],
                           s="p", praxis="hidden")


@app.route("/plan/<string:kurs>")
def displayPlan(kurs):
    """
    Zeigt den Stundenplan ohne Login an. \n
    Präferenzen werden nicht berücksichtigt.
    :param kurs:
    :return HTML:
    """
    week = request.args.get("week")
    if week:
        week = datetime.datetime.strptime(week, "%Y-%m-%d")
    else:
        week = "today"
    try:
        if current_user.kurs == kurs.upper():
            return redirect(url_for("displayRapla"))
    except AttributeError:
        pass
    kurs = kurs.upper()
    plan = fetchRAPLA.getIcal(kurs)
    if plan:
        samstag = request.args.get("samstag")
        if not samstag:
            samstag = False
        events = getWeek(week, plan, samstag)
        return render_template("plan-anon.html", events=events[0], eventdays=events[1], kurs=kurs,
                               prev=str(events[2])[:10], next=str(events[3])[:10], mon=events[4], praxis="hidden")
    else:
        return redirect(url_for("login"))


@app.route("/set-up")
def redKurs():
    """
    Setup beginnt mit Kurs.
    :return HTML:
    """
    return redirect(url_for("getKurs"))


@app.route("/set-up/kurs")
@login_required
async def getKurs():
    """
    Automatische Kurs-Auswahl. \n
    Aktives Dualis-Token benötigt.
    :return HTML:
    """
    d = Dualis.query.filter_by(uid=current_user.id).first()
    if d:
        cookie = request.cookies.get("cnsc")
        timeout = fetchDUALIS.timeOut(d, cookie, "getKurs")
        if timeout:
            return timeout
        e = False
        if not current_user.kurs:
            kurs = await fetchDUALIS.getKurs(d.token, cookie)
            if kurs != 0:
                if not fetchRAPLA.getIcal(kurs):
                    return render_template('kurs.html', detected=(kurs, e), s="s", theorie="hidden", praxis="hidden",
                                           file=False)
                current_user.kurs = kurs
                db.session.commit()
            else:
                e = True
        else:
            kurs = current_user.kurs
            current_user.kurs = kurs
            db.session.commit()
    else:
        e = True
        kurs = ""
    return render_template('kurs.html', detected=(kurs, e), s="s", theorie="hidden", praxis="hidden", file=True)


@app.route("/set-up/semester")
@login_required
async def getSemester():
    """
    Manuelle Semester-Auswahl.
    :return HTML:
    """
    t = Dualis.query.filter_by(uid=current_user.id).first().token
    c = request.cookies.get("cnsc")
    semesterlist = Semesterlist.query.filter_by(uid=current_user.id).all()
    if not semesterlist:
        semester = await fetchDUALIS.getSem(t, c)
        for i in semester:
            semitem = Semesterlist(semestername=i[0], semesterid=i[1], uid=current_user.id, itemid=current_user.id*int(i[1][-7:])//1000000)
            db.session.add(semitem)
        db.session.commit()
    else:
        semester = requesthelpers.semesterlist(current_user.id)
    return render_template("semester.html", semester=semester, s="s", theorie="hidden", praxis="hidden")


@app.route("/set-up/semester", methods=["POST"])
@login_required
def setSemester():
    """
    Speichern der Semester-Auswahl.
    :return HTML:
    """
    n = request.args.get("next")
    if not n:
        n = url_for("welcome")
    d = Dualis.query.filter_by(uid=current_user.id).first()
    d.semester = request.form.get("sem")
    db.session.commit()
    return redirect(n)


@app.route("/set-up/rapla")
@login_required
def chooseRaplas():
    """
    Manuelle Rapla-Auswahl.
    :return HTML:
    """
    r = getRaplas()
    return render_template("rapla.html", raplas=r, s="s", theorie="hidden", praxis="hidden")


@app.route("/set-up/rapla", methods=["POST"])
@login_required
def getRapla():
    """
    Verarbeitet die Eingabe von chooseRaplas().
    :return HTML:
    """
    file = str(request.form.get("file"))
    url = str(request.form.get("url"))
    if file == url == "None":
        return redirect(url_for("chooseRaplas"))
    if file != "None":
        User.query.filter_by(id=current_user.id).first().kurs = file[5:-5]
        db.session.commit()
    elif url != "None":
        file = getNewRapla(url)
        if type(file) is not int:
            User.query.filter_by(id=current_user.id).first().kurs = file[5:-5]
            db.session.commit()
        else:
            return redirect(url_for("error", ecode=900))
    return redirect(url_for("welcome"))


@app.route("/log-in")
def login():
    """
    Login-Maske.
    :return HTML:
    """
    return render_template("login.html", theorie="hidden", praxis="hidden", s="s")


@app.route("/log-in", methods=["POST"])
async def login_post():
    """
    Verarbeitet die Eingabe von login(). \n
    Falls der User schon angelegt ist, wird das Passwort verglichen. \n
    Falls nicht, wird ein neuer angelegt.
    :return HTML:
    """
    email = request.form.get("email")
    password = request.form.get("password")
    n = request.args.get("next")
    if n:
        success = make_response(redirect(n))
    else:
        success = make_response(redirect(url_for("getKurs")))

    user = User.query.filter_by(email=email).first()
    t = await fetchDUALIS.checkUser(email, password)
    if t[0] == -2:
        return redirect(url_for("login", code=-2))
    if user:
        dualis = Dualis.query.filter_by(uid=user.id).first()
        dualis.token = t[0]
        newcookie = t[1]
        dualis.token_created = time.time()
        db.session.commit()
        login_user(user)
        if user.kurs:
            if not dualis.semester:
                success = make_response(redirect(url_for("getSemester")))
            elif not n:
                success = make_response(redirect(url_for("welcome")))
            success.set_cookie("cnsc", value=newcookie, httponly=True, secure=True)

    else:
        hashid = int(hashlib.sha1(email.encode("utf-8")).hexdigest(), 16) % (10 ** 8)
        pname = email.find(".") + 1
        ename = min(email[pname:].find("."), email[pname:].find("@"))
        name = email[pname:pname + ename].capitalize()
        new_user = User(email=email, name=name, id=hashid)
        db.session.add(new_user)

        cookie = requesthelpers.getCookie(t[1].cookies)

        new_dualis = Dualis(uid=hashid, token=t[0], token_created=int(time.time()))
        db.session.add(new_dualis)
        db.session.commit()
        login_user(new_user)
        success.set_cookie("cnsc", value=cookie, httponly=True, secure=True)
    return success


@app.route("/log-out")
@login_required
async def logout():
    """
    Loggt den User aus.
    :return Empty Token:
    """
    cookie = request.cookies.get("cnsc")
    dualis = Dualis.query.filter_by(uid=current_user.id).first()
    await fetchDUALIS.logOut(dualis.token, cookie)
    dualis.token = None
    db.session.commit()
    logout_user()
    red = make_response(redirect(url_for("login", code=1, next=url_for("welcome"))))
    red.set_cookie("cnsc", value="Logged out! Your temporary token "
                                 "on our server and the cookie on your device have been deleted.", httponly=True,
                   secure=True)
    return red


@app.route("/error")
def error():
    """
    Error Page für custom-Errors. \n
    TODO: Funktion depreciaten. Ersetzen durch Errors auf den entsprechenden Seiten.
    :return:
    """
    error = request.args.get("ecode")
    if error == "900":
        msg = "Ungültige RAPLA-URL! Sicher, dass der Link zum DHBW-Rapla führt?"
    elif error == "899":
        msg = "Der Kalender wurde nicht gefunden! Sicher, dass der Link korrekt ist?"
    else:
        msg = str(error)
    return render_template('display-message.html', message=msg)


@app.route("/error")
@app.errorhandler(HTTPException)
def handle(e):
    """"
    HTTP-Exception-Handler
    """
    return render_template('display-message.html', message=e)


if __name__ == "__main__":
    app.run(host='0.0.0.0', port=2024, debug=True)