<?php
class StatementEntry extends AppModel {

	var $belongsTo = array(
		'Transaction',
		'Customer',
		'Lease',
		'Account',

		// The charge to which this payment applies (if it is one)
		'ChargeEntry' => array(
			'className' => 'StatementEntry',
		),
	);

	var $hasMany = array(
		// The payments that apply to this charge (if it is one)
		'PaymentEntry' => array(
			'className' => 'StatementEntry',
			'foreignKey' => 'charge_entry_id',
		),

	);

	var $default_log_level = 30;

  /**************************************************************************
   **************************************************************************
   **************************************************************************
   * function: chargePaymentFields
   */


  function chargePaymentFields($sum = false, $entry_name = 'StatementEntry') {
    $fields = array
      (
       ($sum ? 'SUM(' : '') .
       "IF({$entry_name}.type = 'CHARGE'," .
       "   {$entry_name}.amount, NULL)" .
       ($sum ? ')' : '') . ' AS charge' . ($sum ? 's' : ''),

       ($sum ? 'SUM(' : '') .
       "IF({$entry_name}.type = 'PAYMENT' OR {$entry_name}.type = 'SURPLUS'," .
       "   {$entry_name}.amount, NULL)" .
       ($sum ? ')' : '') . ' AS payment' . ($sum ? 's' : ''),

       ($sum ? 'SUM(' : '') .
       "IF({$entry_name}.type = 'CHARGE', 1, -1)" .
       " * IF({$entry_name}.amount, {$entry_name}.amount, 0)" .
       ($sum ? ')' : '') . ' AS balance',
       );

    if ($sum)
      $fields[] = "COUNT({$entry_name}.id) AS entries";

    return $fields;
  }


  /**************************************************************************
   **************************************************************************
   **************************************************************************
   * function: verifyStatementEntry
   *  - Verifies consistenty of new statement entry data
   *    (not in a pre-existing statement entry)
   */
  function verifyStatementEntry($entry) {
    $this->prFunctionLevel(10);
    $this->prEnter(compact('entry'));

    if (empty($entry['type']) ||
	//empty($entry['effective_date']) ||
	empty($entry['account_id']) ||
	empty($entry['amount'])
	) {
      return $this->prExit(false);
    }

    return $this->prExit(true);
  }


  /**************************************************************************
   **************************************************************************
   **************************************************************************
   * function: addStatementEntry
   *  - Inserts new Statement Entry into the database
   */
  function addStatementEntry($entry) {
    $this->prEnter(compact('entry'));

    $ret = array();
    if (!$this->verifyStatementEntry($entry))
      return array('error' => true, 'verify_data' => $entry) + $ret;

    $this->pr(20, array('checkpoint' => 'Pre-Save')
	      + compact('entry'));

    $this->create();
    if (!$this->save($entry))
      return array('error' => true, 'save_data' => $entry) + $ret;

    $ret['statement_entry_id'] = $this->id;
    return $this->prExit($ret + array('error' => false));
  }


  /**************************************************************************
   **************************************************************************
   **************************************************************************
   * function: reverse
   *  - Reverses the charges
   *
   * SAMPLE MOVE IN w/ PRE PAYMENT
   * DEPOSIT   RENT      A/R    RECEIPT   CHECK    PETTY    BANK
   * -------  -------  -------  -------  -------  -------  -------
   *    |25      |      25|        |        |        |        |    
   *    |        |20    20|        |        |        |        |    
   *    |        |20    20|        |        |        |        |    
   *    |        |20    20|        |        |        |        |    
   *    |        |        |25    25|        |        |        |     
   *    |        |        |20    20|        |        |        |     
   *    |        |        |20    20|        |        |        |     
   *    |        |        |20    20|        |        |        |     
   *    |        |        |        |85    85|        |        |     
   *    |        |        |        |        |85      |      85|     

   * MOVE OUT and REFUND FINAL MONTH
   * DEPOSIT   RENT      C/P    RECEIPT   CHECK    PETTY    BANK
   * -------  -------  -------  -------  -------  -------  -------
   *  25|        |        |25      |        |        |        |    t20   e20a
   *    |      20|        |20      |        |        |        |    t20   e20b

   * -ONE REFUND CHECK-
   *    |        |      25|        |25      |        |        |    t30   e30a
   *    |        |      20|        |20      |        |        |    t30   e30b
   *    |        |        |      45|        |        |        |45  t40   e40
   * -OR MULTIPLE-
   *    |        |      15|        |15      |        |        |    t50a  e50a
   *    |        |        |      15|        |        |15      |    t60a  e60a
   *    |        |      30|        |30      |        |        |    t50b  e50b
   *    |        |        |      30|        |        |        |30  t60b  e60b
   *    |        |        |        |        |        |        |     


OPTION 1
   *    |-25     |     -25|        |        |        |        |     
   *    |        |-20  -20|        |        |        |        |     
   *    |        |        |-25  -25|        |        |        |     
   *    |        |        |-20  -20|        |        |        |     

OPTION 2
   *    |-25     |        |     -25|        |        |        |     
   *    |        |-20     |     -20|        |        |        |     
   *    |        |        |        |-15     |     -15|        |    
   *    |        |        |        |-30     |        |     -30|    
   *    |        |        |        |        |        |        |     
   *
   */
  function reverse($ledger_entries, $stamp = null) {
    $this->prEnter(compact('ledger_entries', 'stamp'));

    // If the user only wants to reverse one ID, we'll allow it
    if (!is_array($ledger_entries))
      $ledger_entries = $this->find
	('all', array
	 ('contain' => false,
	  'conditions' => array('Entry.id' => $ledger_entries)));

    $A = new Account();

    $ar_account_id = $A->accountReceivableAccountID();
    $receipt_account_id = $A->receiptAccountID();

    $transaction_id = null;
    foreach ($ledger_entries AS $entry) {
      $entry = $entry['Entry'];
      $amount = -1*$entry['amount'];

      if (isset($entry['credit_account_id']))
	$refund_account_id = $entry['credit_account_id'];
      elseif (isset($entry['CreditLedger']['Account']['id']))
	$refund_account_id = $entry['CreditLedger']['Account']['id'];
      elseif (isset($entry['credit_ledger_id']))
	$refund_account_id = $this->Ledger->accountID($entry['credit_ledger_id']);
      else
	return $this->prExit(null);

      // post new refund in the income account
      $ids = $A->postEntry
	(array('transaction_id' => $transaction_id),
	 null,
	 array('debit_ledger_id' => $A->currentLedgerID($ar_account_id),
	       'credit_ledger_id' => $A->currentLedgerID($refund_account_id),
	       'effective_date' => $entry['effective_date'],
	       'through_date' => $entry['through_date'],
	       'amount' => $amount,
	       'lease_id' => $entry['lease_id'],
	       'customer_id' => $entry['customer_id'],
	       'comment' => "Refund; Entry #{$entry['id']}",
	       ),
	 array('debit'  => array
	       (array('Entry' =>
		      array('id' => $entry['id'],
			    'amount' => $amount))),
	       )
	 );

      if ($ids['error'])
	return $this->prExit(null);
      $transaction_id = $ids['transaction_id'];

      $this->pr(15, compact('ids', 'amount', 'refund_account_id', 'ar_account_id'),
		'Posted Refund Ledger Entry');
    }

    return $this->prExit(true);
  }


  /**************************************************************************
   **************************************************************************
   **************************************************************************
   * function: reconciledSet
   *  - Returns the set of entries satisfying the given conditions,
   *    along with any entries that they reconcile
   */
  function reconciledSetQuery($set, $query) {
    $this->queryInit($query);

    if ($set == 'CHARGE' || $set == 'PAYMENT')
      $query['conditions'][] = array('StatementEntry.type' => $set);
    else
      die("INVALID RECONCILE SET");

    if ($set == 'CHARGE')
      $query['link']['PaymentEntry'] = array('fields' => array("SUM(PaymentEntry.amount) AS reconciled"));
    if ($set == 'PAYMENT')
      $query['link']['ChargeEntry'] = array('fields' => array("SUM(ChargeEntry.amount) AS reconciled"));

    $query['group'] = 'StatementEntry.id';

    // REVISIT: TESTING
    //$query['link']['PaymentEntry'] = array('fields' => array("(`PaymentEntry.amount`+0) AS reconciled"));
    //$query['group'] = null;
    // END REVISIT

    return $query;
  }

  function reconciledSet($set, $query = null, $unrec = false) {
    $this->prEnter(compact('set', 'query', 'unrec'));
    $lquery = $this->reconciledSetQuery($set, $query);
    $result = $this->find('all', $lquery);

    $this->pr(20, compact('lquery', 'result'));

    $resultset = array();
    foreach ($result AS $i => $entry) {
      $this->pr(25, compact('entry'));
      if (!empty($entry[0]))
	$entry['StatementEntry'] = $entry[0] + $entry['StatementEntry'];
      unset($entry[0]);

      $entry['StatementEntry']['balance'] =
	$entry['StatementEntry']['amount'] - $entry['StatementEntry']['reconciled'];

      // Since HAVING isn't a builtin feature of CakePHP,
      // we'll have to post-process to get the desired entries
      if ($entry['StatementEntry']['balance'] == 0) {
	if (!$unrec)
	  $resultset[] = $entry;
      }
      else {
	if ($unrec)
	  $resultset[] = $entry;
      }
    }

    return $this->prExit(array('entries' => $resultset,
			       'summary' => $this->stats(null, $query)));
  }


  /**************************************************************************
   **************************************************************************
   **************************************************************************
   * function: reconciledEntries
   *  - Returns a list of entries that reconcile against the given entry.
   *    (such as payments towards a charge).
   */
  function reconciledEntriesQuery($id, $query = null) {
    $this->queryInit($query, false);

    $this->id = $id;
    $this->recursive = -1;
    $this->read();

    $query['conditions'][] = array('StatementEntry.id' => $id);

    if ($this->data['StatementEntry']['type'] == 'CHARGE')
      $query['link']['PaymentEntry'] = array();
    if ($this->data['StatementEntry']['type'] == 'PAYMENT')
      $query['link']['ChargeEntry'] = array();

    return $query;
  }

  function reconciledEntries($id, $query = null) {
    $this->prEnter(compact('id', 'query'));
    $lquery = $this->reconciledEntriesQuery($id, $query);

    $result = $this->find('all', $lquery);
    foreach (array_keys($result) AS $i)
      unset($result[$i]['StatementEntry']);

    return $this->prExit(array('entries' => $result));
  }


  /**************************************************************************
   **************************************************************************
   **************************************************************************
   * function: assignCredits
   *  - Assigns all credits to existing charges
   *
   * REVISIT <AP>: 20090726
   *  This algorithm shouldn't be hardcoded.  We need to allow
   *  the user to specify how payments should be applied.
   *
   */
  function assignCredits($query = null, $receipt_id = null) {
    $this->prEnter( compact('query', 'receipt_id'));
    $this->queryInit($query);

    $ret = array();

    // First, find all known credits
    $lquery = $query;
    $lquery['conditions'][] = array('StatementEntry.type' => 'SURPLUS');
    $lquery['order'][] = 'StatementEntry.effective_date ASC';
    $credits = $this->find('all', $lquery);
    $this->pr(18, compact('credits'),
	      "Credits Established");

    // Next, establish credit from the newly added receipt
    $receipt_credit = null;
    if (!empty($receipt_id)) {
      $lquery = $query;
      $lquery['link'] += array('LedgerEntry' =>
			       array('conditions' =>
				     //array(LedgerEntry.'crdr'=>'DEBIT'),
				     array('LedgerEntry.account_id !=' => $this->Account->accountReceivableAccountID()),
				     ));
      $lquery['fields'] = array('Transaction.id', 'Transaction.stamp', 'Transaction.amount',
				'LedgerEntry.account_id');
      // Very specific case here... no extra conditions
      unset($lquery['conditions']);
      $this->Transaction->id = $receipt_id;
      $receipt_credit = $this->Transaction->find('first', $lquery);
      if (!$receipt_credit)
	die("INTERNAL ERROR: UNABLE TO LOCATE RECEIPT");

      $receipt_credit['balance'] = $receipt_credit['Transaction']['amount'];

      $this->pr(18, compact('receipt_credit'),
		"Receipt Credit Added");
    }

    // Now find all unpaid charges
    $lquery = $query;
    $lquery['order'] = 'StatementEntry.effective_date ASC';
    $charges = $this->reconciledSet('CHARGE', $query, true);
    $this->pr(18, compact('charges'),
	      "Outstanding Charges Determined");

    // Initialize our list of used credits
    $used_credits = array();

    // Work through all unpaid charges, applying payments as we go
    foreach ($charges['entries'] AS $charge) {

      $this->pr(20, compact('charge'),
		'Process Charge');

      // Check that we have available credits.
      // Technically, this isn't necessary, since the loop
      // will handle everything just fine.  However, this
      // just saves extra processing if/when there is no
      // means to resolve a charge anyway.
      if (count($credits) == 0 && empty($receipt_credit['balance'])) {
	$this->pr(15, 'No more available credits');
	break;
      }

      $charge['balance'] = $charge['StatementEntry']['balance'];
      while ($charge['balance'] > 0 &&
	     (count($credits) || !empty($receipt_credit['balance']))) {

	$this->pr(20, compact('charge'),
		  'Attempt Charge Reconciliation');

	// Use explicit credits before using implicit credits
	// (Not sure it matters though).
	if (count($credits)) {
	  // Peel off the first credit available
	  $credit =& $credits[0];
	  $payment_date = $credit['StatementEntry']['effective_date'];
	  $payment_transaction_id = $credit['StatementEntry']['transaction_id'];
	  $payment_account_id = $credit['StatementEntry']['account_id'];

	  if (!isset($credit['balance']))
	    $credit['balance'] = $credit['StatementEntry']['amount'];
	}
	elseif (!empty($receipt_credit['balance'])) {
	  // Use our only receipt credit
	  $credit =& $receipt_credit;
	  $payment_date = $credit['Transaction']['stamp'];
	  $payment_transaction_id = $credit['Transaction']['id'];
	  $payment_account_id = $credit['LedgerEntry']['account_id'];
	}
	else {
	  die("HOW DID WE GET HERE WITH NO SURPLUS?");
	}

	// Set the payment amount to the maximum amount
	// possible without exceeding the charge or credit balance
	$payment_amount = min($charge['balance'], $credit['balance']);
	if (!isset($credit['applied']))
	  $credit['applied'] = 0;

	$credit['applied'] += $payment_amount;
	$credit['balance'] -= $payment_amount;

	$this->pr(20, compact('credit'),
		  (($credit['balance'] > 0 ? 'Utilized' : 'Exhausted')
		   . (count($credits) ? '' : ' Anon')
		   . ' Credit'));

	if ($credit['balance'] < 0)
	  die("HOW DID WE END UP WITH NEGATIVE SURPLUS BALANCE?");

	// If we've exhaused the credit, get it out of the
	// available credit pool (but keep track of it for later).
	if ($credit['balance'] <= 0) {
	  if (count($credits))
	    $used_credits[] = array_shift($credits);
	  else
	    $used_anon_credits[] = array_shift($anon_credits);
	}

	// Add a payment that uses the available credit to pay the charge
	$payment = array('type' => 'PAYMENT',
			 'account_id' => $payment_account_id,
			 'amount'     => $payment_amount,
			 'effective_date' => $payment_date,
			 'transaction_id' => $payment_transaction_id,
			 'customer_id' => $charge['StatementEntry']['customer_id'],
			 'lease_id' => $charge['StatementEntry']['lease_id'],
			 'charge_entry_id' => $charge['StatementEntry']['id'],
			 'comment' => null,
			 );

	$this->pr(20, compact('payment'),
		  'New Payment Entry');

	$result = $this->addStatementEntry($payment);
	$ret['Payment'][] = $result;
	if ($result['error'])
	  $ret['error'] = true;

	// Adjust the charge balance to reflect the new payment
	$charge['balance'] -= $payment_amount;
	if ($charge['balance'] < 0)
	  die("HOW DID WE GET A NEGATIVE CHARGE AMOUNT?");

	if ($charge['balance'] <= 0)
	  $this->pr(20, 'Fully Paid Charge');
      }

    }

    // Partially used credits must be added to the used list
    if (isset($credits[0]['applied']))
      $used_credits[] = array_shift($credits);
      
    $this->pr(18, compact('credits', 'used_credits', 'anon_credits', 'used_anon_credits'),
	      'Payments added');

    // Clean up any explicit credits that have been used
    foreach ($used_credits AS $credit) {
      if ($credit['balance'] > 0) {
	$this->pr(20, compact('credit'),
		  'Update Credit Entry');

 	$this->id = $credit['StatementEntry']['id'];
	$this->saveField('amount', $credit['balance']);
      }
      else {
	$this->pr(20, compact('credit'),
		  'Delete Exhausted Credit Entry');

	$this->del($credit['StatementEntry']['id'], false);
      }
    }

    // Convert non-exhausted receipt credit to an explicit one
    if (!empty($receipt_credit['balance'])) {
      $credit =& $receipt_credit;

      $this->pr(18, compact('credit'),
		'Create Explicit Credit');

      $result = $this->addStatementEntry
	(array('type'           => 'SURPLUS',
	       'account_id'     => $credit['LedgerEntry']['account_id'],
	       'amount'         => $credit['balance'],
	       'effective_date' => $credit['Transaction']['stamp'],
	       'transaction_id' => $credit['Transaction']['id'],
	       'customer_id'    => $credit['Customer']['id'],
	       ));
      $ret['Credit'] = $result;
      if ($result['error'])
	$ret['error'] = true;
    }

    return $this->prExit($ret + array('error' => false));
  }


  /**************************************************************************
   **************************************************************************
   **************************************************************************
   * function: stats
   *  - Returns summary data from the requested statement entry
   */
  function stats($id = null, $query = null) {
    $this->prEnter(compact('id', 'query'));

    $this->queryInit($query);
    unset($query['group']);

    $stats = array();
    if (isset($id))
      $query['conditions'][] = array('StatementEntry.id' => $id);

    $rquery = $query;
    unset($rquery['link']['ChargeEntry']);
    $rquery['link']['PaymentEntry'] = array('fields' => array());

    $rquery['fields'] = array();
    $rquery['fields'][] = "StatementEntry.amount";
    $rquery['fields'][] = "SUM(PaymentEntry.amount) AS reconciled";

    $rquery['conditions'][] = array('StatementEntry.type' => 'CHARGE');
    $rquery['group'] = 'StatementEntry.id';

    $result = $this->find('all', $rquery);
    $stats['Charge'] = array('total' => 0, 'reconciled' => 0);
    foreach($result AS $charge) {
      $stats['Charge']['total'] += $charge['StatementEntry']['amount'];
      $stats['Charge']['reconciled'] += $charge[0]['reconciled'];
    }
    $stats['Charge']['balance'] = 
      $stats['Charge']['total'] - $stats['Charge']['reconciled'];
    
    $this->pr(17, compact('query', 'result'),
	      'Charges');

    $rquery = $query;
    unset($rquery['link']['PaymentEntry']);
    $rquery['link']['ChargeEntry'] = array('fields' => array());

    $rquery['fields'] = array();
    $rquery['fields'][] = "SUM(StatementEntry.amount) AS total";
    $rquery['fields'][] = "SUM(IF(ChargeEntry.id IS NULL, 0, StatementEntry.amount)) AS reconciled";
    $rquery['fields'][] = "SUM(IF(ChargeEntry.id IS NULL, StatementEntry.amount, 0)) AS balance";

    $rquery['conditions'][] = array('StatementEntry.type' => 'PAYMENT');
    $result = $this->find('first', $rquery);
    if (!isset($result[0]['balance']))
      $result[0]['balance'] = 0;
    $stats['Payment'] = $result[0];

    $this->pr(17, compact('rquery', 'result'),
	      'Payments');

    return $this->prExit($stats);
  }

}