#!/usr/bin/env python3.7
import csv
from datetime import datetime
from itertools import chain
from pathlib import Path
import sys

import click
import requests
from peewee import fn, JOIN

from .db import db, HamsterCategory, HamsterActivity, HamsterFact, KimaiCustomer, KimaiProject, KimaiActivity, HamsterKimaiMapping

HAMSTER_DIR = Path.home() / '.local/share/hamster'
# HAMSTER_FILE = HAMSTER_DIR / 'hamster.db'
HAMSTER_FILE = 'hamster-testing.db'

db.init(HAMSTER_FILE)


@click.group()
def cli():
    pass


@cli.group()
def categories():
    pass


@categories.command('list')
@click.option('--search', help='Search string')
def list_categories(search):
    """ List / search categories  """
    categories = HamsterCategory.select()

    if search is not None:
        categories = categories.where(HamsterCategory.name.contains(search))

    for c in categories:
        click.echo(f'@{c.id}: {c.name}')


@categories.command('delete')
@click.argument('ids', nargs=-1)
def delete_categories(ids):
    """ Delete categories specified by IDS """
    click.secho('Deleting:', fg='red')

    categories = HamsterCategory.select(
        HamsterCategory,
        fn.Count(HamsterActivity.id).alias("activities_count")
    ).join(HamsterActivity, JOIN.LEFT_OUTER).group_by(HamsterCategory).where(HamsterCategory.id.in_(ids))

    for c in categories:
        click.echo(f'@{c.id}: {c.name} ({c.activities_count} activities)')

    click.confirm('Do you want to continue?', abort=True)

    count = HamsterCategory.delete().where(HamsterCategory.id.in_(ids)).execute()

    click.secho('Deleted {0} categories'.format(count), fg='green')


@categories.command('rename')
@click.argument('id_', metavar='ID')
@click.argument('name')
def rename_category(id_, name):
    """ Rename a category """

    category = HamsterCategory.get(id=id_)

    click.echo(f'Renaming @{category.id}: {category.name} to "{name}"')

    category.name = name
    category.save()


@categories.command('activities')
@click.argument('ids', nargs=-1)
def list_category_activities(ids):
    """ Show activities for categories specified by ids """

    activities = HamsterActivity.select(
        HamsterActivity,
        HamsterCategory.name
    ).join(HamsterCategory, JOIN.LEFT_OUTER).where(HamsterCategory.id.in_(ids))

    for a in activities:
        click.echo(f'@{a.id}: {a.category.name} » {a.name}')



@categories.command('tidy')
def tidy_categories():
    """ Remove categories with no activities """

    # Create a subquery to calculate the count of activities per category
    subquery = (
        HamsterCategory
        .select(HamsterCategory, fn.COUNT(HamsterActivity.id).alias('activities_count'))
        .join(HamsterActivity, JOIN.LEFT_OUTER)
        .group_by(HamsterCategory)
        .alias('subquery')
    )

    # Use the subquery to filter categories where activities_count is 0
    categories = (
        HamsterCategory
        .select()
        .join(subquery, on=(HamsterCategory.id == subquery.c.id))
        .where(subquery.c.activities_count == 0)
    )

    click.echo('Found {0} empty categories:'.format(categories.count()))

    for cat in categories:
        click.echo(f'@{cat.id}: {cat.name}')

    click.confirm('Do you want to continue?', abort=True)

    [cat.delete_instance() for cat in categories]


@cli.group()
def activities():
    pass


@activities.command('list')
@click.option('--search', help='Search string')
@click.option('--csv/--no-csv', 'csv_output', default=False, help='CSV output')
def list_activities(search, csv_output):
    """ List / search activities """

    activities = HamsterActivity.select(
        HamsterActivity,
        HamsterCategory
    ).join(HamsterCategory, JOIN.LEFT_OUTER).order_by(
        HamsterCategory.name,
        HamsterActivity.name
    )

    if search is not None:
        activities = activities.where(HamsterActivity.name.contains(search))

    if csv_output:
        csv_writer = csv.writer(sys.stdout)

    for a in activities:
        category_name = a.category.name if a.category_id != -1 else ""
        if csv_output:
            csv_writer.writerow([
                a.category_id,
                category_name,
                a.id,
                a.name
            ])
        else:
            click.echo(f'@{a.category_id}: {category_name} » {a.id}: {a.name}')


@activities.command('delete')
@click.argument('ids', nargs=-1)
def delete_activities(ids):
    """ Delete activities specified by IDS """

    activities = HamsterActivity.select(
        HamsterActivity,
        HamsterCategory.name,
        fn.Count(HamsterFact.id).alias("facts_count")
    ).join(HamsterCategory,
           JOIN.LEFT_OUTER).switch(HamsterActivity).join(HamsterFact,
                                                         JOIN.LEFT_OUTER).group_by(HamsterActivity).where(
        HamsterActivity.id.in_(ids)
    )

    click.secho('Deleting:', fg='red')

    for a in activities:
        category_name = a.category.name if a.category_id != -1 else ""
        click.echo(f'@{a.id}: {category_name} » {a.name} ({a.facts_count} facts)')

    click.confirm('Do you want to continue?', abort=True)

    [a.delete_instance() for a in activities]

    click.secho('Deleted {0} activities'.format(len(ids)), fg='green')


@activities.command()
@click.argument('category_id')
@click.argument('ids', nargs=-1)
def move(category_id, ids):
    """ Move activities to another category """
    category = HamsterCategory.get(id=category_id)
    activities = HamsterActivity.select().where(HamsterActivity.id.in_(ids))

    click.secho(f'Moving to "@{category.id}: {category.name}":', fg='green')

    for a in activities:
        category_name = a.category.name if a.category_id != -1 else ""
        click.secho(f'@{a.category_id}: {category_name} » @{a.id}: {a.name}', fg='blue')

    click.confirm('Do you want to continue?', abort=True)

    for a in activities:
        a.category = category
        a.save()

    click.secho('Moved {0} activities'.format(len(ids)), fg='green')


@activities.command()
@click.argument('ids', nargs=-1)
def list_facts(ids):
    """ Show facts for activities """
    activities = HamsterActivity.select().where(HamsterActivity.id.in_(ids))

    for a in activities:
        click.secho(
            f'@{a.id}: {a.name}', fg='green'
        )

        for f in a.facts:
            click.secho(f'@{f.id}, {f.start_time}', fg='blue')


@activities.command()
@click.argument('from_id')
@click.argument('to_id')
def move_facts(from_id, to_id):
    """ Move facts from one activity to another """
    from_activity = HamsterActivity.get(id=from_id)
    to_activity = HamsterActivity.get(id=to_id)

    from_category_name = from_activity.category.name if from_activity.category_id != -1 else ""
    to_category_name = to_activity.category.name if to_activity.category_id != -1 else ""

    click.secho(
        f'Moving facts from "{from_category_name} » @{from_activity.id}: {from_activity.name}" to "@{to_category_name} » @{to_activity.id}: {to_activity.name}"', fg='green'
    )

    for f in from_activity.facts:
        click.secho(f'@{f.id}, {f.start_time}', fg='blue')

    click.confirm('Do you want to continue?', abort=True)

    count = HamsterFact.update(activity_id=to_activity.id).where(HamsterFact.activity == from_activity).execute()

    click.secho('Moved {0} facts'.format(count), fg='green')

    click.confirm(
        f'Would you like to delete "{from_category_name} » @{from_activity.id}: {from_activity.name}?',
        abort=True
    )

    from_activity.delete_instance()


@activities.command()
def find_duplicates():
    """ Show activities which are not unique in their categories """

    non_unique_activities = (
        HamsterActivity
        .select(
            HamsterActivity,
            HamsterCategory.id,
            fn.COALESCE(HamsterCategory.name, 'None').alias("category_name")
        )
        .join(HamsterCategory, JOIN.LEFT_OUTER)
        .group_by(HamsterActivity.category_id, HamsterActivity.name)
        .having(fn.COUNT(HamsterActivity.id) > 1)
    )

    for activity in non_unique_activities:
        click.secho(
            f"@{activity.category_id}: {activity.category_name} » @{activity.id}: {activity.name}", fg='blue')


@cli.group()
def kimai():
    pass


def _get_kimai_mapping_file(path, category_search=None):
    try:
        return open(path)
    except FileNotFoundError:
        click.confirm(
            'Mapping file {} not found, create it?:'.format(path),
            abort=True
        )
        mapping_file = open(path, 'w')
        mapping_writer = csv.writer(mapping_file)

        mapping_writer.writerow([
            'FROM category',
            'FROM activity',
            'TO Customer',
            'TO Project',
            'TO Activity',
            'TO Tag',
            'TO Note'
        ])

        activities = HamsterActivity.select(
            HamsterActivity,
            HamsterCategory
        ).join(HamsterCategory, JOIN.LEFT_OUTER)

        for a in activities:
            mapping_writer.writerow([
                a.category.name if a.category_id != -1 else "",
                a.name
            ])

        mapping_file.close()
        return open(path)


@kimai.command()
@click.option('--mapping-path', help='Mapping file (default ~/.local/share/hamster/mapping.kimai.csv)', multiple=True)
@click.argument('username')
@click.argument('api_key')
@click.option('--just-errors', 'just_errors', is_flag=True, help='Only display errors')
@click.option('--ignore-activities', is_flag=True, help='Ignore missing activities')
def sync(username, api_key, just_errors, ignore_activities, mapping_path=None):
    """
    Download customer / project / activity data from Kimai
    """

    kimai_api_url = 'https://kimai.autonomic.zone/api'

    if type(mapping_path) == tuple:
        mapping_files = []
        for mapping_path_item in mapping_path:
            mapping_file = _get_kimai_mapping_file(mapping_path_item)
            next(mapping_file)
            mapping_files.append(mapping_file)
        mapping_reader = csv.reader(chain(*mapping_files))
    else:
        if mapping_path is None:
            mapping_path = HAMSTER_DIR / 'mapping.kimai.csv'
        mapping_file = _get_kimai_mapping_file(mapping_path)
        mapping_reader = csv.reader(mapping_file)

    next(mapping_reader)

    mapping_data = [
        [row[2], row[3], row[4]]
        for row in mapping_reader
    ]

    mapping_file.close()

    auth_headers = {
        'X-AUTH-USER': username,
        'X-AUTH-TOKEN': api_key
    }

    customers = requests.get(
        f'{kimai_api_url}/customers?visible=3', headers=auth_headers).json()
    projects = requests.get(
        f'{kimai_api_url}/projects?visible=3', headers=auth_headers).json()
    activities = requests.get(
        f'{kimai_api_url}/activities?visible=3', headers=auth_headers).json()

    found_customers = []
    found_projects = []
    found_activities = []

    for row in mapping_data:
        # Check if each mapping still exists in Kimai

        matching_customers = list(
            filter(lambda x: x['name'] == row[0], customers))
        if row[0] in found_customers:
            just_errors or click.secho(
                "Skipping existing customer '{0}'".format(row[0]), fg='green')
        else:
            if len(matching_customers) > 1:
                click.secho(
                    "More than one match for customer '{0}'".format(row[0]), fg='red')
                continue
            elif len(matching_customers) < 1:
                click.secho("Missing customer '{0}'".format(
                    row[0]), fg='yellow')
                continue
            else:
                just_errors or click.secho(
                    "Found customer '{0}'".format(row[0]), fg='green')
                found_customers.append(row[0])

        project_str = ':'.join(row[0:2])
        matching_projects = list(filter(
            lambda x: x['name'] == row[1] and
            x['customer'] == matching_customers[0]['id'],
            projects)
        )

        if project_str in found_projects:
            just_errors or click.secho(
                "Skipping existing project '{0}'".format(project_str), fg='green')
        else:
            if len(matching_projects) > 1:
                click.secho("More than one match for project '{0}'".format(
                    project_str), fg='red')
                continue
            elif len(matching_projects) < 1:
                click.secho("Missing project '{0}'".format(
                    project_str), fg='yellow')
                continue
            else:
                just_errors or click.secho(
                    "Found project '{0}'".format(project_str), fg='green')
                found_projects.append(project_str)

        if ignore_activities:
            continue

        activity_str = ':'.join(row)
        if activity_str in found_activities:
            just_errors or click.secho(
                "Skipping existing activity '{0}'".format(activity_str), fg='green')
        else:
            matching_activities = list(filter(
                lambda x: x['name'] == row[2]
                and x['project'] == matching_projects[0]['id'],
                activities
            ))

            if len(matching_activities) > 1:
                click.secho("More than one match for activity '{0}'".format(
                    activity_str), fg='red')
            elif len(matching_activities) < 1:
                click.secho("Missing activity '{0}'".format(
                    activity_str), fg='yellow')
            else:
                just_errors or click.secho(
                    "Found activity '{0}'".format(activity_str), fg='green')
                found_activities.append(activity_str)


@kimai.command('import')
@click.option('--mapping-path', help='Mapping file (default ~/.local/share/hamster/mapping.kimai.csv)', multiple=True)
@click.option('--output', help='Output file (default kimai.csv)')
@click.option('--category-search', help='Category search string')
@click.option('--after', help='Only show time entries after this date')
@click.option('--show-missing', help='Just report on the missing entries', is_flag=True)
@click.argument('username')
def _import(username, mapping_path=None, output=None, category_search=None, after=None, show_missing=False):
    """
    Export time tracking data in Kimai format
    """

    if mapping_path is None:
        mapping_path = HAMSTER_DIR / 'mapping.kimai.csv'

    if output is None:
        timestamp = datetime.now().strftime('%F')
        output = f'kimai_{timestamp}.csv'

    if type(mapping_path) == tuple:
        mapping_files = []
        for mapping_path_item in mapping_path:
            mapping_file = _get_kimai_mapping_file(mapping_path_item, category_search)
            next(mapping_file)
            mapping_files.append(mapping_file)
        mapping_reader = csv.reader(chain(*mapping_files))
    else:
        mapping_file = _get_kimai_mapping_file(mapping_path, category_search)
        next(mapping_file)
        mapping_reader = csv.reader(mapping_file)

    mapping = {
        '{0}:{1}'.format(row[0], row[1]): [row[2], row[3], row[4], row[5]]
        for row in mapping_reader
    }

    if type(mapping_path) == tuple:
        for mapping_file in mapping_files:
            mapping_file.close()
    else:
        mapping_file.close()

    output_file = open(output, 'w')
    output_writer = csv.writer(output_file)

    args = []

    facts = HamsterFact.select(
        HamsterFact,
        HamsterActivity,
        HamsterCategory
    ).join(HamsterActivity).join(HamsterCategory, JOIN.LEFT_OUTER)

    sql = '''
    SELECT
        facts.id, facts.start_time, facts.end_time, facts.description,
        activities.id, activities.name,
        categories.name, categories.id
    FROM
        facts
    LEFT JOIN
        activities ON facts.activity_id = activities.id
    LEFT JOIN
        categories ON activities.category_id = categories.id '''

    if category_search is not None:
        facts = facts.where(HamsterCategory.name.contains(category_search))

    if after is not None:
        facts = facts.where(HamsterFact.start_time >= after)

    if not show_missing:
        output_writer.writerow([
            "Date",
            "From",
            "To",
            "Duration",
            "Rate",
            "User",
            "Customer",
            "Project",
            "Activity",
            "Description",
            "Exported",
            "Tags",
            "HourlyRate",
            "FixedRate",
            "InternalRate"
        ])

    for fact in facts:
        k = f'{fact.activity.category.name}:{fact.activity.name}'
        try:
            mapping_ = mapping[k]
        except KeyError:
            if show_missing:
                output_writer.writerow([fact.activity.category.name, fact.activity.name])
            click.secho(
                "Can't find mapping for '{0}', skipping".format(k), fg='yellow')
            continue

        if show_missing:
            continue

        if fact.start_time is None or fact.end_time is None:
            click.secho(f"Missing duration data '{fact.start_time}-{fact.end_time}', skipping", fg='yellow')
            continue

        if len(mapping_) < 5:
            mapping_.append(None)

        date_start, date_end = (
            datetime.strptime(fact.start_time.split('.')[0], '%Y-%m-%d %H:%M:%S'),
            datetime.strptime(fact.end_time.split('.')[0], '%Y-%m-%d %H:%M:%S')
        )
        duration = (
            date_start - date_end
        ).seconds / 3600

        output_writer.writerow([
            date_start.strftime('%Y-%m-%d'),
            date_start.strftime('%H:%M'),
            '',  # To (time)
            duration,
            '',  # Rate
            username,
            mapping_[0],
            mapping_[1],
            mapping_[2],
            fact.description or mapping_[4] or '',
            '0',  # Exported
            mapping_[3],
            '',  # Hourly rate
            '',  # Fixed rate
        ])

    output_file.close()


@kimai.group('db')
def db_():
    pass


@db_.command()
def init():
    db.create_tables([KimaiCustomer, KimaiProject, KimaiActivity,
                      HamsterKimaiMapping])


@db_.command()
def reset():
    HamsterKimaiMapping.delete().execute()


@db_.command()
@click.option('-g', '--global', 'global_', help='Does this file contain mappings to global activties', is_flag=True)
@click.option('--mapping-path', help='Mapping file')
def import_csv(mapping_path=None, global_=False):
    mapping_file = _get_kimai_mapping_file(mapping_path, None)
    next(mapping_file)
    mapping_reader = csv.reader(mapping_file)
    
    for row in mapping_reader:
        hamster_category = HamsterCategory.get(name=row[0])
        hamster_activity = HamsterActivity.get(name=row[1])
        kimai_customer = KimaiCustomer.get(name=row[2])
        kimai_project = KimaiProject.get(name=row[3],
                                         customer_id=kimai_customer.id)
        try:
            kimai_activity = KimaiActivity.get(
                name=row[4],
                project_id=kimai_project.id
            )
        except KimaiActivity.DoesNotExist:
            kimai_activity = KimaiActivity.get(
                name=row[4],
            )

        HamsterKimaiMapping.create(
            hamster_activity=hamster_activity,
            kimai_customer=kimai_customer,
            kimai_project=kimai_project,
            kimai_activity=kimai_activity,
            kimai_description=row[6],
            kimai_tags=row[5]
        )


@cli.command()
def app():
    from .app import HamsterToolsApp
    app = HamsterToolsApp()
    app.run()


@cli.command()
def hamster():
    click.echo('🐹')


if __name__ == "__main__":
    cli()