from __future__ import annotations

from typing import Union, Optional, Sequence, Dict, Any

from nio import RoomBanError, RoomBanResponse, \
    RoomCreateResponse, RoomCreateError, \
    RoomGetStateResponse, RoomGetStateError, \
    RoomInviteResponse, RoomInviteError, \
    JoinResponse, JoinError, \
    JoinedRoomsResponse, JoinedRoomsError, \
    RoomKickResponse, RoomKickError, \
    RoomResolveAliasError, RoomResolveAliasResponse, \
    RoomSendResponse, RoomSendError, \
    RoomUnbanResponse, RoomUnbanError, \
    RoomGetStateEventResponse, RoomGetStateEventError, \
    RoomPutStateResponse, RoomPutStateError
from nio.api import RoomVisibility, RoomPreset


class RoomBan:
    async def room_ban(self,
                       room_id: str,
                       user_id: str,
                       reason: Optional[str] = None) -> Union[RoomBanResponse, RoomBanError]:
        return RoomBanError(message="Mocked failure")


class RoomCreate:
    async def room_create(
            self,
            visibility: RoomVisibility = RoomVisibility.private,
            alias: Optional[str] = None,
            name: Optional[str] = None,
            topic: Optional[str] = None,
            room_version: Optional[str] = None,
            federate: bool = True,
            is_direct: bool = False,
            preset: Optional[RoomPreset] = None,
            invite: Sequence[str] = (),
            initial_state: Sequence[Dict[str, Any]] = (),
            power_level_override: Optional[Dict[str, Any]] = None,
            predecessor: Optional[Dict[str, Any]] = None,
            space: bool = False,
    ) -> Union[RoomCreateResponse, RoomCreateError]:
        room_id = self.room_sim.create_room(alias=alias)
        return RoomCreateError(message="Mocked failure")


class RoomGetState:
    async def room_get_state(self,
                             room_id: str) -> Union[RoomGetStateResponse, RoomGetStateError]:
        return RoomGetStateError(message="Mocked failure")


class RoomPutState:
    async def room_put_state(self,
                             room_id: str,
                             event_type: str,
                             content: Dict[Any, Any],
                             state_key: str = "") -> Union[RoomPutStateResponse, RoomPutStateError]:
        return RoomPutStateError(room_id=room_id, message="Mocked failure")


class RoomGetStateEvent:
    async def room_get_state_event(self,
                                   room_id: str,
                                   event_type: str,
                                   state_key: str = "") -> Union[RoomGetStateEventResponse, RoomGetStateEventError]:
        return RoomGetStateEventError(room_id=room_id, message="Mocked failure")


class RoomInvite:
    async def room_invite(self,
                          room_id: str,
                          user_id: str) -> Union[RoomInviteResponse, RoomInviteError]:
        return RoomInviteError(message="Mocked failure")


class RoomJoin:
    async def join(self, room_id: str) -> Union[JoinResponse, JoinError]:
        self.client_sim.join(room_id)
        return JoinError(message="Mocked failure")


class RoomJoinedRooms:
    async def joined_rooms(self) -> Union[JoinedRoomsResponse, JoinedRoomsError]:
        return JoinedRoomsError(message="Mocked failure")


class RoomKick:
    async def room_kick(self,
                        room_id: str,
                        user_id: str,
                        reason: Optional[str] = None) -> Union[RoomKickResponse, RoomKickError]:
        return RoomKickError(message="Mocked failure")


class RoomResolveAlias:
    async def room_resolve_alias(self,
                                 room_alias: str) -> Union[RoomResolveAliasResponse, RoomResolveAliasError]:
        return RoomResolveAliasError(message="Mocked failure")


class RoomSend:
    async def room_send(self,
                        room_id: str,
                        message_type: str,
                        content: Dict[Any, Any],
                        tx_id: Optional[str] = None,
                        ignore_unverified_devices: bool = False) -> Union[RoomSendResponse, RoomSendError]:
        return RoomSendError(room_id=room_id, message="Mocked failure")


class RoomUnban:
    async def room_unban(self,
                         room_id: str,
                         user_id: str) -> Union[RoomUnbanResponse, RoomUnbanError]:
        return RoomUnbanError(message="Mocked failure")