import logging
from micro_framework.runner import Runner, RunnerContext
from micro_framework.routes import Route, CallbackRoute
from micro_framework.entrypoints import TimeEntrypoint
from micro_framework.amqp.entrypoints import EventListener, RPCListener
from micro_framework.retry import AsyncBackOff 
from micro_framework.websocket.entrypoints import WebSocketEntrypoint 
from tasks import test2, test, Class, websocket_task, websocket_caller, \ 
    test_failure, amqp_rpc_task, amqp_rpc_caller

config = {
    'AMQP_URI': 'amqp://guest:guest@localhost:5672',
    'MAX_WORKERS': 3,
    'SERVICE_NAME': 'my_service',
    'MAX_TASKS_PER_CHILD': 2, # currently for process WORKER_MODE only 
    'WORKER_MODE': 'process',
    'WEBSOCKET_IP': '0.0.0.0', # Default value
    'WEBSOCKET_PORT': 8765,  # Default Value
}

logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO, format='%(message)s')

contexts = [
    RunnerContext(routes=[
        CallbackRoute(
            test,
            callback_target=test_failure, # Called if error and after the backoff max_retries
            entrypoint=EventListener(
                source_service='my_exchange', event_name='my_routing_key'
            ),
            backoff=AsyncBackOff(
                max_retries=5, interval=10000, exception_list=None
            ),
        )],
        max_workers=3, # If not given, we use the config value
        worker_mode="thread", # If not given, we use the config value
        context_metric_label="context_1" # Prometheus Metric Label
    ),
    RunnerContext(routes=[
        Route(
            test2, # We also allow a direct reference instead of path.
            entrypoint=EventListener(
                source_service='my_service', event_name='event_name',
                # Only trigger the Route if this condition bellow is met.
                payload_filter=lambda payload: payload['some_key'] == 'some_value' 
            ),
        ),
        Route(
            Class,
            method_name='class_method', # If not provided, the __call__ method is called
            entrypoint=EventListener(
                source_service='my_service', event_name='event_name',
            ),
            backoff=AsyncBackOff(
                max_retries=5, interval=10000, exception_list=None
            ),
        ),
        # We support RPC  over websockets:
        Route(
            websocket_task,
            entrypoint=WebSocketEntrypoint(),
        ),
        Route(
            websocket_caller,
            entrypoint=TimeEntrypoint(10), 
        ),
        
        # But Also over AMQP
        Route(
            amqp_rpc_task,
            entrypoint=RPCListener()
        ),
        Route(
            amqp_rpc_caller,
            entrypoint=TimeEntrypoint(10)
        )], 
        context_metric_label="context_2"
    )
]


if __name__ == '__main__':
    runner = Runner(contexts, config)
    runner.start()

from micro_framework.amqp.dependencies import Producer
from micro_framework.websocket.dependencies import WebSocketRPCClient
from micro_framework.dependencies import inject
from micro_framework.retry import BackOffData
from micro_framework.amqp.dependencies import RPCProxyProvider
import time

@inject(producer=Producer(), retry=BackOffData())
def test(payload, producer, retry):
    # business_logic
    producer('event_name', {})

def test2(payload):
    print("Called after test function")

def test_failure(payload, producer, retry):
    print("Called after test failed and the max_retries is reached.")

class Class:
    producer = Producer()
    
    @inject(retry=BackOffData())
    def class_method(self, payload, retry):
        # business_logic
        self.producer('event_name', {})


# WebSocket RPC Examples
def websocket_task(arg1, arg2):
    """
    My Docstring
    :param arg1:
    :param arg2:
    :return:
    """
    print(f"Websocket Task Called with {arg1} and {arg2}")
    time.sleep(3)
    return f"{arg1} - {arg2}"

# Service Address to connect the client
@inject(service_rpc=WebSocketRPCClient('127.0.0.1', 8765))
def websocket_caller(reference, service_rpc):
    print(service_rpc.targets)
    print(service_rpc.websocket_task.info)
    async_response = service_rpc.websocket_task.call_async('argument1', 'argument2')
    print("This is an async response future", async_response)
    response = service_rpc.websocket_task('argument3', 'argument4')
    print('Sync Response: ', response)
    print("Async Response result will lock until response: ", async_response.result())


def amqp_rpc_task(arg1, arg2, *args, **kwargs):
    print(arg1, arg2, args, kwargs)

# We inject a RPCProxyProvider aiming at the service we wan't to consume.
# In this case, it is our own service...
@inject(service_rpc=RPCProxyProvider("my_service"))
def amqp_rpc_caller(reference, service_rpc):
    print(service_rpc.targets)
    print(service_rpc.amqp_rpc_task.info)
    async_response = service_rpc.amqp_rpc_task.call_async(
        'argument1', 'argument2', "additional_arg", and_kwargs="too"
    )
    print("This is an async response future", async_response)
    response = service_rpc.amqp_rpc_task(
        'argument3', 'argument4'
    )
    print('Sync Response: ', response)
    print(
        "Async Response result will lock until response: ", 
        async_response.result(timeout=None) # or some float value in seconds
    )