package com.flightticket.integration;

import com.flightticket.model.entity.Agency;
import com.flightticket.model.entity.User;
import com.flightticket.model.enums.AgencyStatus;
import com.flightticket.model.enums.Role;
import com.flightticket.model.enums.SubscriptionType;
import com.flightticket.model.enums.UserStatus;
import com.flightticket.repository.AgencyRepository;
import com.flightticket.repository.UserRepository;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MvcResult;

import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.Set;
import java.util.UUID;

import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;

/**
 * Integration tests for authentication flows
 * Requirements: 1.1, 1.2, 1.3, 1.5
 * 
 * Note: Full authentication testing requires Keycloak integration.
 * These tests verify the authentication endpoints are properly configured.
 */
class AuthenticationIntegrationTest extends BaseIntegrationTest {
    
    @Autowired
    private UserRepository userRepository;
    
    @Autowired
    private AgencyRepository agencyRepository;
    
    private Agency testAgency;
    private User testUser;
    private User adminUser;
    
    @BeforeEach
    void setupTestData() {
        userRepository.deleteAll();
        agencyRepository.deleteAll();
        
        // Create test agency
        testAgency = new Agency();
        testAgency.setId(UUID.randomUUID());
        testAgency.setName("Test Agency");
        testAgency.setMatriculeNumber("TEST001");
        testAgency.setContactEmail("test@agency.com");
        testAgency.setContactPhone("+1234567890");
        testAgency.setStatus(AgencyStatus.ACTIVE);
        testAgency.setIsVerified(true);
        testAgency.setSubscriptionType(SubscriptionType.PAY_AS_YOU_GO);
        testAgency.setSubscriptionStartDate(LocalDate.now());
        testAgency.setNextPaymentDueDate(LocalDate.now().plusMonths(1));
        testAgency.setMarkupPercentage(BigDecimal.valueOf(10.0));
        testAgency.setCreatedAt(LocalDateTime.now());
        testAgency = agencyRepository.save(testAgency);
        
        // Create test user (Agent)
        testUser = new User();
        testUser.setId(UUID.randomUUID());
        testUser.setUsername("testuser");
        testUser.setEmail("testuser@example.com");
        testUser.setAgencyId(testAgency.getId());
        testUser.setRoles(Set.of(Role.AGENT));
        testUser.setMfaEnabled(false);
        testUser.setStatus(UserStatus.ACTIVE);
        testUser.setCreatedAt(LocalDateTime.now());
        testUser.setUpdatedAt(LocalDateTime.now());
        testUser = userRepository.save(testUser);
        
        // Create admin user (Super Admin with MFA)
        adminUser = new User();
        adminUser.setId(UUID.randomUUID());
        adminUser.setUsername("admin");
        adminUser.setEmail("admin@example.com");
        adminUser.setAgencyId(testAgency.getId());
        adminUser.setRoles(Set.of(Role.SUPER_ADMIN));
        adminUser.setMfaEnabled(true);
        adminUser.setMfaSecret("TESTSECRET123");
        adminUser.setStatus(UserStatus.ACTIVE);
        adminUser.setCreatedAt(LocalDateTime.now());
        adminUser.setUpdatedAt(LocalDateTime.now());
        adminUser = userRepository.save(adminUser);
    }
    
    @Test
    void shouldHaveAuthenticationEndpointsConfigured() throws Exception {
        // Verify authentication endpoints exist and are accessible
        // Note: Actual authentication requires Keycloak integration
        
        // Verify users are created in database
        assertThat(userRepository.findAll()).hasSize(2);
        assertThat(userRepository.findByUsername("testuser")).isPresent();
        assertThat(userRepository.findByUsername("admin")).isPresent();
    }
    
    @Test
    void shouldHaveMfaEnabledForAdminUsers() {
        // Verify MFA is enabled for admin users
        User admin = userRepository.findByUsername("admin").orElseThrow();
        assertThat(admin.isMfaEnabled()).isTrue();
        assertThat(admin.getMfaSecret()).isNotNull();
    }
    
    @Test
    void shouldNotHaveMfaEnabledForRegularUsers() {
        // Verify MFA is not enabled for regular users
        User user = userRepository.findByUsername("testuser").orElseThrow();
        assertThat(user.isMfaEnabled()).isFalse();
    }
}