import logging
from datetime import datetime
from flask import jsonify
from app.models.loan_charge import LoanCharge

# Configure logging
logger = logging.getLogger(__name__)

class LoanChargeService:
    """
    Service class for handling loan charge-related operations.
    """

    @staticmethod
    def get_all_loan_charges(filters=None):
        """
        Get all loan charges with optional filtering.

        Args:
            filters (dict, optional): Filters for the loan charges query.

        Returns:
            dict: A standardized response with loan charges data.
        """
        try:
            if filters is None:
                filters = {}

            # Extract filters
            loan_id = filters.get('loan_id')
            transaction_id = filters.get('transaction_id')
            code = filters.get('code')
            start_date = filters.get('start_date')
            end_date = filters.get('end_date')
            due_before = filters.get('due_before')
            due_after = filters.get('due_after')

            # Extract pagination parameters
            page = int(filters.get('page', 1))
            limit = int(filters.get('limit', 20))

            # Ensure page and limit are valid
            if page < 1:
                page = 1
            if limit < 1 or limit > 100:
                limit = 20

            # Convert string dates to datetime objects if provided
            if start_date and isinstance(start_date, str):
                start_date = datetime.fromisoformat(start_date.replace('Z', '+00:00'))
            if end_date and isinstance(end_date, str):
                end_date = datetime.fromisoformat(end_date.replace('Z', '+00:00'))
            if due_before and isinstance(due_before, str):
                due_before = datetime.fromisoformat(due_before.replace('Z', '+00:00'))
            if due_after and isinstance(due_after, str):
                due_after = datetime.fromisoformat(due_after.replace('Z', '+00:00'))

            # Get loan charges with optional filters and pagination
            loan_charges, total_count = LoanCharge.get_all_loan_charges(
                loan_id=loan_id,
                transaction_id=transaction_id,
                code=code,
                start_date=start_date,
                end_date=end_date,
                due_before=due_before,
                due_after=due_after,
                page=page,
                limit=limit
            )

            # Convert loan charges to dictionary format
            loan_charges_data = []
            for charge in loan_charges:
                loan_charges_data.append({
                    'loan_id': charge.loan_id,
                    'code': charge.code,
                    'amount': charge.amount,
                    'percent': charge.percent,
                    'description': charge.description,
                    'due': charge.due,
                    'transaction_id': charge.transaction_id,
                    'due_date': charge.due_date.isoformat() if charge.due_date else None,
                    'created_at': charge.created_at.isoformat() if charge.created_at else None,
                    'updated_at': charge.updated_at.isoformat() if charge.updated_at else None
                })

            # Calculate total pages
            total_pages = (total_count + limit - 1) // limit

            response_data = {
                'loan_charges': loan_charges_data,
                'count': len(loan_charges_data),
                'pagination': {
                    'total_count': total_count,
                    'total_pages': total_pages,
                    'current_page': page,
                    'limit': limit,
                    'has_next': page < total_pages,
                    'has_prev': page > 1
                }
            }

            return response_data

        except Exception as e:
            logger.error(f"An error occurred: {str(e)}", exc_info=True)
            return jsonify({
                "message": "Internal Server Error"
            }), 500