package com.social.media.application.shared.utils;

import com.social.media.domain.shared.enums.UserType;
import com.social.media.infrastructure.persistence.entity.UserTypeEntity;
import com.social.media.domain.shared.enums.UserStatus;
import com.social.media.infrastructure.persistence.entity.UserStatusEntity;

/**
 * Utility class for converting between domain enums and JPA entities
 */
public class EnumConversionUtils {
    
    /**
     * Convert UserType domain enum to UserTypeEntity
     */
    public static UserTypeEntity toUserTypeEntity(UserType userType) {
        if (userType == null) {
            return null;
        }
        
        return switch (userType) {
            case SUPER_ADMIN -> UserTypeEntity.SUPER_ADMIN;
            case ADMIN -> UserTypeEntity.ADMIN;
            case MANAGER -> UserTypeEntity.MANAGER;
            case USER -> UserTypeEntity.USER;
            case VIEWER -> UserTypeEntity.VIEWER;
        };
    }
    
    /**
     * Convert UserTypeEntity to UserType domain enum
     */
    public static UserType fromUserTypeEntity(UserTypeEntity userTypeEntity) {
        if (userTypeEntity == null) {
            return null;
        }
        
        return switch (userTypeEntity) {
            case SUPER_ADMIN -> UserType.SUPER_ADMIN;
            case ADMIN -> UserType.ADMIN;
            case MANAGER -> UserType.MANAGER;
            case USER -> UserType.USER;
            case VIEWER -> UserType.VIEWER;
        };
    }
    
    /**
     * Convert UserStatus domain enum to UserStatusEntity
     */
    public static UserStatusEntity toUserStatusEntity(UserStatus userStatus) {
        if (userStatus == null) {
            return null;
        }
        
        return switch (userStatus) {
            case ACTIVE -> UserStatusEntity.ACTIVE;
            case INACTIVE -> UserStatusEntity.INACTIVE;
            case PENDING -> UserStatusEntity.PENDING;
            case SUSPENDED -> UserStatusEntity.SUSPENDED;
            case BLOCKED -> UserStatusEntity.BLOCKED;
        };
    }
    
    /**
     * Convert UserStatusEntity to UserStatus domain enum
     */
    public static UserStatus fromUserStatusEntity(UserStatusEntity userStatusEntity) {
        if (userStatusEntity == null) {
            return null;
        }
        
        return switch (userStatusEntity) {
            case ACTIVE -> UserStatus.ACTIVE;
            case INACTIVE -> UserStatus.INACTIVE;
            case PENDING -> UserStatus.PENDING;
            case SUSPENDED -> UserStatus.SUSPENDED;
            case BLOCKED -> UserStatus.BLOCKED;
        };
    }
    
    /**
     * Check if UserType has admin privileges
     */
    public static boolean isAdmin(UserType userType) {
        return userType == UserType.ADMIN || userType == UserType.SUPER_ADMIN;
    }
    
    /**
     * Check if UserTypeEntity has admin privileges
     */
    public static boolean isAdmin(UserTypeEntity userTypeEntity) {
        return userTypeEntity == UserTypeEntity.ADMIN || userTypeEntity == UserTypeEntity.SUPER_ADMIN;
    }
    
    /**
     * Check if UserType is super admin
     */
    public static boolean isSuperAdmin(UserType userType) {
        return userType == UserType.SUPER_ADMIN;
    }
    
    /**
     * Check if UserTypeEntity is super admin
     */
    public static boolean isSuperAdmin(UserTypeEntity userTypeEntity) {
        return userTypeEntity == UserTypeEntity.SUPER_ADMIN;
    }
    
    /**
     * Get admin types for queries
     */
    public static UserTypeEntity[] getAdminTypes() {
        return new UserTypeEntity[]{UserTypeEntity.ADMIN, UserTypeEntity.SUPER_ADMIN};
    }
    
    /**
     * Get admin types as string array for native queries
     */
    public static String[] getAdminTypesAsStrings() {
        return new String[]{"ADMIN", "SUPER_ADMIN"};
    }
    
    /**
     * Check if user can access resource based on ownership and user type
     */
    public static boolean canAccessResource(UserType userType, Long resourceOwnerId, Long requestingUserId) {
        // Super admin and admin can access everything
        if (isAdmin(userType)) {
            return true;
        }
        
        // Regular users can only access their own resources
        return resourceOwnerId != null && resourceOwnerId.equals(requestingUserId);
    }
    
    /**
     * Check if user can modify resource based on ownership and user type
     */
    public static boolean canModifyResource(UserType userType, Long resourceOwnerId, Long requestingUserId) {
        // Super admin can modify everything
        if (isSuperAdmin(userType)) {
            return true;
        }
        
        // Admin can modify resources in their company (handled at repository level)
        if (userType == UserType.ADMIN) {
            return true;
        }
        
        // Regular users can only modify their own resources
        return resourceOwnerId != null && resourceOwnerId.equals(requestingUserId);
    }
}