FleetManagercustomerCUSTOMERcustomerimport json
import math

from simfleet.customer import CustomerStrategyBehaviour
from simfleet.fleetmanager import FleetManagerStrategyBehaviour
from simfleet.transport import TransportStrategyBehaviour
from simfleet.utils import TRANSPORT_WAITING, TRANSPORT_WAITING_FOR_APPROVAL, CUSTOMER_WAITING, TRANSPORT_MOVING_TO_CUSTOMER, \
    CUSTOMER_ASSIGNED
from simfleet.protocol import REQUEST_PERFORMATIVE, ACCEPT_PERFORMATIVE, REFUSE_PERFORMATIVE, PROPOSE_PERFORMATIVE, \
    CANCEL_PERFORMATIVE
from simfleet.helpers import PathRequestException, distance_in_meters

###############################################################
#   Desarrollado por Joaquin Sanchiz Navarro  54064236E       #
#   Desarrollado por Carlos                                   #
###############################################################


class MyFleetManagerStrategy(FleetManagerStrategyBehaviour):
    """
    The default strategy for the FleetManager agent. By default it delegates all requests to all transports.
    """

    async def run(self):
        msg = await self.receive(timeout=5)
        if msg:

            content = json.loads(msg.body)
            id = content["customer_id"]
            pos = content["origin"]
            dest = content["dest"]

            closer_transport = None
            min_dist = math.inf
            for transport in self.get_transport_agents():

                if distance_in_meters(transport.get("current_pos"),pos) < min_dist:
                    closer_transport = transport
                    min_dist = distance_in_meters(transport.get("current_pos"),pos)

            msg.to = str(closer_transport.jid)
            self.logger.debug("FleetManager sent request to transport {}".format(closer_transport.name))
            await self.send(msg)


class MyTransportStrategy(TransportStrategyBehaviour):
    """
    The default strategy for the Transport agent. By default it accepts every request it receives if available.
    """

    async def run(self):
        msg = await self.receive(timeout=5)
        if not msg:
            return
        self.logger.debug("Transport received message: {}".format(msg))
        content = json.loads(msg.body)
        performative = msg.get_metadata("performative")

        self.logger.debug("Transport {} received request protocol from customer {}.".format(self.agent.name,
                                                                                        content["customer_id"]))
        if performative == REQUEST_PERFORMATIVE:
            if self.agent.status == TRANSPORT_WAITING:
                await self.send_proposal(content["customer_id"], {})
                self.agent.status = TRANSPORT_WAITING_FOR_APPROVAL

        elif performative == ACCEPT_PERFORMATIVE:
            if self.agent.status == TRANSPORT_WAITING_FOR_APPROVAL:
                self.logger.debug("Transport {} got accept from {}".format(self.agent.name,
                                                                      content["customer_id"]))
                try:
                    self.agent.status = TRANSPORT_MOVING_TO_CUSTOMER
                    await self.pick_up_customer(content["customer_id"], content["origin"], content["dest"])
                except PathRequestException:
                    self.logger.error("Transport {} could not get a path to customer {}. Cancelling..."
                                      .format(self.agent.name, content["customer_id"]))
                    self.agent.status = TRANSPORT_WAITING
                    await self.cancel_proposal(content["customer_id"])
                except Exception as e:
                    self.logger.error("Unexpected error in transport {}: {}".format(self.agent.name, e))
                    await self.cancel_proposal(content["customer_id"])
                    self.agent.status = TRANSPORT_WAITING
            else:
                await self.cancel_proposal(content["customer_id"])

        elif performative == REFUSE_PERFORMATIVE:
            self.logger.debug("Transport {} got refusal from {}".format(self.agent.name,
                                                                   content["customer_id"]))
            if self.agent.status == TRANSPORT_WAITING_FOR_APPROVAL:
                self.agent.status = TRANSPORT_WAITING


class MyCustomerStrategy(CustomerStrategyBehaviour):
    """
    The default strategy for the Customer agent. By default it accepts the first proposal it receives.
    """

    async def run(self):
        if self.agent.status == CUSTOMER_WAITING:
            await self.send_request(content={})

        msg = await self.receive(timeout=5)

        if msg:
            performative = msg.get_metadata("performative")
            transport_id = msg.sender
            if performative == PROPOSE_PERFORMATIVE:
                if self.agent.status == CUSTOMER_WAITING:
                    self.logger.debug("Customer {} received proposal from transport {}".format(self.agent.name,
                                                                                           transport_id))
                    await self.accept_transport(transport_id)
                    self.agent.status = CUSTOMER_ASSIGNED
                else:
                    await self.refuse_transport(transport_id)

            elif performative == CANCEL_PERFORMATIVE:
                if self.agent.transport_assigned == str(transport_id):
                    self.logger.warning("Customer {} received a CANCEL from Transport {}.".format(self.agent.name, transport_id))
                    self.agent.status = CUSTOMER_WAITING