#!/usr/bin/env python

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

import gnucash

import datetime

import logging

ZERO = gnucash.GncNumeric()

def recurse_all_splits(account):

    for acc in account.get_descendants():

        for split in acc.GetSplitList():

            yield split

def check_in_date(start_date, end_date, d):

    return start_date <= d and d <= end_date

def check_split_date_func(start_date, end_date):

    def f(split):

        parent = split.GetParent()

        if parent == None:

            return False

        d = datetime.date.fromtimestamp(split.GetParent().GetDate())

        return start_date <= d and d <= end_date

    return f

def generate_splits(root, start, end):

    f = check_split_date_func(start, end)

    return (split for split in recurse_all_splits(root) if f(split))

def generate_summary_amounts(root, start, end):

    prevAccount = None

    prevAccountName = "<None>"

    zero = (0, ZERO, ZERO)

    pos = zero

    neg = zero

    for split in generate_splits(root, start, end):

        account = split.account

        amount = split.GetAmount()

        value = split.GetValue()

        name = account.get_full_name()

        is_neg = amount.negative_p()

        if account.get_full_name() != prevAccountName:

            if prevAccount != None:

                yield (prevAccount,) + pos

                yield (prevAccount,) + neg

            prevAccount = account

            prevAccountName = name

            if is_neg:

                pos = zero

                neg = (1, amount, value)

            else:

                pos = (1, amount, value)

                neg = zero

        else:

            tmp = neg if is_neg else pos

            tmp = (tmp[0]+1,

                   tmp[1].add(amount, gnucash.GNC_DENOM_AUTO, gnucash.GNC_HOW_DENOM_EXACT),

                   tmp[2].add(value, gnucash.GNC_DENOM_AUTO, gnucash.GNC_HOW_DENOM_EXACT))

            if is_neg:

                neg = tmp

            else:

                pos = tmp

    if prevAccount != None:

        yield (prevAccount,) + pos

        yield (prevAccount,) + neg

def transaction_to_string(trans, currency):

    result = str(datetime.date.fromtimestamp(trans.GetDate()))

    result += " " + trans.GetDescription() + "\n"

    for split in trans.GetSplitList():

        result += "\t" + split.account.get_full_name() + " "

        result += " "

        c = split.account.GetCommodity()

        a = split.GetAmount()

        result += str(a.to_double()) + " " + c.get_nice_symbol()

        if not currency.equal(c):

            v = split.GetValue()

            result += " => " + str(v.to_double()) + " " + currency.get_nice_symbol()

            result += " ( " + str(v.div(a, gnucash.GNC_DENOM_AUTO, gnucash.GNC_HOW_DENOM_EXACT).to_double())

            result += " " + c.get_nice_symbol() + " )"

        result += "\n"

    imbl = trans.GetImbalanceValue()

    result += "Balance: " + str(imbl.to_double()) + " " + currency.get_nice_symbol()

    if not imbl.equal(ZERO):

        for c, v in trans.GetImbalance():

            result += "\n\t"

            result += " => " + str(v.to_double()) + " " + c.get_nice_symbol() 

    return result

def delete_transactions(root, start, end, filt):

    removed = 0

    for split in generate_splits(root, start, end):

        t = split.GetParent()

        if filt(t):

            removed += t.CountSplits()

            t.Destroy()

    logging.info("%d splits removed.", removed)

def transaction_not_equal_p(trans):

    gtrans = trans.GetGUID()        

    def f(t):

        return not gtrans.equal(t.GetGUID())

    return f

def generate_summary_splits(root, start, end):

    book = root.get_book()

    for account, count, amount, value in generate_summary_amounts(root, start, end):

        if not amount.zero_p():

            split = gnucash.Split(book)

            split.SetAccount(account)

            price = value.div(amount, gnucash.GNC_DENOM_AUTO, gnucash.GNC_HOW_DENOM_EXACT)

            split.SetSharePriceAndAmount(price, amount)

            yield split, count

def create_summary(root, start, end, currency, title):

    logging.info("Creating summary %s for %s between %s and %s",

                 title, root.get_full_name(), start, end)

    book = root.get_book()

    trans = gnucash.Transaction(book)

    trans.BeginEdit()

    trans.SetDate(end.day, end.month, end.year)

    trans.SetDescription(title)

    trans.SetCurrency(currency)

    total = 0

    for split, count in generate_summary_splits(root, start, end):

        split.SetParent(trans)

        total += count

    if trans.CountSplits() > 0:

        logging.info("%d splits summary into one transaction '%s'.", total, title)

        logging.debug(transaction_to_string(trans, currency))

        assert(trans.IsBalanced())

        trans.CommitEdit()

    if total > 0:

        delete_transactions(root, start, end, transaction_not_equal_p(trans))

    else:

        logging.info("No splits found for this date")

def make_summary(root, currency, start, end, title):

    create_summary(root, start, end, currency, title)

def lookup_currency(book, currency):

    return book.get_table().lookup("CURRENCY", currency)

## Datetime support

ONEDAY = datetime.timedelta(days=1)

def first_day_of_month(d):

    return datetime.date(d.year, d.month, 1)

def first_day_of_year(d):

    return datetime.date(d.year, 1, 1)

def next_day(d):

    return d + ONEDAY

def next_month(d):

    if d.month == 12:

        return datetime.date(d.year+1, 1, 1)

    else:

        return datetime.date(d.year, d.month + 1, 1)

def next_year(d):

    return datetime.date(d.year + 1, 1, 1)

def datetime_iter(start, end, next_f):

    d = start

    while end == None or d < end:

        yield d

        d = next_f(d)

def datetime_iter_range(start, end, next_f):

    for d in datetime_iter(start, end, next_f):

        yield d, next_f(d) - ONEDAY

def day_iter(start, end=None):

    return (d for d in datetime_iter(start, end, next_day))

def month_iter(start, end=None):

    return (d for d in datetime_iter(first_day_of_month(start), end, next_month))

def year_iter(start, end=None):

    return (d for d in datetime_iter(first_day_of_year(start), end, next_year))

def day_range_iter(start, end=None):

    return ((d,d) for d in datetime_iter(start, end, next_day))

def month_range_iter(start, end=None):

    return (d for d in datetime_iter_range(first_day_of_month(start), end, next_month))

def year_range_iter(start, end=None):

    return (d for d in datetime_iter_range(first_day_of_year(start), end, next_year))

def main(filename, title, currency, daterange):

    try:

        session = gnucash.Session(filename, is_new=False)

        root = session.book.get_root_account()

        curr = lookup_currency(session.book, currency)

        for s, e in daterange:

            make_summary(root, curr, s, e, title)

        session.save()

        session.end()

    except:

        logging.exception("Exception occured")

    finally:

        if 'session' in locals():

            session.destroy()

def usage(msg):

    import sys

    print msg

    print "Usage:", sys.argv[0], \

        "filename.gnc", "transaction_title", "currency", \

        "yearly|monthly|daily", \

        "start_year start_month start_day", \

        "end_year end_month end_day"

    exit(-1)

if __name__ == '__main__':

    # logging.basicConfig(level=logging.DEBUG)

    import sys

    if len(sys.argv) != 11:

        usage("Invalid number of arguments")

        exit(-1)

    cmd, filename, title, currency, period, syear, smonth, sday, eyear, emonth, eday = sys.argv

    start = datetime.date(int(syear), int(smonth), int(sday))

    end = datetime.date(int(eyear), int(emonth), int(eday))

    if period == "daily":

        daterange = day_range_iter(start, end)

    elif period == "monthly":

        daterange = month_range_iter(start, end)

    elif period == "yearly":

        daterange = year_range_iter(start, end)

    else:

        usage("Invalid period '%s'" % (period,))

    main(filename, title, currency, daterange)