from uuid import UUID, uuid4
from pydantic import BaseModel

from src.customer import Customer
from src.models import NKodePolicy
from src.session_cache import SessionCacheModel
from src.user_cipher_keys import UserCipherKeys
from src.user_db_model import UserDBModel
from src.user_interface import UserInterface
from src.customer_interface import CustomerInterface


class NKodeAPI(BaseModel):
    customers: dict[UUID, Customer] = {}
    sessions: dict[UUID, SessionCacheModel] = {}

    def generate_index_interface(self, customer_id: UUID) -> tuple[UUID, list[int]]:
        assert (customer_id in self.customers.keys())
        customer = self.customers[customer_id]
        set_interface = UserInterface.new(customer.interface.attrs_per_key, customer.interface.numb_of_keys)
        new_session = SessionCacheModel(
            session_id=uuid4(),
            set_interface=set_interface.interface_index,
            customer_id=customer_id,
        )
        self.sessions[new_session.session_id] = new_session
        return new_session.session_id, new_session.set_interface

    def get_login_index_interface(self, username: str, customer_id: UUID) -> list[int]:
        """
        TODO: how do we prevent a targeted denial-of-service attack?
        """
        assert (customer_id in self.customers.keys())
        customer = self.customers[customer_id]
        assert (username in customer.users.keys())
        user = customer.users[username]
        user.user_interface.shuffle_interface()
        return user.user_interface.interface_index

    def set_nkode(
            self, username: str, customer_id: UUID,
            key_selection: list[int], session_id: UUID) -> list[int]:
        assert (customer_id in self.customers.keys())
        customer = self.customers[customer_id]
        assert (username not in customer.users.keys())
        assert (session_id in self.sessions.keys())
        session = self.sessions[session_id]
        assert (customer_id == session.customer_id)
        numb_of_keys = customer.interface.numb_of_keys
        attrs_per_key = customer.interface.attrs_per_key
        assert (all(0 <= key <= numb_of_keys for key in key_selection))
        set_interface = UserInterface(
            interface_index=session.set_interface,
            attrs_per_key=attrs_per_key,
            numb_of_keys=numb_of_keys,
        )
        set_interface.disperse_interface()
        session.username = username
        session.set_key_entry = key_selection
        session.confirm_interface = set_interface.interface_index
        self.sessions[session_id] = session
        return self.sessions[session_id].confirm_interface

    def confirm_nkode(self, username: str, customer_id: UUID, confirm_key_entry: list[int], session_id: UUID) -> bool:
        assert (
                session_id in self.sessions.keys() and
                customer_id == self.sessions[session_id].customer_id and
                username == self.sessions[session_id].username
        )
        session = self.sessions[session_id]
        customer = self.customers[customer_id]
        numb_of_keys = customer.interface.numb_of_keys
        attrs_per_key = customer.interface.attrs_per_key
        assert (all(0 <= key <= numb_of_keys for key in confirm_key_entry))
        passcode = session.deduce_passcode(attrs_per_key, confirm_key_entry)
        set_values = customer.interface.set_vals
        if not customer.valid_new_nkode(passcode):
            return False
        new_user_keys = UserCipherKeys.new(numb_of_keys, attrs_per_key, set_values)
        enciphered_passcode = new_user_keys.encipher_nkode(passcode, customer.interface)
        new_user = UserDBModel(
            username=username,
            enciphered_passcode=enciphered_passcode,
            user_keys=new_user_keys,
            user_interface=UserInterface(
                interface_index=self.sessions[session_id].confirm_interface,
                attrs_per_key=attrs_per_key,
                numb_of_keys=numb_of_keys,
            ),
        )
        self.customers[customer_id].add_new_user(new_user)
        return True
        # del self.sessions[session_id]

    def login(self, customer_id: UUID, username: str, key_selection: list[int]) -> bool:
        assert (customer_id in self.customers.keys())
        customer = self.customers[customer_id]
        return customer.valid_key_entry(username, key_selection)

    def renew_keys(self, customer_id: UUID) -> bool:
        assert (customer_id in self.customers.keys())
        return self.customers[customer_id].renew_keys()

    def create_new_customer(self, numb_keys: int, numb_sets: int, nkode_policy: NKodePolicy) -> UUID:
        new_customer = Customer(
            customer_id=uuid4(),
            interface=CustomerInterface.new(numb_keys, numb_sets),
            users={},
            nkode_policy=nkode_policy
        )
        self.customers[new_customer.customer_id] = new_customer

        return new_customer.customer_id