package com.social.media.infrastructure.persistence.mapper;

import com.social.media.domain.company.valueobject.CompanyId;
import com.social.media.domain.shared.valueobject.Email;
import com.social.media.domain.shared.valueobject.Phone;
import com.social.media.domain.user.aggregate.User;
import com.social.media.domain.user.valueobject.*;
import com.social.media.domain.shared.enums.UserType;
import com.social.media.domain.shared.enums.UserStatus;
import com.social.media.infrastructure.persistence.entity.UserEntity;
import com.social.media.infrastructure.persistence.entity.UserStatusEntity;
import com.social.media.infrastructure.persistence.entity.UserTypeEntity;
import org.springframework.stereotype.Component;

/**
 * Mapper between User domain aggregate and UserEntity
 */
@Component
public class UserEntityMapper {
    
    /**
     * Convert User domain aggregate to UserEntity
     */
    public UserEntity toEntity(User user) {
        if (user == null) {
            return null;
        }
        
        UserEntity entity = new UserEntity();
        entity.setId(user.getId().value());
        entity.setCompanyId(user.getCompanyId().value());
        entity.setName(user.getName());
        entity.setEmail(user.getEmail().value());
        entity.setCpf(user.getCpf().value());
        entity.setPhone(user.getPhone() != null ? user.getPhone().value() : null);
        entity.setPasswordHash(user.getPasswordHash());
        entity.setStatus(mapToEntityStatus(user.getStatus()));
        entity.setType(mapToEntityType(user.getType()));
        entity.setEmailVerified(user.isEmailVerified());
        entity.setLastAccessDate(user.getLastAccessDate());
        entity.setCreatedAt(user.getCreatedAt());
        entity.setUpdatedAt(user.getUpdatedAt());
        entity.setDeleted(user.isDeleted());
        
        return entity;
    }
    
    /**
     * Convert UserEntity to User domain aggregate
     */
    public User toDomain(UserEntity entity) {
        if (entity == null) {
            return null;
        }
        
        return User.reconstruct(
            UserId.of(entity.getId()),
            CompanyId.of(entity.getCompanyId()),
            entity.getName(),
            new Email(entity.getEmail()),
            new Cpf(entity.getCpf()),
            entity.getPhone() != null ? new Phone(entity.getPhone()) : null,
            false, // whatsappEnabled - not in entity yet
            entity.getPasswordHash(),
            null, // avatarUrl - not in entity yet
            null, // position - not in entity yet
            null, // department - not in entity yet
            entity.getCreatedAt(), // registrationDate
            entity.getLastAccessDate(), // lastAccessDate
            mapToDomainStatus(entity.getStatus()),
            mapToDomainType(entity.getType()),
            UserPermissions.empty(), // default permissions
            entity.getEmailVerified(),
            null, // verificationToken - removed from entity
            null, // passwordResetToken - removed from entity
            null, // passwordResetExpiry - removed from entity
            null, // parentUserId - not in entity yet
            UserConfiguration.defaultConfig(), // default configuration
            entity.getDeleted() != null ? entity.getDeleted() : false, // deleted
            entity.getCreatedAt(),
            entity.getUpdatedAt()
        );
    }
    
    private UserStatusEntity mapToEntityStatus(UserStatus status) {
        return switch (status) {
            case ACTIVE -> UserStatusEntity.ACTIVE;
            case INACTIVE -> UserStatusEntity.INACTIVE;
            case SUSPENDED -> UserStatusEntity.SUSPENDED;
            case PENDING -> UserStatusEntity.PENDING;
            case BLOCKED -> UserStatusEntity.BLOCKED;
        };
    }
    
    private UserStatus mapToDomainStatus(UserStatusEntity status) {
        return switch (status) {
            case ACTIVE -> UserStatus.ACTIVE;
            case INACTIVE -> UserStatus.INACTIVE;
            case SUSPENDED -> UserStatus.SUSPENDED;
            case PENDING -> UserStatus.PENDING;
            case BLOCKED -> UserStatus.BLOCKED;
        };
    }
    
    private UserTypeEntity mapToEntityType(UserType type) {
        return switch (type) {
            case SUPER_ADMIN -> UserTypeEntity.SUPER_ADMIN;
            case ADMIN -> UserTypeEntity.ADMIN;
            case MANAGER -> UserTypeEntity.MANAGER;
            case USER -> UserTypeEntity.USER;
            case VIEWER -> UserTypeEntity.VIEWER;
        };
    }

    private UserType mapToDomainType(UserTypeEntity type) {
        return switch (type) {
            case SUPER_ADMIN -> UserType.SUPER_ADMIN;
            case ADMIN -> UserType.ADMIN;
            case MANAGER -> UserType.MANAGER;
            case USER -> UserType.USER;
            case VIEWER -> UserType.VIEWER;
        };
    }
}