from uuid import UUID
from pydantic import BaseModel
from src.customer_attributes import CustomerAttributes
from src.models import NKodePolicy
from src.user import User
from src.utils import xor_lists


class Customer(BaseModel):
    customer_id: UUID
    nkode_policy: NKodePolicy
    attributes: CustomerAttributes
    users: dict[str, User]

    # TODO: validate policy and keypad size don't conflict


    def add_new_user(self, user: User):
        self.users[user.username] = user

    def valid_key_entry(self, username, selected_keys) -> bool:
        assert (username in self.users.keys())
        assert (all(0 <= key_idx < self.attributes.keypad_size.numb_of_keys for key_idx in selected_keys))
        passcode_len = len(selected_keys)
        user = self.users[username]

        passcode_set_vals = user.user_keys.decipher_mask(
            user.enciphered_passcode.mask, self.attributes.set_vals, passcode_len)
        set_vals_idx = [self.attributes.get_set_index(set_val) for set_val in passcode_set_vals]

        presumed_selected_attributes_idx = []
        for idx in range(passcode_len):
            key_numb = selected_keys[idx]
            set_idx = set_vals_idx[idx]
            selected_attr_idx = user.user_interface.get_attr_idx_by_keynumb_setidx(key_numb, set_idx)
            presumed_selected_attributes_idx.append(selected_attr_idx)

        enciphered_attr = user.user_keys.encipher_salt_hash_code(presumed_selected_attributes_idx, self.attributes)
        if enciphered_attr != user.enciphered_passcode.code:
            return False

        if user.renew:
            user.refresh_passcode(presumed_selected_attributes_idx, self.attributes)
        return True

    def renew_keys(self) -> bool:
        old_attrs = self.attributes.attr_vals.copy()
        old_sets = self.attributes.set_vals.copy()
        self.attributes.renew()
        new_attrs = self.attributes.attr_vals
        new_sets = self.attributes.set_vals

        attrs_xor = xor_lists(new_attrs, old_attrs)
        set_xor = xor_lists(new_sets, old_sets)
        for user in self.users.values():
            user.renew_keys(set_xor, attrs_xor)
            self.users[user.username] = user
        return True

    def valid_new_nkode(self, passcode_attr_idx: list[int]) -> bool:
        nkode_len = len(passcode_attr_idx)
        passcode_set_values = [
            self.attributes.get_attr_set_val(self.attributes.attr_vals[attr_idx]) for attr_idx in passcode_attr_idx
        ]
        distinct_sets = len(set(passcode_set_values))
        distinct_attributes = len(set(passcode_attr_idx))
        if (
            self.nkode_policy.min_nkode_len <= nkode_len <= self.nkode_policy.max_nkode_len and
            distinct_sets >= self.nkode_policy.distinct_sets and
            distinct_attributes >= self.nkode_policy.distinct_attributes
        ):
            return True
        return False