<?php

namespace App;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\SoftDeletes;

class ProFormaInvoice extends Model
{
    use SoftDeletes;
    protected $table = 'pro_forma_invoice';

    protected $fillable = [
        'application_id',
        'gst_number',
        'center_name',
        'customer_name',
        'treatment_name',
        'customer_registration_date',
        'customer_registration_number',
        'loan_application_no',
        'cersai_hypothecation_charge',
        'insurance_premium_by_merchant',
        'insurance_premium_applicable',
        'insurance_premium_amount',
        'merchant_collected_advance_amount',
        'fldg_applied',
        'liability_hold',
        'fldg_applied_category',
        'spouse_name',
        'insurance_coverage',
    ];

    /*
     * The per-charge collection methods are deliberately NOT mass assignable:
     *   processing_fee_collection_method
     *   cersai_collection_method
     *   legal_charges_collection_method
     *
     * 0 = collected by CreditFair, 1 = collected by merchant, 2 = added in loan amount,
     * null = not configured here, fall back to the merchant level default.
     * See App\Merchant::COLLECTED_BY_* / ADDED_IN_LOAN_AMOUNT.
     *
     * "Added in loan amount" is only valid for applications approved on or after the
     * release date, and that is enforced on assignment via
     * collectionMethodForPersistence(). Keeping these out of $fillable stops
     * fill(Input::all()) writing a request value straight to the column and
     * sidestepping that check. Always assign them explicitly.
     */

    /**
     * Resolves a charge collection method for an application, falling back to the
     * merchant level default when the application has no override of its own.
     *
     * @param  int|string|null $applicationMethod value from this table
     * @param  int|string|null $merchantMethod    value from the merchant row
     * @return int 0, 1 or 2
     */
    public static function resolveCollectionMethod($applicationMethod, $merchantMethod = null)
    {
        if (!is_null($applicationMethod) && $applicationMethod !== '') {
            return (int) $applicationMethod;
        }

        if (!is_null($merchantMethod) && $merchantMethod !== '') {
            return (int) $merchantMethod;
        }

        return Merchant::COLLECTED_BY_CREDIT_FAIR;
    }

    /**
     * True when the given collection method means "collected by the merchant".
     * Anything else (CreditFair, added in loan amount, not set) is false.
     *
     * @param  int|string|null $method
     * @return bool
     */
    public static function isCollectedByMerchant($method)
    {
        return !is_null($method) && (int) $method === Merchant::COLLECTED_BY_MERCHANT;
    }

    /**
     * True when the given collection method means "added in the loan amount".
     *
     * @param  int|string|null $method
     * @return bool
     */
    public static function isAddedInLoanAmount($method)
    {
        return !is_null($method) && (int) $method === Merchant::ADDED_IN_LOAN_AMOUNT;
    }

    /**
     * The date the per-charge collection methods went live.
     *
     * @return string
     */
    public static function collectionMethodReleaseDate()
    {
        return env('CHARGE_COLLECTION_METHOD_RELEASE_DATE', '2026-10-21 00:00:00');
    }

    /**
     * Whether the per-charge collection methods govern the given application.
     *
     * They only apply to applications approved on or after the release date.
     * Before that, none of the three charges had a collection method of its own:
     * the processing fee was a plain boolean, and CERSAI and legal charges rode on
     * that boolean. Applying the new rules retrospectively, in particular "added in
     * loan amount", would change historical loan amounts and merchant payouts.
     *
     * An application with no approval log yet counts as new, since it can only be
     * approved from here on.
     *
     * @param  int|null $applicationId
     * @return bool
     */
    public static function collectionMethodsApply($applicationId)
    {
        if (empty($applicationId)) {
            return true;
        }

        $approvedBeforeRelease = StatusLogs::where('application_id', $applicationId)
            ->where('status', 'approved')
            ->where('created_at', '<', self::collectionMethodReleaseDate())
            ->exists();

        return !$approvedBeforeRelease;
    }

    /**
     * True when a charge should be folded into the loan principal for this
     * application. Applies the release gate, so "added in loan amount" can never
     * take effect on an application approved before the release date.
     *
     * @param  int|string|null $method
     * @param  int|null        $applicationId
     * @return bool
     */
    public static function isAddedInLoanAmountForApplication($method, $applicationId)
    {
        return self::isAddedInLoanAmount($method) && self::collectionMethodsApply($applicationId);
    }

    /**
     * Guards a collection method before it is persisted.
     *
     * "Added in loan amount" is not available on applications approved before the
     * release date, so the value is refused for those. Returning null tells the
     * caller to leave the stored value untouched rather than silently substituting
     * a different collection method, which would move money.
     *
     * @param  int|string|null $method
     * @param  int|null        $applicationId
     * @return int|null the value to persist, or null to skip the write
     */
    public static function collectionMethodForPersistence($method, $applicationId)
    {
        if (is_null($method) || $method === '') {
            return null;
        }

        if (self::isAddedInLoanAmount($method) && !self::collectionMethodsApply($applicationId)) {
            return null;
        }

        return (int) $method;
    }

    public function consumner(){
        return $this->hasOne('App\ConsumerApplication','id','application_id');
    }

    public function fldg_category(){
        return $this->hasOne('App\FLDGCategory','id','fldg_applied_category');
    }

}