from uuid import UUID, uuid4
from pydantic import BaseModel

from src.models import EncipheredNKode
from src.user_cipher_keys import UserCipherKeys
from src.user_interface import UserInterface
from src.nkode_interface import CustomerInterface


class UserDBModel(BaseModel):
    username: str
    enciphered_passcode: EncipheredNKode
    user_keys: UserCipherKeys
    user_interface: UserInterface


class CustomerDBModel(BaseModel):
    customer_id: UUID
    interface: CustomerInterface
    users: list[UserDBModel]


class SessionCacheModel(BaseModel):
    session_id: UUID
    set_interface: list[int] | None = None
    confirm_interface: list[int] | None = None
    set_key_entry: list[int] | None = None
    confirm_key_entry: list[int] | None = None
    username: str | None = None
    customer_id: UUID

    #   timeout: datetime


class PseudoNKodeAPI(BaseModel):
    customers: dict[UUID, CustomerDBModel] = {}
    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_interface(customer.interface.attrs_per_key, customer.interface.numb_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):
        pass

    def set_nkode(
            self, username: str, customer_id: UUID,
            key_selection: list[int], session_id: UUID) -> list[int]:
        assert (username not in [user.username for user in self.customers[customer_id].users])
        assert (session_id in self.sessions.keys())
        assert (customer_id == self.sessions[session_id].customer_id)
        numb_of_keys = self.customers[customer_id].interface.numb_keys
        attrs_per_key = self.customers[customer_id].interface.attrs_per_key
        assert (all(0 <= key <= numb_of_keys for key in key_selection))
        session = self.sessions[session_id]
        set_interface = UserInterface(
            interface_index=session.set_interface,
            numb_sets=attrs_per_key,
            numb_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):
        assert (
                session_id in self.sessions.keys() and
                customer_id == self.sessions[session_id].customer_id and
                username == self.sessions[session_id].username
        )
        customer = self.customers[customer_id]
        numb_of_keys = customer.interface.numb_keys
        attrs_per_key = customer.interface.attrs_per_key
        assert(all(0 <= key <= numb_of_keys for key in confirm_key_entry))
        passcode = self._deduce_passcode(session_id, numb_of_keys, attrs_per_key, confirm_key_entry)
        set_values = customer.interface.set_vals
        new_user_keys = UserCipherKeys.new_user_encipher_keys(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,
                numb_sets=attrs_per_key,
                numb_keys=numb_of_keys
            )
        )
        self.customers[customer_id].users.append(new_user)
        return "success"
        # del self.sessions[session_id]

    def _deduce_passcode(self, session_id: UUID, numb_of_keys: int, attrs_per_key, confirm_key_entry: list[int]) -> list[int]:
        session = self.sessions[session_id]
        set_key_entry = session.set_key_entry
        assert (len(set_key_entry) == len(confirm_key_entry))
        set_interface = session.set_interface
        confirm_interface = session.confirm_interface
        set_key_vals = [set_interface[key*attrs_per_key:(key+1)*attrs_per_key] for key in set_key_entry]
        confirm_key_vals = [confirm_interface[key*attrs_per_key:(key+1)*attrs_per_key] for key in confirm_key_entry]

        passcode = []
        for idx in range(len(set_key_entry)):
            set_key = set(set_key_vals[idx])
            confirm_key = set(confirm_key_vals[idx])
            intersection = list(set_key.intersection(confirm_key))
            assert (len(intersection) == 1)
            passcode.append(intersection[0])
        return passcode

    def login(self):
        pass

    def renew_keys(self):
        pass

    def create_new_customer(self, numb_keys: int, numb_sets: int) -> CustomerDBModel:
        new_customer = CustomerDBModel(
            customer_id=uuid4(),
            interface=CustomerInterface.new_interface(numb_keys, numb_sets),
            users=[],
        )
        self.customers[new_customer.customer_id] = new_customer

        return new_customer