#! /usr/bin/env python3

"""

Name: 

Author: Eugen Sawin <sawine@me73.com>

"""

import socketserver

import logging

import os

import os.path

import shelve

import json

import re

import urllib.request

import subprocess

import time

from operator import itemgetter

from urllib.parse import urlparse

from urllib.request import urlopen

from tempfile import NamedTemporaryFile

from http.server import BaseHTTPRequestHandler, HTTPServer

from pseudoword import Database

try:

    from argparse import ArgumentParser

except ImportError:

    from external.argparse import ArgumentParser

ENCODING = 'utf-8'

def parse_args():

    parser = ArgumentParser(description='')

    parser.add_argument('-p', type=int, default=8080, help='port')

    parser.add_argument('-a', default='localhost', help='host address')

    parser.add_argument('-l', default='log/server.log', help='log file')

    parser.add_argument('-w', default='data/names', help='word database')

    parser.add_argument('-d', default='httpdocs', help='http docs path')

    parser.add_argument('--pid', default=None, help='pid file')

    return parser.parse_args()	

def main():       

    args = parse_args()

    logging.basicConfig(filename=args.l, level=logging.DEBUG,

                        format='[%(levelname)s@%(asctime)s] %(message)s',

                        datefmt='%d.%m.%Y %I:%M:%S')

    if args.pid:

        with open(args.pid, 'w') as f:

            f.write(str(os.getpid()))

    db = Database(args.w)

    server = Server(args.a, args.p, args.d, db, GetHandler)

    server.run()

class GetHandler(BaseHTTPRequestHandler):

    def do_GET(self):

        request = Request(self.path, self.server.docs_path, self.server.db)

        logging.info('Request: %s' % request)

        code, content_type, data = request()

        self.send_response(code)       

        self.send_header('Content-type', content_type)

        self.end_headers()

        self.wfile.write(data)

    def log_message(self, format, *args):

        pass

class Server(HTTPServer):

    def __init__(self, host, port, docs_path, db, handler):

        HTTPServer.__init__(self, (host, port), handler)

        self.host = host

        self.port = port

        self.docs_path = docs_path

        self.db = db

    def run(self):

        logging.info('Server ready and listening at port {0}.'.format(self.port))

        self.serve_forever()

class Request:    

    @classmethod

    def _content_type(cls, doc):

        if doc.endswith('.html'):

            return 'text/html'

        elif doc.endswith('.css'):

            return 'text/css'

        elif doc.endswith('.js'):

            return 'application/javascript'

        elif doc.endswith('.ttf'):           

            return 'application/octet-stream'

        else:            

            return 'text/plain'

    def __init__(self, query, docs_path, db):       

        self.docs_path = docs_path

        self.db = db

        self.parsed = urlparse(query)

        self.args = dict()

        if len(self.parsed.query):

            self.args = dict([a.split('=') for a in self.parsed.query.split('&')])

        if self.parsed.path[1:] in commands:

            self.__class__ = commands[self.parsed.path[1:]]

        else:

            self.__class__ = WebRequest     

            self.args['doc'] = self.parsed.path    

    def __str__(self):

        return '{0}({1})'.format(str(self.__class__).partition('.')[-1].rstrip('">'),

                           ', '.join(['{0}: {1}'.format(k, str(v))

                                      for k, v in self.args.items()]))

def client_rating(rating):

    return int(rating * 1000)

class WordsRequest(Request):

    def __call__(self):   

        w1, w2 = self.db.pick_words()    

        data = '{{"words":[["{w1}", {r1}], ["{w2}", {r2}]]}}'.format(w1=w1[0],

                                                                     r1=w1[1], 

                                                                     w2=w2[0],

                                                                     r2=w2[1])

        return (200, 'application/javascript', bytes(data, ENCODING))

class RateRequest(Request):

    def __call__(self):

        w3 = self.args['bn']

        w4 = self.args['wn']

        w3, w4 = self.db.rate(w3, w4)

        w1, w2 = self.db.pick_words()

        data = '{{"words":[["{w1}",{r1}],["{w2}",{r2}],'.format(w1=w1[0], r1=client_rating(w1[1]), 

                                                                   w2=w2[0], r2=client_rating(w2[1]))

        data += '["{w3}",{r3}],["{w4}",{r4}]]}}'.format(w3=w3[0], r3=client_rating(w3[1]), 

                                                           w4=w4[0], r4=client_rating(w4[1]))

        return (200, 'application/javascript', bytes(data, ENCODING))

commands = {'words': WordsRequest,

            'rate': RateRequest}

class WebRequest(Request):

    def __call__(self):

        if self.args['doc'] == '/':

            self.args['doc'] = '/index.html'

        content_type = self._content_type(self.args['doc'])

        data = bytes('', ENCODING)

        rel_path = self.docs_path + self.args['doc']

        if os.path.exists(rel_path):

            with open(rel_path, 'r+b') as f:

                data = f.read()

            code = 200

        else:

            code = 404

        return (code, content_type, data)

if __name__ == '__main__':

	main()