from dataclasses import dataclass
from uuid import UUID, uuid4
from src.customer_cipher import CustomerCipher
from src.models import NKodePolicy
from src.user import User

@dataclass
class Customer:
    customer_id: UUID
    nkode_policy: NKodePolicy
    cipher: CustomerCipher
    users: dict[str, User]

    @classmethod
    def create(cls, nkode_policy: NKodePolicy, cipher: CustomerCipher) -> 'Customer':
        if nkode_policy.distinct_positions > cipher.keypad_size.numb_of_keys:
            raise ValueError("Distinct sets cannot be greater than the number of keys")
        if nkode_policy.distinct_properties > cipher.keypad_size.total_props:
            raise ValueError("Distinct properties cannot be greater than the total number of properties")
        return Customer(
            customer_id=uuid4(),
            nkode_policy=nkode_policy,
            cipher=cipher,
            users={}
        )

    def add_new_user(self, user: User):
        if user.username in self.users:
            raise ValueError(f"User with username '{user.username}' already exists")
        self.users[user.username] = user

    def valid_key_entry(self, username, selected_keys) -> bool:
        if username not in self.users:
            raise ValueError(f"User '{username}' does not exist")
        numb_of_keys = self.cipher.keypad_size.numb_of_keys
        if not all(0 <= key_idx < numb_of_keys for key_idx in selected_keys):
            raise ValueError(f"Invalid key indices. Must be between 0 and {numb_of_keys - 1}")
        passcode_len = len(selected_keys)
        user = self.users[username]
        passcode_set_vals = user.cipher.decipher_mask(
            user.enciphered_passcode.mask, self.cipher.position_key, passcode_len)
        set_vals_idx = [self.cipher.get_position_index(set_val) for set_val in passcode_set_vals]
        presumed_property_idxs = user.user_keypad.get_prop_idxs_by_keynumb_setidx(selected_keys, set_vals_idx)
        if not user.cipher.compare_nkode(presumed_property_idxs, self.cipher,user.enciphered_passcode.code):
            return False
        if user.renew:
            user.refresh_passcode(presumed_property_idxs, self.cipher)
        user.user_keypad.split_shuffle()
        #self.users[username] = user
        return True

    def renew_keys(self) -> bool:
        old_props = self.cipher.property_key.copy()
        old_sets = self.cipher.position_key.copy()
        self.cipher.renew()
        new_props = self.cipher.property_key
        new_sets = self.cipher.position_key

        props_xor = new_props ^ old_props
        set_xor = new_sets ^ old_sets
        for user in self.users.values():
            user.renew_keys(set_xor, props_xor)
            self.users[user.username] = user
        return True

    def valid_new_nkode(self, passcode_prop_idx: list[int]) -> bool:
        nkode_len = len(passcode_prop_idx)
        #passcode_set_values = [
        #    self.cipher.get_prop_set_val(int(self.cipher.property_key[prop_idx])) for prop_idx in passcode_prop_idx
        #]
        passcode_set_values = self.cipher.get_props_position_vals(passcode_prop_idx)
        distinct_sets = len(set(passcode_set_values))
        distinct_properties = len(set(passcode_prop_idx))
        if (
            self.nkode_policy.min_nkode_len <= nkode_len <= self.nkode_policy.max_nkode_len and
            distinct_sets >= self.nkode_policy.distinct_positions and
            distinct_properties >= self.nkode_policy.distinct_properties
        ):
            return True
        return False