#!/usr/bin/python3

import os

os.chdir(os.path.dirname(os.path.abspath(__file__)))

import sys

if len(sys.argv) == 2 and sys.argv[1] == "daemon":

    sys.stdout = open('log/server.log', 'a')

    sys.stderr = sys.stdout

import config

import game

import template

import json

import threading

import http.server

import urllib.parse

class Server(http.server.BaseHTTPRequestHandler):

    def write(self, *texts):

        for text in texts:

            self.wfile.write(bytes(str(text), "utf8"))

    def parsePath(self, path):

        if not path.startswith(config.prefix):

            return None

        path = path[len(config.prefix):]

        if len(path) and path[0] != '/':

            return None

        return list(filter(None, path.split("/")))

    def err(self, code = 404, message = ""):

        self.send_response(int(code))

        self.send_header("Content-type", "text/html")

        self.end_headers()

        tplErrorpage.write(self, {

            "host": config.externalHost,

            "prefix": config.prefix,

            "code": int(code),

            "message": str(message),

            "waiting": False });

    def writeJpeg(self, path):

        if not path.endswith(".jpg") or not os.path.isfile(path):

            return self.err()

        with open(path, "rb") as f:

            self.send_response(200)

            self.send_header("Content-type", "image/jpeg")

            self.send_header("Cache-Control", "max-age=3600")

            self.end_headers()

            self.wfile.write(f.read())

    def writeStatus(self, player):

        self.send_response(200)

        self.send_header("Content-type", "text/html")

        self.end_headers()

        self.write(json.dumps(player.status()))

    def do_POST(self):

        if self.command != 'POST':

            return self.err()

        path = self.parsePath(self.path)

        if path is None:

            return self.err()

        length = int(self.headers.get('content-length'))

        data = self.rfile.read(length)

        fields = urllib.parse.parse_qs(str(data,"UTF-8"))

        word = str(fields.get("word", [""])[0])

        vocabulary = str(fields.get("vocabulary", [""])[0])

        with mutex:

            if not path: # create new game

                if not vocabulary in game.words:

                    return self.err()

                g = game.Game(vocabulary, word)

                self.send_response(303)

                self.send_header("Location", str(config.prefix) + "/" + str(g.players[0].id))

                self.end_headers()

                return

            player = game.players.get(path[0], None)

            if not player:

                return self.err()

            del path[0]

            if not path:

                player.join(word)

            elif len(path) == 2 and path[0] == "select":

                i = -1

                try:

                    i = int(path[1])

                except ValueError:

                    return self.err()

                player.select(i)

            elif len(path) == 1 and path[0] == "ready":

                player.nextturn(word)

            else:

                return self.err()

            self.send_response(303)

            self.send_header("Location", str(config.prefix) + "/" + str(player.id))

            self.end_headers()

    def do_GET(self):

        #loadTemplates()

        if self.command != 'GET':

            return self.err()

        if self.path.startswith(config.cardsPrefix):

            p = str(self.path[len(config.cardsPrefix):])

            if p and p[0] == "/":

                if p.count("/") > 1 or p.count("..") > 0:

                    return self.err()

                return self.writeJpeg("cards" + p)

        path = self.parsePath(self.path)

        if path is None:

            return self.err()

        if not path:

            self.send_response(200)

            self.send_header("Content-type", "text/html")

            self.end_headers()

            tplStartpage.write(self, {

                "host": config.externalHost,

                "prefix": config.prefix,

                "vocabularies": list(sorted(game.words.keys())),

                "waiting": False });

            return

        with mutex:

            if len(path) != 1:

                return self.err()

            j = False

            if path[0].endswith(".json"):

                j = True

                path[0] = path[0][0:-5]

            player = game.players.get(path[0], None)

            if not player:

                return self.err()

            if j:

                return self.writeStatus(player)

            self.send_response(200)

            self.send_header("Content-type", "text/html")

            self.end_headers()

            if player.game.started:

                tplPlayerpage.write(self, player.status());

            else:

                tplJoinpage.write(self, player.status());

def loadTemplates():

    global tplStartpage, tplJoinpage, tplPlayerpage, tplErrorpage

    tplStartpage = template.TplLoader.load("tpl/startpage.tpl")

    tplJoinpage = template.TplLoader.load("tpl/joinpage.tpl")

    tplPlayerpage = template.TplLoader.load("tpl/playerpage.tpl")

    tplErrorpage = template.TplLoader.load("tpl/errorpage.tpl")

mutex = threading.Lock()

loadTemplates()

game.mergeCards("cards")

game.mergeWords("words")

webServer = http.server.HTTPServer((

    config.hostName,

    config.serverPort ), Server )

print("Server started http://%s:%s" % (

    config.hostName,

    config.serverPort ))

try:

    webServer.serve_forever()

except KeyboardInterrupt:

    pass

webServer.server_close()

print("Server stopped.")