import eventlet
import logging

# 配置 eventlet 日志，抑制 IOClosed 等错误日志
logging.getLogger('eventlet.hubs').setLevel(logging.CRITICAL)
logging.getLogger('eventlet.greenio').setLevel(logging.CRITICAL)

# 进行猴子补丁操作
eventlet.monkey_patch()

# 配置 eventlet hub 以更优雅地处理所有错误
try:
    from eventlet import hubs
    import eventlet
    import traceback
    
    # 只修改存在的属性，避免引用错误
    if hasattr(hubs, 'trampoline'):
        # 保存原始的trampoline方法
        original_trampoline = hubs.trampoline
        
        def custom_trampoline(fd, read=False, write=False, timeout=None, timeout_exc=None):
            try:
                return original_trampoline(fd, read, write, timeout, timeout_exc)
            except Exception as e:
                # 捕获 trampoline 方法中所有异常
                print(f"[Eventlet Trampoline Error] {type(e).__name__}: {e}")
                print(f"[Params] fd: {fd}, read: {read}, write: {write}, timeout: {timeout}")
                print("[Traceback]")
                traceback.print_exc()
                # 返回 None 继续运行，不往外传播错误
                return None
        
        # 替换原始方法
        hubs.trampoline = custom_trampoline
    
    # 同样处理 greenio 模块的所有相关方法，捕获所有异常
    from eventlet import greenio
    
    # 保存并替换原始的 greenio 方法（只修改存在的方法）
    if hasattr(greenio.base.GreenSocket, '_recv_loop'):
        original_recv_loop = greenio.base.GreenSocket._recv_loop
        
        def custom_recv_loop(self, recv_func, recv_args, *args, **kwargs):
            try:
                return original_recv_loop(self, recv_func, recv_args, *args, **kwargs)
            except Exception as e:
                # 捕获所有 IO 操作异常
                print(f"[Eventlet IO Error] _recv_loop: {type(e).__name__}: {e}")
                print("[Traceback]")
                traceback.print_exc()
                # 返回空字节串继续运行
                return b''
        
        greenio.base.GreenSocket._recv_loop = custom_recv_loop
    
    if hasattr(greenio.base.GreenSocket, 'recv_into'):
        original_recv_into = greenio.base.GreenSocket.recv_into
        
        def custom_recv_into(self, buffer, nbytes=0, flags=0):
            try:
                return original_recv_into(self, buffer, nbytes, flags)
            except Exception as e:
                # 捕获所有 IO 操作异常
                print(f"[Eventlet IO Error] recv_into: {type(e).__name__}: {e}")
                print("[Traceback]")
                traceback.print_exc()
                # 返回 0 继续运行
                return 0
        
        greenio.base.GreenSocket.recv_into = custom_recv_into
    
    if hasattr(greenio.base.GreenSocket, '_send_loop'):
        original_send_loop = greenio.base.GreenSocket._send_loop
        
        def custom_send_loop(self, send_func, data, *args, **kwargs):
            try:
                return original_send_loop(self, send_func, data, *args, **kwargs)
            except Exception as e:
                # 捕获所有 IO 操作异常
                print(f"[Eventlet IO Error] _send_loop: {type(e).__name__}: {e}")
                print("[Traceback]")
                traceback.print_exc()
                # 返回 0 继续运行
                return 0
        
        greenio.base.GreenSocket._send_loop = custom_send_loop
    
    if hasattr(greenio.base.GreenSocket, 'send'):
        original_send = greenio.base.GreenSocket.send
        
        def custom_send(self, data, flags=0):
            try:
                return original_send(self, data, flags)
            except Exception as e:
                # 捕获所有 IO 操作异常
                print(f"[Eventlet IO Error] send: {type(e).__name__}: {e}")
                print("[Traceback]")
                traceback.print_exc()
                # 返回 0 继续运行
                return 0
        
        greenio.base.GreenSocket.send = custom_send
    
    # 处理 WSGI 中的所有错误
    try:
        import eventlet.wsgi
        
        if hasattr(eventlet.wsgi.HttpProtocol, 'handle_one_request'):
            original_wsgi_handle_one_request = eventlet.wsgi.HttpProtocol.handle_one_request
            
            def custom_wsgi_handle_one_request(self):
                try:
                    return original_wsgi_handle_one_request(self)
                except Exception as e:
                    # 捕获 WSGI 请求处理中的所有异常
                    print(f"[Eventlet WSGI Request Error] {type(e).__name__}: {e}")
                    print("[Traceback]")
                    traceback.print_exc()
                    # 清理连接状态并返回，不往外传播错误
                    try:
                        self.finish()
                    except Exception:
                        pass
                    return
            
            eventlet.wsgi.HttpProtocol.handle_one_request = custom_wsgi_handle_one_request
        
        if hasattr(eventlet.wsgi.HttpProtocol, 'handle_one_response'):
            original_wsgi_handle_one_response = eventlet.wsgi.HttpProtocol.handle_one_response
            
            def custom_wsgi_handle_one_response(self):
                try:
                    return original_wsgi_handle_one_response(self)
                except Exception as e:
                    # 捕获 WSGI 响应处理中的所有异常
                    print(f"[Eventlet WSGI Response Error] {type(e).__name__}: {e}")
                    print("[Traceback]")
                    traceback.print_exc()
                    # 清理连接状态并返回，不往外传播错误
                    try:
                        self.finish()
                    except Exception:
                        pass
                    return
            
            eventlet.wsgi.HttpProtocol.handle_one_response = custom_wsgi_handle_one_response
    except Exception as e:
        # 如果修改失败，忽略错误
        print(f"[WSGI Patch Error] {e}")
    
    print("[Eventlet Error Handling] Eventlet errors will be caught and printed, not raised")
except Exception as e:
    # 如果修改失败，打印错误但继续运行
    print(f"[Eventlet Patch Initialization Error] {e}")
    traceback.print_exc()

from flask import Flask
from .views.routes import main_bp
from .views.file import file_bp
from .config import Config
from .extensions import init_extensions,register_namespaces

def create_app():
    app = Flask(__name__, template_folder="../templates", static_folder="../static",static_url_path="/vsc-like/static")
    app.config.from_object(Config)
    @app.route('/')
    def hello():
        return 'Hello, World!'

    # 注册蓝图
    app.register_blueprint(main_bp)
    app.register_blueprint(file_bp)
    # 初始化SocketIO
    init_extensions(app)

    register_namespaces(app)

    return app