/*
 * Copyright (c) 2003-2009, John Wiegley.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 *
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 *
 * - Neither the name of New Artisans LLC nor the names of its
 *   contributors may be used to endorse or promote products derived from
 *   this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "report.h"
#include "iterators.h"
#include "filters.h"
#include "chain.h"
#include "output.h"
#include "precmd.h"

namespace ledger {

report_t::report_t(session_t& _session) : session(_session)
{
  // Setup default values for some of the option handlers
  HANDLER(date_format_).on("%y-%b-%d");

  HANDLER(register_format_).on(
    "%-.9(display_date) %-.20(payee)"
    " %-.23(truncate(account, 23, 2))"
    " %!12(print_balance(strip(display_amount), 12, 67))"
    " %!12(print_balance(strip(display_total), 12, 80, true))\n%/"
    "%31|%-.23(truncate(account, 23, 2))"
    " %!12(print_balance(strip(display_amount), 12, 67))"
    " %!12(print_balance(strip(display_total), 12, 80, true))\n");

  // jww (2009-02-06): Most of these still need to be defined
  HANDLER(wide_register_format_).on(
    "%-.9D  %-.35P %-.39A %22.108t %!22.132T\n%/"
    "%48|%-.38A %22.108t %!22.132T\n");

  HANDLER(print_format_).on(
    "%(display_date)%(entry.cleared ? \" *\" : (entry.uncleared ? \"\" : \" !\"))"
    "%(code ? \" (\" + code + \")\" : \"\") %(payee)%(entry.comment | \"\")\n"
    "    %(cleared ? \" *\" : (uncleared ? \"\" : \" !\"))%-34(account)"
    "  %12(amount)%(comment | \"\")\n%/"
    "    %(cleared ? \" *\" : (uncleared ? \"\" : \" !\"))%-34(account)"
    "  %12(amount)%(comment | \"\")\n%/\n");

  HANDLER(balance_format_).on(
    "%20(strip(display_total))  %(depth_spacer)%-(partial_account)\n");

  HANDLER(equity_format_).on("\n%D %Y%C%P\n%/    %-34W  %12t\n");
  HANDLER(plot_amount_format_).on("%D %(S(t))\n");
  HANDLER(plot_total_format_).on("%D %(S(T))\n");
  HANDLER(write_hdr_format_).on("%d %Y%C%P\n");
  HANDLER(write_xact_format_).on("    %-34W  %12o%n\n");
  HANDLER(prices_format_).on("%[%Y/%m/%d %H:%M:%S %Z]   %-10A %12t %12T\n");
  HANDLER(pricesdb_format_).on("P %[%Y/%m/%d %H:%M:%S] %A %t\n");
}

void report_t::xacts_report(xact_handler_ptr handler)
{
  session_xacts_iterator walker(session);
  pass_down_xacts(chain_xact_handlers(*this, handler), walker);
  session.clean_xacts();
}

void report_t::entry_report(xact_handler_ptr handler, entry_t& entry)
{
  entry_xacts_iterator walker(entry);
  pass_down_xacts(chain_xact_handlers(*this, handler), walker);
  session.clean_xacts(entry);
}

void report_t::sum_all_accounts()
{
  session_xacts_iterator walker(session);
  pass_down_xacts
    (chain_xact_handlers(*this, xact_handler_ptr(new set_account_value), false),
     walker);

  session.master->calculate_sums(HANDLER(amount_).expr, *this);
}

void report_t::accounts_report(acct_handler_ptr handler)
{
  sum_all_accounts();

  if (! HANDLED(sort_)) {
    basic_accounts_iterator walker(*session.master);
    pass_down_accounts(handler, walker,
		       item_predicate<account_t>("total", what_to_keep()));
  } else {
    sorted_accounts_iterator walker(*session.master, HANDLER(sort_).str());
    pass_down_accounts(handler, walker,
		       item_predicate<account_t>("total", what_to_keep()));
  }
    
  session.clean_xacts();
  session.clean_accounts();
}

void report_t::commodities_report(const string& format)
{
}

value_t report_t::fn_amount_expr(call_scope_t& scope)
{
  return HANDLER(amount_).expr.calc(scope);
}

value_t report_t::fn_total_expr(call_scope_t& scope)
{
  return HANDLER(total_).expr.calc(scope);
}

value_t report_t::fn_display_amount(call_scope_t& scope)
{
  return HANDLER(display_amount_).expr.calc(scope);
}

value_t report_t::fn_display_total(call_scope_t& scope)
{
  return HANDLER(display_total_).expr.calc(scope);
}

namespace {
  value_t fn_market_value(call_scope_t& args)
  {
    var_t<datetime_t> date(args, 1);
    var_t<string>	    in_terms_of(args, 2);

    commodity_t * commodity = NULL;
    if (in_terms_of)
      commodity = amount_t::current_pool->find_or_create(*in_terms_of);

    DEBUG("report.market", "getting market value of: " << args[0]);

    value_t result =
      args[0].value(date ? optional<datetime_t>(*date) : optional<datetime_t>(),
		    commodity ? optional<commodity_t&>(*commodity) :
		    optional<commodity_t&>());

    DEBUG("report.market", "result is: " << result);
    return result;
  }

  value_t fn_print_balance(call_scope_t& args)
  {
    report_t& report(find_scope<report_t>(args));

    var_t<long>	first_width(args, 1);
    var_t<long>	latter_width(args, 2);
#if 0
    var_t<bool>	bold_negative(args, 3);
#endif

    std::ostringstream out;
    args[0].strip_annotations(report.what_to_keep())
      .print(out, *first_width, *latter_width,
	     report.HANDLED(date_format_) ?
	     report.HANDLER(date_format_).str() : optional<string>());

    return string_value(out.str());
  }

  value_t fn_strip(call_scope_t& args)
  {
    report_t& report(find_scope<report_t>(args));
    return args[0].strip_annotations(report.what_to_keep());
  }

  value_t fn_truncate(call_scope_t& args)
  {
    report_t& report(find_scope<report_t>(args));

    var_t<long>	width(args, 1);
    var_t<long>	account_abbrev(args, 2);

    return string_value(format_t::truncate(args[0].as_string(), *width,
					   account_abbrev ? *account_abbrev : -1));
  }

  value_t fn_display_date(call_scope_t& args)
  {
    report_t& report(find_scope<report_t>(args));
    item_t&   item(find_scope<item_t>(args));

    // jww (2009-02-06): Should we be calling reported_date here?

    date_t when;
    if (report.HANDLED(effective)) {
      if (optional<date_t> date = item.effective_date())
	when = *date;
      else
	when = item.date();
    } else {
      when = item.date();
    }

    if (report.HANDLED(date_format_))
      return string_value(format_date(when,
				      report.HANDLER(date_format_).str()));
    else
      return string_value(format_date(when));
  }

  template <class Type        = xact_t,
	    class handler_ptr = xact_handler_ptr,
	    void (report_t::*report_method)(handler_ptr) =
	      &report_t::xacts_report>
  class reporter
  {
    shared_ptr<item_handler<Type> > handler;

  public:
    reporter(item_handler<Type> * _handler)
      : handler(_handler) {}

    value_t operator()(call_scope_t& args)
    {
      report_t& report(find_scope<report_t>(args));

      if (args.value().size() > 0)
	report.append_predicate
	  (args_to_predicate_expr(args.value().as_sequence().begin(),
				  args.value().as_sequence().end()));

      DEBUG("report.predicate",
	    "Predicate = " << report.HANDLER(limit_).str());

      (report.*report_method)(handler_ptr(handler));

      return true;
    }
  };
}

#if 0
// Commands yet to implement:
//
// entry
// prices
// pricesdb
// csv
// emacs | lisp
#endif

expr_t::ptr_op_t report_t::lookup(const string& name)
{
  const char * p = name.c_str();
  switch (*p) {
  case 'a':
    METHOD(report_t, amount_expr);
    break;

  case 'c':
    if (WANT_CMD()) { p += CMD_PREFIX_LEN;
      switch (*p) {
      case 'b':
	if (*(p + 1) == '\0' ||
	    std::strcmp(p, "bal") == 0 ||
	    std::strcmp(p, "balance") == 0)
	  return expr_t::op_t::wrap_functor
	    (reporter<account_t, acct_handler_ptr, &report_t::accounts_report>
	     (new format_accounts(*this, HANDLER(balance_format_).str())));
	break;

      case 'e':
	if (std::strcmp(p, "equity") == 0)
	  return expr_t::op_t::wrap_functor
	    (reporter<account_t, acct_handler_ptr, &report_t::accounts_report>
	     (new format_equity(*this, HANDLER(print_format_).str())));
	break;

      case 'p':
	if (*(p + 1) == '\0' || std::strcmp(p, "print") == 0)
	  return WRAP_FUNCTOR
	    (reporter<>(new format_xacts(*this, HANDLER(print_format_).str())));
	break;

      case 'r':
	if (*(p + 1) == '\0' ||
	    std::strcmp(p, "reg") == 0 ||
	    std::strcmp(p, "register") == 0)
	  return WRAP_FUNCTOR
	    (reporter<>(new format_xacts(*this, HANDLER(register_format_).str())));
	break;
      }
    }
    break;

  case 'd':
    METHOD(report_t, display_total);
    else METHOD(report_t, display_amount);
    else FUNCTION(display_date);
    break;

  case 'm':
    FUNCTION(market_value);
    break;

  case 'o':
    if (WANT_OPT()) { p += OPT_PREFIX_LEN;
      switch (*p) {
      case 'a':
	OPT(amount_);
	else OPT(anon);
	else OPT(account_);
	else OPT(abbrev_len_);
	break;

      case 'b':
	OPT_(begin_);
	else OPT(base);
	else OPT(by_payee);
	break;

      case 'c':
	OPT_(current);
	else OPT(collapse);
	else OPT(cleared);
	else OPT(cost);
	else OPT(comm_as_payee);
	else OPT(code_as_payee);
	break;

      case 'd':
	OPT(daily);
	else OPT(dow);
	else OPT(date_format_);
	break;

      case 'e':
	OPT_(end_);
	else OPT(empty);
	else OPT(effective);
	break;

      case 'f':
	OPT(format_);
	break;

      case 'h':
	OPT(head_);
	break;

      case 'i':
	OPT(invert);
	break;

      case 'j':
	OPT_CH(amount_data);
	break;

      case 'l':
	OPT_(limit_);
	break;

      case 'm':
	OPT(monthly);
	else OPT(market);
	break;

      case 'n':
	OPT_CH(collapse);
	break;

      case 'o':
	OPT_(output_);
	break;

      case 'p':
	OPT_(period_);
	else OPT(period_sort_);
	else OPT(price);
	else OPT(pager_);
	break;

      case 'q':
	OPT(quarterly);
	else OPT(quantity);
	break;

      case 'r':
	OPT_(related);
	else OPT_(related_all);
	break;

      case 's':
	OPT_(subtotal);
	else OPT(sort_);
	else OPT(sort_all_);
	else OPT(sort_entries_);
	break;

      case 't':
	OPT_CH(amount_);
	else OPT(total_);
	else OPT(totals);
	else OPT(tail_);
	break;

      case 'u':
	OPT(uncleared);
	break;

      case 'w':
	OPT(weekly);
	break;

      case 'x':
	OPT_CH(comm_as_payee); // jww (2009-02-05): ???
	break;

      case 'y':
	OPT_CH(date_format_);
	else OPT(yearly);
	break;

      case 'B':
	OPT_CH(cost);
	break;
      case 'C':
	OPT_CH(cleared);
	break;
      case 'E':
	OPT_CH(empty);
	break;
      case 'F':
	OPT_CH(format_);
	break;
      case 'I':
	OPT_CH(price);
	break;
      case 'J':
	OPT_CH(total_data);
	break;
      case 'M':
	OPT_CH(monthly);
	break;
      case 'O':
	OPT_CH(quantity);
	break;
      case 'P':
	OPT_CH(by_payee);
	break;
      case 'S':
	OPT_CH(sort_);
	break;
      case 'T':
	OPT_CH(total_);
	break;
      case 'U':
	OPT_CH(uncleared);
	break;
      case 'V':
	OPT_CH(market);
	break;
      case 'W':
	OPT_CH(weekly);
	break;
      case 'Y':
	OPT_CH(yearly);
	break;
      }
    }
    break;

  case 'p':
    if (WANT_PRECMD()) { p += PRECMD_PREFIX_LEN;
      switch (*p) {
      case 'a':
	COMMAND(args);
	break;
      case 'p':
	COMMAND(parse);
	else COMMAND(period);
	break;
      case 'e':
	COMMAND(eval);
	break;
      case 'f':
	COMMAND(format);
	break;
      }
    }
    else FUNCTION(print_balance);
    break;

  case 's':
    FUNCTION(strip);
    break;

  case 't':
    FUNCTION(truncate);
    else METHOD(report_t, total_expr);
    break;
  }

  return session.lookup(name);
}

} // namespace ledger