from .protocol import (
    make_status_request,
    make_set_relay,
    is_status_response,
    is_relay_response,
    is_error,
)


class CommunicationService:
    def __init__(self, uart_client, app_state, http_client=None):
        self.uart_client = uart_client
        self.http_client = http_client
        self.app_state = app_state
        self.last_messages = []
        self.use_http_fallback = False

    def request_status(self):
        if self.use_http_fallback and self.http_client:
            message = self.http_client.get_status()
            self.handle_message(message)
            return message

        self.uart_client.send_message(make_status_request())
        return None

    def set_relay(self, relay, enabled):
        if self.use_http_fallback and self.http_client:
            message = self.http_client.set_relay(relay, enabled)
            self.handle_message(message)
            return message

        self.uart_client.send_message(make_set_relay(relay, enabled))
        return None

    def poll(self):
        messages = self.uart_client.read_available_messages()
        self.last_messages = messages

        for message in messages:
            self.handle_message(message)

        return messages

    def enable_http_fallback(self):
        self.use_http_fallback = True

    def disable_http_fallback(self):
        self.use_http_fallback = False

    def handle_message(self, message):
        if is_status_response(message):
            self.app_state.update_from_status(message)
            return

        if is_relay_response(message):
            self.app_state.update_from_relay_response(message)
            return

        if is_error(message):
            self.app_state.set_error(message)
            return

        self.app_state.set_error({
            "type": "error",
            "message": "unknown_message_type",
            "raw": message,
        })