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

from action import record_action
from action import TypeAction
import project

from args import get_string_arg
from args import arg_number

class Note:
    def __init__(self):
        self.message = None

def handle_note(args, last_action, conn):
    logging.info('> handle note')
    logging.debug('args: ' + str(args))

    if not args:
        list_note(last_action.project_id, last_action.task_id, last_action.note_id, conn)
        sys.exit(0)

    if args[0] == '-c':
        if len(args) == 1:
            print('missing note message')
            sys.exit(1)

        note = Note()
        note.message = get_string_arg(args[1:], 'note message')
        create_note(note, last_action.project_id, last_action.task_id, conn)
    elif args[0] == '-e':
        if len(args) == 1:
            print('nothing to update')

        note = Note()
        args_i = 1
        note_id = last_action.note_id
        if args[args_i].isdigit():
            note_id = arg_number(args[args_i])
            args_i += 1

        if not note_id:
            print('No active note to update')
            sys.exit(1)

        note.message = get_string_arg(args[args_i:], 'note message')
        edit_note(note, note_id, last_action, conn)
    elif args[0] == '-d':
        # FIXME Duplicate code
        if len(args) > 1:
            delete_note(arg_number(args[1]), conn)
        else:
            delete_note(last_action.task_id, conn)
    else:
        print(f'Invalid note option: {args[0]}')

def create_note(note, active_project_id, active_task_id, conn):
    # TODO Don't create note if no project (nothing selected?) ==> foreign key is not a solution: there is no project ID :)
    logging.info('>> Create note')

    query = """
    INSERT INTO note (project_id, task_id, username, message)
    VALUES (?, ?, ?, ?);
    """

    cursor = conn.cursor()
    cursor.execute(query, (active_project_id, active_task_id, getpass.getuser(), note.message))

    note_id = cursor.lastrowid

    action_message = '{} (task: {})'.format(note.message, active_task_id)
    record_action(cursor, TypeAction.CREATE, action_message, active_project_id, active_task_id, note_id)
    logging.debug(action_message)

    print('created note {}: {} (task {})'.format(note_id, note.message, active_task_id))

def edit_note(note, note_id, last_action, conn):
    logging.info('>> Edit note')

    query = 'UPDATE note SET message = ? WHERE id = ?'

    cursor = conn.cursor()
    cursor.execute(query, (note.message, note_id,))

    if cursor.rowcount != 1:
        logging.error('UPDATE FAILED')
        print('could not find note {}'.format(note_id))
        sys.exit(1)

    record_action(cursor, TypeAction.UPDATE, note.message, last_action.project_id,
        last_action.task_id, last_action.note_id)

    print('updated note {}: (message: {}, task {})'.format(note_id, note.message, last_action.task_id))

def delete_note(note_id, conn):
    logging.info('>> Remove note')

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

    cursor = conn.cursor()
    cursor.execute(query, (note_id,))
    if cursor.rowcount != 1:
        logging.error('DELETE FAILED')
        print('could not find note {}'.format(note_id))
        sys.exit(1)

    record_action(cursor, TypeAction.DELETE, 'delete note')

    print('deleted note {}: {}'.format(note_id, 'note_name'))

def list_note(active_project_id, active_task_id, active_note_id, conn):
    logging.info('>> No arguments')
    query = "SELECT id, username, message FROM note WHERE project_id = ? AND task_id = ?;" #TODO Date & time

    cursor = conn.cursor()
    cursor.execute(query, (active_project_id, active_task_id))
    for row in cursor.fetchall():
        note_id, username, message = row
        print('{:1} {:2d}: ({:8}) {}'.format('*' if active_note_id == note_id else '', note_id, username, message))