#! /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')

     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')

     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()