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

import project
import action
import task
import note

# logging.basicConfig(level=logging.ERROR, format='%(levelname)7s :: %(message)s')
# logging.basicConfig(level=logging.DEBUG, format='%(asctime)s :: %(levelname)s :: %(message)s')
logging.basicConfig(level=logging.ERROR, format='%(asctime)s :: {%(filename)10s:%(lineno)3d} :: %(funcName)s :: %(levelname)s :: %(message)s')

DB_FILENAME = 'pits.db'
SCHEMA_FILENAME = 'pits_schema.sql'

def get_file_path(file_name):
    return os.path.join(os.path.dirname(os.path.realpath(__file__)), file_name)


def strstr(haystack, needle):
    pos = haystack.find(needle)
    if pos < 0: # not found
        return None
    else:
        return haystack[pos:]

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

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

def create_connection(db_filename):
    db_path = get_file_path(db_filename)
    logging.debug("Try to connect to {}".format(db_path))
    try:
        conn = sqlite3.connect(db_path)
        return conn
    except Error as e:
        print(e)

    return None

def init():
    # TODO Use init command like original pit
    db_path = get_file_path(DB_FILENAME)

    logging.debug('Search database in {}'.format(db_path))
    db_is_new = not os.path.exists(db_path)
    if not db_is_new:
        print('Database already exist')
        # TODO Permit to override
        return

    with sqlite3.connect(db_path) as conn:
        logging.info('Creating schema')
        schema_path = get_file_path(SCHEMA_FILENAME)
        logging.debug('Schema file path: {}'.format(schema_path))

        with open(schema_path, 'rt') as f:
            schema = f.read()
        conn.executescript(schema)

        action_query = '''
            INSERT INTO action (username, action, message)
            VALUES (?, ?, ?);
        '''
        conn.execute(action_query, (getpass.getuser(), 'init', 'Initialized pit',)) # TODO Add schema version

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

def version(args, last_action, conn):
    print('TODO version')
    # TODO version

def help(args, last_action, conn):
    print('TODO help')
    # TODO help

if __name__ == '__main__':
    command = [ 'project', 'task', 'note', 'log', 'info', 'help', 'version', 'init' ]
    handler = [
        project.handle_project,
        task.handle_task,
        note.handle_note,
        action.handle_action,
        info,
        help,
        version]
    candidate = -1

    argv = sys.argv

    if len(argv) == 1:
        argv.append('help')
        argv.append(None)

    for i in range(len(command)):
        if strstr(command[i], argv[1]) == command[i]:
            if candidate < 0:
                candidate = i
            else:
                print('Ambiguous command ({})'.format(argv[1]))
                sys.exit(1)

    if candidate < 0:
        print("Invalid command ({}), run '{} help' for help".format(argv[1], os.path.basename(__file__)))
        sys.exit(1)

    if candidate == (len(command) -1):
        init()
        sys.exit(0)

    conn = create_connection(DB_FILENAME)
    last_action = action.read_last_action(conn)
    logging.debug('Last action: {}'.format(last_action))
    logging.debug(argv)
    logging.debug(argv[2:])
    handler[candidate](argv[2:], last_action, conn)

    conn.commit()
    conn.close()