#!/bin/python
import sqlite3
import secrets
import time
import flask_socketio
from flask import Flask, request
# base socket

app = Flask(__name__)
socketio = flask_socketio.SocketIO(app)

###############################################################################


def first_run():
    """
    create databases
    """
    con = sqlite3.connect("database.db")
    cur = con.cursor()
    cur.execute("CREATE TABLE USERS(\
                username,\
                password,\
                token)")

    cur.execute("CREATE TABLE NOTIFICATION(\
                id INTEGER PRIMARY KEY AUTOINCREMENT,\
                date,\
                machine,\
                token,\
                title,\
                content)")

    cur.execute("CREATE TABLE CLIPBOARD(\
                id INTEGER PRIMARY KEY AUTOINCREMENT,\
                date,\
                machine,\
                token,\
                content)")

    con.commit()
    con.close()

###############################################################################


@app.route("/user", methods=['POST'])
def auth():
    """
    Authentifie un user, simple, basique
    "username"
    "password"
    """
    user = (request.values.get("username"), request.values.get("password"))
    con = sqlite3.connect("database.db")
    cur = con.cursor()
    db_user = cur.execute("SELECT token FROM USERS WHERE USERNAME=? AND \
                          PASSWORD=?", user).fetchone()
    con.close()
    if db_user is None:
        return {"status": "This user does not exist or the password is \
                incorrect"}, 404
    else:
        return {"status": "ok", "token": db_user[0]}


@app.route("/user", methods=['PUT'])
def register():
    """
    Authentifie un user, simple, basique
    "username"
    "password"
    """
    con = sqlite3.connect("database.db")
    cur = con.cursor()
    username = request.values.get("username")
    user = (username,)
    if cur.execute("SELECT username FROM USERS WHERE username=?", user)\
            .fetchone() is not None:
        con.close()
        return {"status": "Error, username already taken"}, 500
    user = (request.values.get("username"), request.values.get("password"),
            secrets.token_urlsafe(64))
    try:
        cur.execute("INSERT INTO USERS VALUES (?,?,?)", user)
        con.commit()
        con.close()
        return {"status": "ok"}
    except:
        con.close()
        return {"status": "Error, most likely username already taken"}, 500

###############################################################################


@app.route("/notification", methods=['PUT'])
def add_notification():
    """
    Le but de cet app se resume a cette fonction, elle recoit une requete
    http et renvoie via le websocket le contenu de la requette a tout les 
    client.
    """
    token = request.values.get("token")
    title = request.values.get('title')
    content = request.values.get('content')
    device_name = request.values.get('deviceName')
    date = time.time()
    con = sqlite3.connect("database.db")
    cur = con.cursor()
    if cur.execute("SELECT username FROM USERS WHERE token=?", (token,))\
            .fetchone() is None:
        return {"status": "Error, no user"}, 500
    try:
        notification = (date, device_name, token, title, content)
        cur.execute("INSERT INTO notification VALUES (null,?,?,?,?,?)",
                    notification)
        con.commit()
        con.close()
        socketio.emit("NotificationUpdate",
                      data={"device_name": device_name},
                      broadcast=True)

        return {"status": "ok"}, 200
    except:
        return {"status": "error"}, 500


@app.route("/notification", methods=['GET'])
def get_notifications():
    """
    Le but de cet app se resume a cette fonction, elle recoit une requete
    http et renvoie via le websocket le contenu de la requette a tout les 
    client.
    """
    token = request.values.get("token")
    con = sqlite3.connect("database.db")
    cur = con.cursor()
    notifications = cur.execute("SELECT title,content \
                                 FROM NOTIFICATION \
                                 WHERE token=?",
                                (token, )).fetchall()
    data = {"status": "ok"}
    data["notifications"] = []
    for notification in notifications:
        data["notifications"].append({"title": notification[0],"content": notification[1]})
    return data, 200


@app.route("/notification/<notifid>", methods=['GET'])
def get_notification_by_id(notifid):
    """
    Le but de cet app se resume a cette fonction, elle recoit une requete
    http et renvoie via le websocket le contenu de la requette a tout les 
    client.
    """
    notifid = int(notifid)
    token = request.values.get("token")
    con = sqlite3.connect("database.db")
    cur = con.cursor()
    if notifid == -1:
        notifications = cur.execute("SELECT title,content \
                                     FROM NOTIFICATION \
                                     WHERE token=?\
                                     ORDER BY id DESC \
                                     LIMIT 1",
                                    (token,)).fetchone()
    else:
        notifications = cur.execute("SELECT title,content \
                                     FROM NOTIFICATION \
                                     WHERE token=? AND id=?",
                                    (token, notifid)).fetchone()
    
    return {"status": "ok",
            "notifications": {"title": notifications[0],
                              "content": notifications[1]
                              }
            }, 200

###############################################################################


@app.route("/clipboard", methods=['PUT'])
def add_clipboard():
    """
    Le but de cet app se resume a cette fonction, elle recoit une requete http
    et renvoie via le websocket le contenu de la requette a tout les clients.
    """
    token = request.values.get("token")
    content = request.values.get('content')
    device_name = request.values.get('deviceName')
    date = time.time()
    con = sqlite3.connect("database.db")
    cur = con.cursor()
    if cur.execute("SELECT username FROM USERS WHERE token=?", (token,))\
            .fetchone() is None:
        return {"status": "Error, no user"}, 500
    try:
        clipboard = (date, device_name, token, content)
        cur.execute("INSERT INTO CLIPBOARD VALUES (null,?,?,?,?)", clipboard)
        con.commit()
        con.close()
        socketio.emit("ClipboardUpdate",
                      data={"device_name": device_name},
                      broadcast=True)
        return {"status": "ok"}, 200
    except:
        return {"status": "error"}, 500


@app.route("/clipboard", methods=['GET'])
def get_clipboard():
    """
    Le but de cet app se resume a cette fonction, elle recoit une requete
    http et renvoie via le websocket le contenu de la requette a tout les
    client.
    """
    token = request.values.get("token")
    con = sqlite3.connect("database.db")
    cur = con.cursor()
    clipboard = cur.execute("SELECT content \
                             FROM CLIPBOARD \
                             WHERE token=?", 
                            (token, )).fetchall()
    
    return {"status": "ok", "clipboard": clipboard}, 200


@app.route("/clipboard/<clipid>", methods=['GET'])
def get_clipboard_by_id(clipid):
    """
    Le but de cet app se resume a cette fonction, elle recoit une requete
    http et renvoie via le websocket le contenu de la requette a tout les
    client.
    """
    clipid = int(clipid)
    token = request.values.get("token")
    con = sqlite3.connect("database.db")
    cur = con.cursor()
    if clipid == -1:
        clipboard = cur.execute("SELECT content \
                                 FROM CLIPBOARD \
                                 WHERE token=? \
                                 ORDER BY id DESC \
                                 LIMIT 1",
                                (token,)).fetchone()
    else:
        clipboard = cur.execute("SELECT content \
                                 FROM CLIPBOARD \
                                 token=? AND id=?",
                                (token, clipid)).fetchone()
        
    return {"status": "ok", "clipboard": clipboard[0]}, 200


if __name__ == '__main__':
    try:
        f=open("database.db","r")
        f.close()
    except :
        first_run()
    socketio.run(app, host="0.0.0.0", port=9564)