# -*- coding: utf-8 -*-

import errno
import glob
import os
import sqlite3

from tornado.httpserver import HTTPServer
from tornado.ioloop import IOLoop
from tornado.options import define, options
from tornado.web import Application, RequestHandler, StaticFileHandler


define('host', default='127.0.0.1', help='run on the given host', type=str)
define('port', default=8001, help='run on the given port', type=int)
options.parse_command_line()


ROOT_PATH = '/tmp/minipai2'

# Create Table SQL
CREATE_TABLE_STMT = """
    CREATE TABLE IF NOT EXISTS photoinfo (
    id integer primary key,
    lensman varchar(20),
    session varchar(20),
    name varchar(13)
);"""
# Create Index SQL
CREATE_INDEX1 = 'CREATE INDEX IF NOT EXISTS idx_lensman ON photoinfo (lensman);'
CREATE_INDEX2 = 'CREATE INDEX IF NOT EXISTS idx_session ON photoinfo (session);'
# Insert Record SQL
INSERT_RECORD_STMT = 'INSERT INTO photoinfo VALUES (NULL, ?, ?, ?);'
# Delete Record SQL
DELETE_RECORD_STMT = 'DELETE FROM photoinfo WHERE lensman = ? and session = ? and name = ?;'
# Query Max(name) SQL
SELECT_RECORD_STMT = 'SELECT MAX(name) FROM photoinfo WHERE lensman = ? and session = ?;'


conn = sqlite3.connect('minipai2.db')
cur = conn.cursor()
# 执行语句
cur.execute(CREATE_TABLE_STMT)
cur.execute(CREATE_INDEX1)
cur.execute(CREATE_INDEX2)
conn.commit()


# FILE OPERATE
def silent_makdirs(path):
    try:
        os.makedirs(path)
    except OSError as e:
        if e.errno != errno.EEXIST:
            raise


def silent_remove(path):
    try:
        os.remove(path)
    except OSError as e:
        if e.errno != errno.ENOENT:
            raise


def get_session_root(lensman, session):
    return '{}/{}'.format(ROOT_PATH, session)


def get_session_dir(lensman, session):
    session_root = get_session_root(lensman, session)
    return '{}/{}'.format(session_root, 'origin'), '{}/{}'.format(session_root, 'thumbnail')


def create_session_dir(lensman, session):
    for path in get_session_dir(lensman, session):
        silent_makdirs(path)


def get_last_timestamp(lensman, session):
    cur.execute(SELECT_RECORD_STMT, (lensman, session))
    result = cur.fetchall()
    return int(result[0][0] or 0)


def insert_session_file(lensman, session, name):
    cur.execute(INSERT_RECORD_STMT, (lensman, session, name))
    conn.commit()


def delete_session_file(lensman, session, name):
    cur.execute(DELETE_RECORD_STMT, (lensman, session, name))
    conn.commit()


def get_new_files(lensman, session, maxt):
    _, thumb = get_session_dir(lensman, session)
    files = glob.iglob('{}/*'.format(thumb))
    news = []
    for file in files:
        filename = file.split('/')[-1]
        name = filename.split('.')[0]
        if int(name) > maxt:
            insert_session_file(lensman, session, name)
            news.append({
                'id': name,
                'name': filename,
                'path': file.strip(ROOT_PATH),
            })
    return news


def print_qrcode(lensman, session):
    # Call ``C`` to Connect Printer
    # Param
    #   :: session
    pass


class HelloHandler(RequestHandler):
    def get(self):
        self.write('Hello Tornado')


class SessionStartHandler(RequestHandler):
    def post(self):
        lensman = self.get_argument('lensman', '')
        session = self.get_argument('session', '')

        # Create Session Dir
        create_session_dir(lensman, session)
        # Change Mode to 0777
        os.chmod(get_session_root(lensman, session), 0777)

        self.write({
            'status': 200,
        })


class SessionEndHandler(RequestHandler):
    def post(self):
        lensman = self.get_argument('lensman', '')
        session = self.get_argument('session', '')

        # Change Mode to 0700
        os.chmod(get_session_root(lensman, session), 0700)
        # Print QRCode
        print_qrcode(lensman, session)

        self.write({
            'status': 200,
        })


class FetchThumbnailHandler(RequestHandler):
    def post(self):
        lensman = self.get_argument('lensman', '')
        session = self.get_argument('session', '')

        maxt = get_last_timestamp(lensman, session)
        files = get_new_files(lensman, session, maxt)

        self.write({
            'status': 200,
            'data': {
                'files': files
            }
        })


class FetchOriginHandler(RequestHandler):
    def post(self):
        lensman = self.get_argument('lensman', '')
        session = self.get_argument('session', '')

        name = self.get_argument('name', '')

        origin, _ = get_session_dir(lensman, session)

        self.write({
            'status': 200,
            'data': {
                'path': '{}/{}'.format(origin, name).strip(ROOT_PATH)
            }
        })


class DeletePhotoHandler(RequestHandler):
    def post(self):
        lensman = self.get_argument('lensman', '')
        session = self.get_argument('session', '')

        id_ = self.get_argument('id', '')
        name = self.get_argument('name', '')
        path = self.get_argument('path', '')

        # Delete Record from Sqlite3
        delete_session_file(lensman, session, id_)

        # Delete Photo from Disk
        origin, thumb = get_session_dir(lensman, session)
        # Delete Thumbnail
        silent_remove('{}/{}'.format(thumb, name))
        # Delete Origin
        silent_remove('{}/{}'.format(origin, name))

        self.write({
            'status': 200,
        })


class PrintQRCodeHandler(RequestHandler):
    def post(self):
        lensman = self.get_argument('lensman', '')
        session = self.get_argument('session', '')

        # Print QRCode
        print_qrcode(lensman, session)

        self.write({
            'status': 200,
        })


handlers = [
    (r'/', HelloHandler),
    (r'/session_start', SessionStartHandler),
    (r'/session_end', SessionEndHandler),
    (r'/fetch_thumbnail', FetchThumbnailHandler),
    (r'/fetch_origin', FetchOriginHandler),
    (r'/delete_photo', DeletePhotoHandler),
    (r'/print_qrcode', PrintQRCodeHandler),
    (r'/static/(.*)', StaticFileHandler, {'path': ROOT_PATH}),
]


def main():
    app = Application(handlers=handlers, default_host=options.host)
    server = HTTPServer(app)
    server.listen(options.port)
    IOLoop.current().start()


if __name__ == '__main__':
    main()