import requests
from app.config import settings
from app.helpers.response_helper import ResponseHelper
from app.services.loan import LoanService
from app.utils.auth import get_headers
from app.utils.extras import preprocess_loan_charges_data
from app.utils.logger import logger
from flask import jsonify, current_app
from app.services.transactions import TransactionService
from app.services.repayment import RepaymentService
from app.extensions import db 
from app.services.repayments_data import RepaymentsData
from app.services.salary import SalaryService


class SimbrellaClient:

    BANK_CALL_BASE_URL = settings.BANK_CALL_BASE_URL
    BANK_CALL_SMS_BASE_URL = settings.BANK_CALL_SMS_BASE_URL
    BANK_CALL_DISBURSE_LOAN_ENDPOINT =  settings.BANK_CALL_DISBURSE_LOAN_ENDPOINT
    BANK_CALL_COLLECT_LOAN_ENDPOINT =  settings.BANK_CALL_COLLECT_LOAN_ENDPOINT
    BANK_CALL_TRANSACTION_VERIFY = settings.BANK_CALL_TRANSACTION_VERIFY

    @staticmethod
    def disburse_loan(data):
        api_url = f"{SimbrellaClient.BANK_CALL_BASE_URL}/{SimbrellaClient.BANK_CALL_DISBURSE_LOAN_ENDPOINT}"
        logger.info(f"Calling DisburseLoan        api_url==> : {api_url}")
        logger.info(f"Calling DisburseLoan endpoint with data: {data}")

        # Check if the transaction exists
        logger.info(f"Checking if transaction exists")
        transaction = TransactionService.get_transaction_by_transaction_id(transaction_id=data['transactionId'])
        logger.info(f"Loan Response From Database ** : {transaction}")

        # If transaction is not found
        if not transaction:
            logger.info(f"Transaction id: {data['transactionId']}, was not found")
            return 0

        # Fetch the loan based on the transaction_id
        logger.info(f"Fetching the loan with transaction ID: {data['transactionId']}")
        loan = LoanService.get_loan_by_transaction_id(transaction_id=data['transactionId'])
        logger.info(f"Response from database: {loan}")

        # If loan is not found
        if not loan:
            logger.info(f"Could not find loan with transaction id: {data['transactionId']}")
            return 0

        loan_data = loan.to_dict()
        logger.info(f"Here is your loan data: {loan_data}")

        if loan_data['disburseDate'] is not None:
            logger.info(
                f"Please call verify loan : {data['transactionId']}  loan send for processing at {loan_data['disburseDate']}")
            return 0

        # let us set disbursement date
        LoanService.set_disbursement_date(loan_data['debtId'],loan_data['customerId'])  # toda this must return something
        logger.info(f"Here is your loan data after setting disbursement date: {loan_data}")

        loan_charges = preprocess_loan_charges_data([loan_charge.to_dict() for loan_charge in loan.loan_charges])
        logger.info(f"Here are your loan_charges: {loan_charges}")

        mgt_fee = loan_charges.get("MGTFEE")['amount']
        vat_fee = loan_charges.get("VAT")['amount']
        interest_fee = loan_charges.get("INTEREST")['amount']
        insurance_fee = loan_charges.get("INSURANCE")['amount']

        debtId =  str(loan_data.get('debtId', "")).strip().zfill(6)

        disbursement_data = {
            "transactionId": loan_data.get('transactionId'),
            "FbnTransactionId": loan_data.get('transactionId'),
            "debtId": debtId,
            "customerId": loan_data.get('customerId'),
            "accountId": loan_data.get('accountId'),
            "productId": str(loan_data.get('productId', "")),
            "provideAmount": loan_data.get('currentLoanAmount'),
            "collectAmountInterest": interest_fee,
            "collectAmountMgtFee": mgt_fee,
            "collectAmountInsurance": insurance_fee,
            "collectAmountVAT": vat_fee,
            "countryId": "01",
            "comment": "Loan Disbursement",
        }

        try:
            logger.info(f"Here is your Disbursement Request data ****** : {disbursement_data}")
            response = requests.post(api_url, json=disbursement_data, timeout=10, headers=get_headers())
            logger.info(f"Disbursement response: {response.json()}")
            result = response.json()
            LoanService.set_disbursement_result(loan_data['debtId'],result.get('responseCode', ''), result.get('responseMessage', ''))
            return ResponseHelper.success(response.json(), "Successful")
        except Exception as e:
            logger.info(f"Failed to call Disbursement endpoint: {e}")
            return 0

        return 1

    @staticmethod
    def verify_transaction(data):
        api_url = f"{SimbrellaClient.BANK_CALL_BASE_URL}{SimbrellaClient.BANK_CALL_TRANSACTION_VERIFY}"
        sms_url = f"{SimbrellaClient.BANK_CALL_SMS_BASE_URL}/singleSMS"
        logger.info(f"Calling TransactionVerify        api_url==> : {api_url}")

        # Check if the transaction exists
        logger.info(f"Checking if transaction exists")
        transaction = TransactionService.get_transaction_by_transaction_id(transaction_id=data['transactionId'])
        transaction_data = transaction.to_dict()
        logger.info(f"Loan Response From Database ** : {transaction}")

        # If transaction is not found
        if not transaction:
            logger.info(f"Transaction id: {data['transactionId']}, was not found")
            return 0

        # Fetch the loan based on the transaction_id
        logger.info(f"Fetching the loan with transaction ID: {data['transactionId']}")
        loan = LoanService.get_loan_by_transaction_id(transaction_id=data['transactionId'])
        logger.info(f"Response from database: {loan}")

        # If loan is not found
        if not loan:
            logger.info(f"Could not find loan with transaction id: {data['transactionId']}")
            return 0

        loan_data = loan.to_dict()
        logger.info(f"Here is your loan data: {loan_data}")

        if loan_data['disburseDate'] is not None and loan_data['disburseVerify'] is  None :
            LoanService.set_disburse_verify_date(loan_data['debtId'],loan_data['customerId'])
            loan_data = loan.to_dict()
            logger.info(f"Here is your loan data after setting verify date: {loan_data}") 
            logger.info(f"Good to Verify transaction id: {data['transactionId']}")
        else:
            logger.info(
                f"Please call disburse loan : {data['transactionId']}  loan send for processing first")
            return 0


        verify_data = {
            "customerId": loan_data.get('customerId'),
            "accountId": loan_data.get('accountId'),
            "transactionId": loan_data.get('transactionId'),
            "transactionType": "provide",
            "fbnTransactionId": loan_data.get('transactionId'),
            "countryId": "NG",
            "requestId": loan_data.get('transactionId')
        }

        try:
            logger.info(f"Here is your TransactionVerify Request data ****** : {verify_data}")
            response = requests.post(api_url, json=verify_data, timeout=10, headers=get_headers())
            result = response.json()
            logger.info(f"this is verify result, {result}")
            LoanService.set_disburse_verify_result(loan_data['debtId'],result.get('responseCode', ''), result.get('responseMessage', ''))
            sms_data = {
                "dest": transaction_data.get('phone_number') or settings.TEST_NO,
                "text": f"Transaction {loan_data.get('transactionId')} verified successfully",
                "unicode": True
            }
            try:
                sms_response = requests.post(sms_url, json=sms_data, timeout=10, headers=get_headers())
                sms_response.raise_for_status()  # Raise an exception for 4xx or 5xx status codes
                result = sms_response.json()
                logger.info(f"SMS Response JSON: {result}")
                if result.get('isSuccess'):
                    logger.info(f"sms sent successfully")
                    return ResponseHelper.success(response.json(), "Successful")
                logger.info(f"sms failed!")
                return 1
            except requests.RequestException as e:
                # Handle the exception
                logger.error(f"Failed to send SMS: {e}")
                return 0
        except Exception as e:
            logger.info(f"Failed to call TransactionVerify endpoint: {e}")
            return 0

    @staticmethod
    def collect_loan_user_initiated(data):
        # InitiatedBy = USER_INITIATED
        logger.info(f"Calling CollectLoan collect_loan_user_initiated ******* endpoint with data: {data}")
        return SimbrellaClient._collect_loan(data,"1")
    @staticmethod
    def collect_loan_user_salary_detect(data):
        try:
            return SimbrellaClient._collect_loan(data, "2")
        except Exception as e:
            logger.error(f"Error in collect_loan_user_salary_detect: {e}")
            return ResponseHelper.error(
                message="Failed to collect loan for salary detection",
                status_code=500,
                error=str(e)
            )
            

    @staticmethod
    def collect_loan_user_due_payment(data):
        # InitiatedBy = REPAYMENT_DUE
        return SimbrellaClient._collect_loan(data,"3")

    @staticmethod
    def _collect_loan(data, collectionMethod: str):
        api_url = f"{SimbrellaClient.BANK_CALL_BASE_URL}{SimbrellaClient.BANK_CALL_COLLECT_LOAN_ENDPOINT}"
        logger.info(f"Calling CollectLoan api_url==> : {api_url}")
        logger.info(f"Calling CollectLoan endpoint with data: {data}")

        # Check if the repayment exists
        logger.info(f"Checking if repayment exists")
        repayment = RepaymentService.get_repayment_by_id(id=data['Id'])
        logger.info(f"Repayment Response From Database ** : {repayment}")

        if not repayment:
            logger.info(f"Repayment with id: {data['Id']}, was not found")
            return ResponseHelper.error("Repayment not found")
        logger.info(f"Repayment Response From Database ** : {repayment.to_dict()}")
        repayment_data = repayment.to_dict()
        loan = LoanService.get_loan_by_loan_id(loan_id=int(repayment_data['loanId']))
        

        # If loan is not found
        if loan is None:
            logger.info(f"Loan with debtId: {repayment_data['loanId']}, was not found")
            return ResponseHelper.error("Loan not found")

        loan_data = loan.to_dict()
        logger.info(f"loan dict : {loan_data}")

        if repayment_data['repayDate'] is not None:
            logger.info(
                f"Please call verify collection : {data['transactionId']} repayment send for processing at {repayment_data['repayDate']}")
            return ResponseHelper.error("Repayment already processed")

        # let us set repay date
        RepaymentService.set_repay_date(repayment_data['Id'], repayment_data['customerId'])
        repayment = RepaymentService.get_repayment_by_transaction_id(transaction_id=data['transactionId'])
        repayment_data = repayment.to_dict()
        logger.info(f"Here is your repayment data after setting repay date: {repayment_data}")
        debtId =  str(loan_data.get('debtId', "")).strip().zfill(6)
        collect_loan_data = {
            "transactionId": repayment_data['transactionId'],
            "fbnTransactionId": loan_data['transactionId'],
            "debtId": debtId,
            "customerId": repayment_data['customerId'],
            "accountId": loan_data['accountId'],
            "productId": repayment_data['productId'],
            "collectAmount": loan_data['repaymentAmount'] or 0,
            "penalCharge": 5,
            "channel": "USSD",
            "collectionMethod": collectionMethod,
            "lienAmount": 0,
            "countryId": "NG",
            "comment": "COLLECT LOAN"
        }

        try:
            logger.info(f"Here is your CollectLoan Request data ***** : {collect_loan_data}")
            response = requests.post(api_url, json=collect_loan_data,timeout=30, headers=get_headers())
            
            logger.info(f"CollectLoan response: {response.json()}")
            RepaymentService.set_repay_result(repayment_data['Id'], response.json().get('responseCode', ''), response.json().get('responseMessage', ''))
            result = response.json()
            logger.info(f"this is the result {result}")
            data_to_add = {
                "transactionId": result.get('transactionId') or collect_loan_data.get('transactionId'),
                "fbnTransactionId": result.get('fbnTransactionId') or collect_loan_data.get('fbnTransactionId'),
                "accountId": result.get('accountId') or collect_loan_data.get('accountId'),
                "customerId": result.get('customerId') or collect_loan_data.get('customerId'),
                "amountCollected": result.get('amountCollected'),
                "repaymentAmount": collect_loan_data.get('collectAmount'),
                "responseCode": result.get('responseCode'),
                "responseDescr": result.get('responseMessage'),
                "balance":result.get('lienAmount')
            }
            
            new_repayment_data = RepaymentsData.add_repayment_data(data_to_add)
            logger.info(f"Repayment data added successfully: {new_repayment_data.to_dict()}")
            if not new_repayment_data:
                logger.info(f"Failed to add repayment data")
            
            return ResponseHelper.success(response.json(), "Successful")
        except Exception as e:
            logger.info(f"Failed to call CollectLoan endpoint: {e}")
            return ResponseHelper.error("Failed to call CollectLoan endpoint")


    @staticmethod
    def refresh_disbursement(data):

        try:
            logger.info(f"Here is your Disbursement Request data ***** : {data}")

            return ResponseHelper.success(data, "Successful")

        except Exception as e:
            logger.info(f"Failed to call Disbursement endpoint: {e}")
            raise

    @staticmethod
    def payment_callback(data):

        try:
            logger.info(f"Here is your Payment Callback Request data ***** : {data}")

            return ResponseHelper.success(data, "Successful")

        except Exception as e:
            logger.info(f"Failed to call Payment Callback endpoint: {e}")
            raise

    @staticmethod
    def penal_charge(data):

        api_url = f"{SimbrellaClient.BANK_CALL_BASE_URL}/PenalCharge"
        logger.info(f"Calling Penal Charge endpoint with data: {data}")

        try:
            logger.info(f"Here is your Penal Charge Request data ***** : {data}")

            try:
                logger.info(f"Here is your Penal Charge Request data ****** : {data}")
                response = requests.post(api_url, json=data, timeout=10, headers=get_headers())
                logger.info(f"Penal Charge response: {response.json()}")
                return ResponseHelper.success(response.json(), "Successful")

            except Exception as e:
                logger.info(f"Failed to call Penal Charge endpoint: {e}")
                return ResponseHelper.error("An error occurred", 500)

        except Exception as e:
            logger.info(f"Failed to call Penal Charge endpoint: {e}")
            raise