import sqlite3
import os
import argparse
import json
import getpass
import datetime
import logging

# logging.basicConfig(level=logging.DEBUG, format='%(asctime)s :: %(levelname)s :: %(message)s')
logging.basicConfig(level=logging.DEBUG, format='%(levelname)7s :: %(message)s')

def info():
    logging.info('info function')

def help(args, last_action):
    logging.info('help function')

def handle_project(args, last_action):
    logging.info('> handle project')
    logging.debug('args: args')

    status = 'active'
    if args.status:
        status = args.status

    do_something = False

    if args.create_name:
        do_something = True
        # TODO Project is same name is forbidden
        logging.info('>> Create project')

        query = """
        INSERT INTO project (username, name, status, created_at)
        VALUES (?, ?, ?, ?);
        """

        with sqlite3.connect(db_filename) as conn:
            cursor = conn.cursor()
            cursor.execute(query, (getpass.getuser(), args.create_name, status, datetime.datetime.now(),))

            project_id = cursor.lastrowid

            create_action(cursor, project_id=project_id)

            print('created project {}: {} (status: {})'.format(project_id, args.create_name, status))
    if args.delete_id:
        do_something = True
        logging.info('>> Remove project')

        query = """
        DELETE FROM project
        WHERE id = ?;
        """

        with sqlite3.connect(db_filename) as conn:
            cursor = conn.cursor()
            cursor.execute(query, (args.delete_id,))
            if cursor.rowcount != 1:
                logging.error('DELETE FAILED')
            print('deleted project {}: {}'.format(args.delete_id, 'project_name'))
    if args.edit_id:
        do_something = True
        logging.info('>> Edit project')

        update_args = {}
        if args.status:
            update_args['status'] = args.status
        if args.edit_name:
            update_args['name'] = args.edit_name

        query = 'UPDATE project SET {} WHERE id = ?'
        query = query.format(', '.join("%s = '%s'" % (k, v) for k, v in update_args.items()))
        logging.debug('update project query: ' + query)

        with sqlite3.connect(db_filename) as conn:
            cursor = conn.cursor()
            if update_args:
                logging.debug('Do a project update')
                cursor.execute(query, (args.edit_id,))

            create_action(cursor, args.edit_id, message = 'update ' + str(update_args))

    if not do_something:
        logging.info('>> No arguments')
        query = "SELECT id, username, name, status, created_at FROM project;"
        current_project = ' '
        with sqlite3.connect(db_filename) as conn:
            cursor = conn.cursor()
            cursor.execute(query)
            for row in cursor.fetchall():
                project_id, username, name, status, date = row
                nb_task = 0
                if last_action and last_action[0] == project_id:
                    current_project = '*'
                print('{} {:2d}: ({:16}) | {} | {} ({} tasks )'.format(current_project, project_id, username, status, name, nb_task))
                # TODO Print creation date

        # desired output
        #created project 3: toto (status: active)

def handle_note(args):
    logging.info('>> handle note')

def handle_action(args, last_action):
    logging.info('>> handle action')
    query = 'SELECT * FROM action;'
    with sqlite3.connect(db_filename) as conn:
        cursor = conn.cursor()
        cursor.execute(query)
        for row in cursor.fetchall():
            result = row
            logging.debug(result)

def create_action(cursor, project_id = '', task_id = '', note_id = '', message = ''):
    query = """
        INSERT INTO action (project_id, task_id, note_id, username, message, created_at)
        VALUES (?, ?, ?, ?, ?, ?);
        """

    cursor.execute(query, (project_id, task_id, note_id, getpass.getuser(), message, datetime.datetime.now(),))

    logging.debug('created action')

def read_last_action():
    logging.info('> last_action')
    # query = 'SELECT * FROM action WHERE id = (SELECT MAX(id) FROM action'
    # query = 'SELECT project_id, task_id, note_id FROM action'
    query = 'SELECT project_id, task_id, note_id FROM action ORDER BY created_at DESC LIMIT 1;'

    with sqlite3.connect(db_filename) as conn:
        cursor = conn.cursor()
        cursor.execute(query)
        logging.debug('DEEEEEEEEBU')
        last_action = cursor.fetchone()
        logging.debug(last_action)
    return last_action

db_filename = 'pits.db'
schema_filename = 'pit_schema.sql'

# TODO Use init command like original pit
# TODO Need to add an action - log init
db_is_new = not os.path.exists(db_filename)

with sqlite3.connect(db_filename) as conn:
    if db_is_new:
        logging.info('Creating schema')
        with open(schema_filename, 'rt') as f:
            schema = f.read()
        conn.executescript(schema)

        # logging.info('Inserting initial data')
        # conn.executescript("""
        # insert into project values(1, 'me', 'test', 'in progress', 'now', 'now')""")

parser = argparse.ArgumentParser()
parser.set_defaults(func=help)

subparsers = parser.add_subparsers()

# PROJECT ARGS PARSER
parser_project = subparsers.add_parser('project')#, usage='toto')
group_project = parser_project.add_mutually_exclusive_group()
group_project.add_argument('-c', type=str, dest='create_name', metavar='name', help='name of project')
group_project.add_argument('-e', type=int, dest='edit_id', metavar='number', help='Edit a project')
group_project.add_argument('-d', type=int, dest='delete_id', nargs='?', const=-1, metavar='number', help='Delete a project')
parser_project.add_argument('-n', type=str, dest='edit_name', metavar='name', help='Edit: new name of project')
parser_project.add_argument('-s', type=str, dest='status', metavar='status')
parser_project.add_argument('-q', type=int)
parser_project.set_defaults(func=handle_project)

parser_note = subparsers.add_parser('note')
parser_note.add_argument('-c', type=str)
parser_note.add_argument('-e', type=int)
parser_note.add_argument('-d', type=int)
parser_note.set_defaults(func=handle_note)

parser_action = subparsers.add_parser('action')
parser_action.set_defaults(func=handle_action)

parser.add_argument('--version', action='version', version='%(prog)s 1.0')

args = parser.parse_args()

last_action = read_last_action()
logging.debug('Last action: {}'.format(last_action))

args.func(args, last_action)