from uuid import UUID, uuid4
from pydantic import BaseModel
from src.customer import Customer
from src.models import NKodePolicy, KeypadSize
from src.user import User
from src.user_cipher_keys import UserCipherKeys
from src.user_signup_session import UserSignupSession
from src.user_interface import UserInterface
from src.customer_attributes import CustomerAttributes


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

    def create_new_customer(self, keypad_size: KeypadSize, nkode_policy: NKodePolicy) -> UUID:
        new_customer = Customer(
            customer_id=uuid4(),
            attributes=CustomerAttributes.new(keypad_size),
            users={},
            nkode_policy=nkode_policy
        )
        self.customers[new_customer.customer_id] = new_customer

        return new_customer.customer_id

    def generate_signup_interface(self, customer_id: UUID) -> tuple[UUID, list[int]]:
        assert (customer_id in self.customers.keys())
        customer = self.customers[customer_id]
        login_interface = UserInterface.new(customer.attributes.keypad_size)
        set_interface = login_interface.sign_up_interface()
        new_session = UserSignupSession(
            session_id=uuid4(),
            login_interface=login_interface,
            set_interface=set_interface.interface,
            customer_id=customer_id,
            keypad_size=set_interface.keypad_size,
        )
        self.signup_sessions[new_session.session_id] = new_session
        return new_session.session_id, new_session.set_interface

    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.signup_sessions.keys())
        self.signup_sessions[session_id].set_user_nkode(username, key_selection)
        return self.signup_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.signup_sessions.keys() and
                customer_id == self.signup_sessions[session_id].customer_id and
                username == self.signup_sessions[session_id].username
        )
        customer = self.customers[customer_id]

        passcode = self.signup_sessions[session_id].deduce_passcode(confirm_key_entry)
        new_user_keys = UserCipherKeys.new(
            customer.attributes.keypad_size,
            customer.attributes.set_vals,
            customer.nkode_policy.max_nkode_len
        )

        enciphered_passcode = new_user_keys.encipher_nkode(passcode, customer.attributes)
        new_user = User(
            username=username,
            enciphered_passcode=enciphered_passcode,
            user_keys=new_user_keys,
            user_interface=self.signup_sessions[session_id].login_interface,
        )
        self.customers[customer_id].add_new_user(new_user)
        del self.signup_sessions[session_id]
        return True

    def get_login_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.partial_interface_shuffle()
        return user.user_interface.interface

    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_attributes(self, customer_id: UUID) -> bool:
        assert (customer_id in self.customers.keys())
        return self.customers[customer_id].renew_keys()