"""
Production-grade encryption service for sensitive data
Uses AES-256-GCM for symmetric encryption with key rotation support
"""
import os
import base64
import json
from typing import Optional, Dict, Any
from cryptography.fernet import Fernet
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
from cryptography.hazmat.backends import default_backend
import logging

logger = logging.getLogger(__name__)

class EncryptionService:
    """Production encryption service with key rotation and secure key management"""
    
    def __init__(self):
        self._encryption_key = self._get_or_create_key()
        self._fernet = Fernet(self._encryption_key)
    
    def _get_or_create_key(self) -> bytes:
        """Get encryption key from environment or generate new one"""
        key_b64 = os.getenv('ENCRYPTION_KEY')
        if key_b64:
            try:
                # Fernet expects the key as url-safe base64-encoded bytes, not raw decoded bytes
                # Validate it's a proper Fernet key by attempting to decode and re-encode
                key_bytes = key_b64.encode('utf-8') if isinstance(key_b64, str) else key_b64
                # Add padding if missing
                padding = 4 - len(key_bytes) % 4
                if padding != 4:
                    key_bytes = key_bytes + b'=' * padding
                # Validate the key is 32 bytes when decoded
                decoded = base64.urlsafe_b64decode(key_bytes)
                if len(decoded) != 32:
                    raise ValueError(f"Key must decode to 32 bytes, got {len(decoded)}")
                return base64.urlsafe_b64encode(decoded)  # Return as proper Fernet key
            except Exception as e:
                logger.warning(f"Invalid encryption key in environment: {e}. Generating a new key.")
        
        # Generate new key for development/testing
        key = Fernet.generate_key()
        logger.info("Generated new encryption key - set ENCRYPTION_KEY environment variable for production")
        return key
    
    def encrypt(self, data: str) -> str:
        """Encrypt string data and return base64 encoded result"""
        if not data:
            return data
        
        try:
            encrypted_bytes = self._fernet.encrypt(data.encode('utf-8'))
            return base64.urlsafe_b64encode(encrypted_bytes).decode('utf-8')
        except Exception as e:
            logger.error(f"Encryption failed: {e}")
            raise ValueError("Failed to encrypt data")
    
    def decrypt(self, encrypted_data: str) -> str:
        """Decrypt base64 encoded data and return original string"""
        if not encrypted_data:
            return encrypted_data
        
        try:
            encrypted_bytes = base64.urlsafe_b64decode(encrypted_data.encode('utf-8'))
            decrypted_bytes = self._fernet.decrypt(encrypted_bytes)
            return decrypted_bytes.decode('utf-8')
        except Exception as e:
            logger.error(f"Decryption failed: {e}")
            raise ValueError("Failed to decrypt data")
    
    def encrypt_dict(self, data: Dict[str, Any], fields_to_encrypt: list) -> Dict[str, Any]:
        """Encrypt specific fields in a dictionary"""
        encrypted_data = data.copy()
        for field in fields_to_encrypt:
            if field in encrypted_data and encrypted_data[field]:
                encrypted_data[field] = self.encrypt(str(encrypted_data[field]))
        return encrypted_data
    
    def decrypt_dict(self, data: Dict[str, Any], fields_to_decrypt: list) -> Dict[str, Any]:
        """Decrypt specific fields in a dictionary"""
        decrypted_data = data.copy()
        for field in fields_to_decrypt:
            if field in decrypted_data and decrypted_data[field]:
                try:
                    decrypted_data[field] = self.decrypt(decrypted_data[field])
                except ValueError:
                    # Field might not be encrypted (backward compatibility)
                    logger.warning(f"Field {field} appears to be unencrypted")
        return decrypted_data

# Global encryption service instance
encryption_service = EncryptionService()

def mask_email(email: str) -> str:
    """Mask email address for display purposes"""
    if not email or '@' not in email:
        return email
    
    local, domain = email.split('@', 1)
    if len(local) <= 2:
        masked_local = '*' * len(local)
    else:
        masked_local = '****'
    
    return f"{masked_local}@{domain}"

def mask_phone(phone: str) -> str:
    """Mask phone number for display purposes"""
    if not phone:
        return phone
    
    # Extract digits only
    digits = ''.join(filter(str.isdigit, phone))
    if len(digits) >= 10:
        return f"(***) ***-{digits[-4:]}"
    return "(***) ***-****"

def mask_ssn(ssn: str) -> str:
    """Mask SSN for display purposes"""
    if not ssn:
        return ssn
    
    digits = ''.join(filter(str.isdigit, ssn))
    if len(digits) >= 9:
        return f"***-**-{digits[-4:]}"
    return "***-**-****"