from app.api.integrations.events_service import EventServiceIntegration
from app.api.integrations.simbrella import SimbrellaIntegration
from flask import Blueprint, request, jsonify, send_from_directory
from app.api.services import (
    EligibilityCheckService,
    SelectOfferService,
    ProvideLoanService,
    LoanStatusService,
    RepaymentService,
    CustomerConsentService,
    NotificationCallbackService,
    AuthorizationService,
)
from app.utils.logger import logger
from app.api.middlewares import enforce_json, require_auth
import os
from flask_jwt_extended import (
    JWTManager,
    jwt_required,
    create_access_token,
    get_jwt_identity,
    create_refresh_token,
)
from sqlalchemy import text
from app.extensions import db
from app.config import settings


api = Blueprint("api", __name__)


@api.before_request
def cors_middleware():
    """Middleware applied globally to all API routes in this blueprint"""
    return enforce_json()


# Swagger JSON file
@api.route("/swagger.json", methods=["GET"])
def swagger_json():
    swagger_dir = os.path.join("swagger")
    return send_from_directory(swagger_dir, "digifi_swagger.json")


@api.route("/swagger/<path:filename>")
def serve_paths(filename):
    swagger_dir = os.path.join("swagger")
    return send_from_directory(swagger_dir, filename)


# EligibilityCheck Endpoint
@api.route("/EligibilityCheck", methods=["POST"])
@jwt_required()
def eligibility_check():
    data = request.get_json()
    # logger.info(f"EligibilityCheck request received: {data}")
    response = EligibilityCheckService.process_request(data)
    return response


# SelectOffer Endpoint
@api.route("/SelectOffer", methods=["POST"])
@jwt_required()
def select_offer():
    data = request.get_json()
    # logger.info(f"SelectOffer request received: {data}")
    response = SelectOfferService.process_request(data)
    return response


# ProvideLoan Endpoint
@api.route("/ProvideLoan", methods=["POST"])
@jwt_required()
def provide_loan():
    data = request.get_json()
    # logger.info(f"ProvideLoan request received: {data}")
    response = ProvideLoanService.process_request(data)
    return response


# LoanStatus Endpoint
@api.route("/LoanStatus", methods=["POST"])
@jwt_required()
def loan_status():
    data = request.get_json()
    # logger.info(f"LoanStatus request received: {data}")
    response = LoanStatusService.process_request(data)
    return response


# Repayment Endpoint
@api.route("/Repayment", methods=["POST"])
@jwt_required()
def repayment():
    data = request.get_json()
    logger.error(f"HERE 0000a **** ")
    # logger.info(f"Repayment request received: {data}")
    response = RepaymentService.process_request(data)
    return response


# CustomerConsent Endpoint
@api.route("/CustomerConsent", methods=["POST"])
@jwt_required()
def customer_consent():
    data = request.get_json()
    # logger.info(f"CustomerConsent request received: {data}")
    response = CustomerConsentService.process_request(data)
    return response


# NotificationCallback Endpoint
@api.route("/NotificationCallback", methods=["POST"])
@jwt_required()
def notification_callback():
    data = request.get_json()
    # logger.info(f"NotificationCallback request received: {data}")
    response = NotificationCallbackService.process_request(data)
    return response

# Health Check Endpoint
@api.route("/health", methods=["GET"])
def health_check():
    SQLALCHEMY_DATABASE_URI = settings.SQLALCHEMY_DATABASE_URI
    response = {}
    db_status = "Connection Successful"
    events_service_status = "Connection Successful"
    bank_status = "Connection Successful"
    errors = []
    status = "ok"


    # Extract the database URI
    try:
        db_uri = db.engine.url.render_as_string(hide_password=False)
        db_uri =  db_uri
    except Exception as e:
        db_uri = "Unavailable"


    # Check database connection
    try:
        logger.info(f"Database Health == : {SQLALCHEMY_DATABASE_URI}")
        db.session.execute(text("SELECT table_name FROM user_tables ORDER BY table_name"))
    except Exception as e:
        db_status = "Connection Failed"
        errors.append(f"Database Error: {str(e)}")
        status = "failed"


    # Check Events Service health
    try:
        events_service_response = EventServiceIntegration.health_check()

        if events_service_response.status_code != 200:
            events_service_status = "Connection Failed"
            status = "failed"
            errors.append(f"Events Service response: {events_service_response.text}")


    except Exception as e:
        events_service_status = "Connection Failed"
        status = "failed"
        errors.append(f"Events Service connection failed: {str(e)}")

    # Check Bank health
    try:
        emulator_response = SimbrellaIntegration.health_check()

        if emulator_response.status_code != 200:
            bank_status = "Connection Failed"
            status = "failed"
            errors.append(f"Bank Connection response: {emulator_response.text}")

    except Exception as e:
        bank_status = "Connection Failed"
        status = "failed"
        errors.append(f"Connection to Bank failed: {str(e)}")


    response = {
        "status": status,
        "db_status": db_status,
        "events_service_status": events_service_status,
        "bank_status": bank_status,
        "db_uri": db_uri,
        "errors": errors or None
    }


    return jsonify(response), 200 if status == "ok" else 500


# Authorize endpoint
@api.route("/Authorize", methods=["POST"])
def authorize():
    data = request.get_json()
    # logger.info(f"Authorize request received: {data}")
    response = AuthorizationService.process_request(data)
    return response


# Authorize refresh endpoint
@api.route("/AuthorizeRefresh", methods=["POST"])
@jwt_required(refresh=True)
def refresh():
    data = request.get_json()
    # logger.info(f"Authorize refresh request received: {data}")
    response = AuthorizationService.process_refresh_request()
    return response