package com.flightticket.integration;

import com.flightticket.model.entity.Agency;
import com.flightticket.model.entity.RechargeRequest;
import com.flightticket.model.entity.User;
import com.flightticket.model.entity.Wallet;
import com.flightticket.model.entity.WalletTransaction;
import com.flightticket.model.enums.*;
import com.flightticket.repository.*;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.test.context.support.WithMockUser;
import org.springframework.test.web.servlet.MvcResult;

import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.List;
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.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;

/**
 * Integration tests for wallet operations
 * Requirements: 4.1, 4.2, 4.3, 4.4, 4.5, 4.6, 4.7
 */
class WalletIntegrationTest extends BaseIntegrationTest {
    
    @Autowired
    private WalletRepository walletRepository;
    
    @Autowired
    private AgencyRepository agencyRepository;
    
    @Autowired
    private UserRepository userRepository;
    
    @Autowired
    private RechargeRequestRepository rechargeRequestRepository;
    
    @Autowired
    private WalletTransactionRepository walletTransactionRepository;
    
    private Agency testAgency;
    private Wallet testWallet;
    private User financeUser;
    private User superAdmin;
    
    @BeforeEach
    void setupTestData() {
        walletTransactionRepository.deleteAll();
        rechargeRequestRepository.deleteAll();
        walletRepository.deleteAll();
        userRepository.deleteAll();
        agencyRepository.deleteAll();
        
        // Create test agency
        testAgency = new Agency();
        testAgency.setId(UUID.randomUUID());
        testAgency.setName("Test Agency");
        testAgency.setMatriculeNumber("WALLET001");
        testAgency.setContactEmail("wallet@test.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 wallet
        testWallet = new Wallet();
        testWallet.setId(UUID.randomUUID());
        testWallet.setAgencyId(testAgency.getId());
        testWallet.setBalance(BigDecimal.valueOf(1000.00));
        testWallet.setReservedAmount(BigDecimal.ZERO);
        testWallet.setCurrency("DINAR");
        testWallet.setCreatedAt(LocalDateTime.now());
        testWallet.setUpdatedAt(LocalDateTime.now());
        testWallet = walletRepository.save(testWallet);
        
        // Create finance user
        financeUser = new User();
        financeUser.setId(UUID.randomUUID());
        financeUser.setUsername("financeuser");
        financeUser.setEmail("finance@test.com");
        financeUser.setAgencyId(testAgency.getId());
        financeUser.setRoles(Set.of(Role.FINANCE_USER));
        financeUser.setStatus(UserStatus.ACTIVE);
        financeUser.setCreatedAt(LocalDateTime.now());
        financeUser = userRepository.save(financeUser);
        
        // Create super admin
        superAdmin = new User();
        superAdmin.setId(UUID.randomUUID());
        superAdmin.setUsername("superadmin");
        superAdmin.setEmail("admin@platform.com");
        superAdmin.setRoles(Set.of(Role.SUPER_ADMIN));
        superAdmin.setStatus(UserStatus.ACTIVE);
        superAdmin.setCreatedAt(LocalDateTime.now());
        superAdmin = userRepository.save(superAdmin);
    }
    
    @Test
    @WithMockUser(username = "financeuser", roles = {"FINANCE_USER"})
    void shouldGetWalletByAgency() throws Exception {
        // When & Then
        mockMvc.perform(get("/api/v1/wallet/agency/" + testAgency.getId()))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.id").value(testWallet.getId().toString()))
                .andExpect(jsonPath("$.agencyId").value(testAgency.getId().toString()))
                .andExpect(jsonPath("$.balance").value(1000.00))
                .andExpect(jsonPath("$.reservedAmount").value(0.00))
                .andExpect(jsonPath("$.currency").value("DINAR"));
    }
    
    @Test
    @WithMockUser(username = "financeuser", roles = {"FINANCE_USER"})
    void shouldCreateRechargeRequest() throws Exception {
        // Given
        BigDecimal rechargeAmount = BigDecimal.valueOf(500.00);
        
        // When
        MvcResult result = mockMvc.perform(post("/api/v1/wallet/recharge")
                .param("agencyId", testAgency.getId().toString())
                .param("amount", rechargeAmount.toString()))
                .andExpect(status().isCreated())
                .andExpect(jsonPath("$.id").exists())
                .andExpect(jsonPath("$.amount").value(500.00))
                .andExpect(jsonPath("$.status").value("PENDING"))
                .andReturn();
        
        // Then - Verify wallet balance hasn't changed yet
        Wallet wallet = walletRepository.findById(testWallet.getId()).orElseThrow();
        assertThat(wallet.getBalance()).isEqualByComparingTo(BigDecimal.valueOf(1000.00));
    }
    
    @Test
    @WithMockUser(username = "superadmin", roles = {"SUPER_ADMIN"})
    void shouldApproveRechargeAndCreditWallet() throws Exception {
        // Given - Create a pending recharge request
        RechargeRequest rechargeRequest = new RechargeRequest();
        rechargeRequest.setId(UUID.randomUUID());
        rechargeRequest.setWalletId(testWallet.getId());
        rechargeRequest.setAmount(BigDecimal.valueOf(500.00));
        rechargeRequest.setStatus(RechargeStatus.PENDING);
        rechargeRequest.setRequestedBy(financeUser.getId());
        rechargeRequest.setRequestedAt(LocalDateTime.now());
        rechargeRequest = rechargeRequestRepository.save(rechargeRequest);
        
        BigDecimal initialBalance = testWallet.getBalance();
        
        // When
        mockMvc.perform(post("/api/v1/wallet/recharge/" + rechargeRequest.getId() + "/approve"))
                .andExpect(status().isOk());
        
        // Then - Verify wallet was credited
        Wallet updatedWallet = walletRepository.findById(testWallet.getId()).orElseThrow();
        assertThat(updatedWallet.getBalance())
                .isEqualByComparingTo(initialBalance.add(BigDecimal.valueOf(500.00)));
        
        // Verify recharge request status
        RechargeRequest updatedRequest = rechargeRequestRepository.findById(rechargeRequest.getId()).orElseThrow();
        assertThat(updatedRequest.getStatus()).isEqualTo(RechargeStatus.APPROVED);
        assertThat(updatedRequest.getApprovedBy()).isNotNull();
        assertThat(updatedRequest.getApprovedAt()).isNotNull();
        
        // Verify transaction record was created
        List<WalletTransaction> transactions = walletTransactionRepository.findByWalletIdOrderByCreatedAtDesc(testWallet.getId());
        assertThat(transactions).isNotEmpty();
        assertThat(transactions.get(0).getTransactionType()).isEqualTo(TransactionType.CREDIT_RECHARGE);
        assertThat(transactions.get(0).getAmount()).isEqualByComparingTo(BigDecimal.valueOf(500.00));
    }
    
    @Test
    @WithMockUser(username = "superadmin", roles = {"SUPER_ADMIN"})
    void shouldRejectRechargeRequest() throws Exception {
        // Given - Create a pending recharge request
        RechargeRequest rechargeRequest = new RechargeRequest();
        rechargeRequest.setId(UUID.randomUUID());
        rechargeRequest.setWalletId(testWallet.getId());
        rechargeRequest.setAmount(BigDecimal.valueOf(500.00));
        rechargeRequest.setStatus(RechargeStatus.PENDING);
        rechargeRequest.setRequestedBy(financeUser.getId());
        rechargeRequest.setRequestedAt(LocalDateTime.now());
        rechargeRequest = rechargeRequestRepository.save(rechargeRequest);
        
        BigDecimal initialBalance = testWallet.getBalance();
        String rejectionReason = "Insufficient documentation provided";
        
        // When
        mockMvc.perform(post("/api/v1/wallet/recharge/" + rechargeRequest.getId() + "/reject")
                .param("reason", rejectionReason))
                .andExpect(status().isOk());
        
        // Then - Verify wallet balance unchanged
        Wallet updatedWallet = walletRepository.findById(testWallet.getId()).orElseThrow();
        assertThat(updatedWallet.getBalance()).isEqualByComparingTo(initialBalance);
        
        // Verify recharge request status
        RechargeRequest updatedRequest = rechargeRequestRepository.findById(rechargeRequest.getId()).orElseThrow();
        assertThat(updatedRequest.getStatus()).isEqualTo(RechargeStatus.REJECTED);
        assertThat(updatedRequest.getRejectionReason()).isEqualTo(rejectionReason);
    }
    
    @Test
    @WithMockUser(username = "financeuser", roles = {"FINANCE_USER"})
    void shouldGetTransactionHistory() throws Exception {
        // Given - Create some transactions
        WalletTransaction transaction1 = createTransaction(TransactionType.CREDIT_RECHARGE, BigDecimal.valueOf(500.00));
        WalletTransaction transaction2 = createTransaction(TransactionType.DEBIT_TICKET, BigDecimal.valueOf(200.00));
        WalletTransaction transaction3 = createTransaction(TransactionType.CREDIT_REFUND, BigDecimal.valueOf(50.00));
        
        walletTransactionRepository.saveAll(List.of(transaction1, transaction2, transaction3));
        
        LocalDate fromDate = LocalDate.now().minusDays(1);
        LocalDate toDate = LocalDate.now().plusDays(1);
        
        // When & Then
        mockMvc.perform(get("/api/v1/wallet/transactions/" + testAgency.getId())
                .param("fromDate", fromDate.toString())
                .param("toDate", toDate.toString()))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.length()").value(3))
                .andExpect(jsonPath("$[*].transactionType").exists());
    }
    
    @Test
    @WithMockUser(username = "financeuser", roles = {"FINANCE_USER"})
    void shouldRejectTransactionWithInsufficientBalance() throws Exception {
        // Given - Set wallet balance to low amount
        testWallet.setBalance(BigDecimal.valueOf(50.00));
        walletRepository.save(testWallet);
        
        // When - Try to create recharge request for amount greater than balance
        // This test simulates the validation that should happen before debit
        // In real scenario, this would be tested through booking/ticketing endpoints
        
        // Then - Verify current balance
        mockMvc.perform(get("/api/v1/wallet/agency/" + testAgency.getId()))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.balance").value(50.00));
    }
    
    @Test
    @WithMockUser(username = "financeuser", roles = {"FINANCE_USER"})
    void shouldTrackBalanceBeforeAndAfterInTransactions() throws Exception {
        // Given - Create a transaction with balance tracking
        BigDecimal initialBalance = testWallet.getBalance();
        
        WalletTransaction transaction = new WalletTransaction();
        transaction.setId(UUID.randomUUID());
        transaction.setWalletId(testWallet.getId());
        transaction.setTransactionType(TransactionType.DEBIT_TICKET);
        transaction.setAmount(BigDecimal.valueOf(100.00));
        transaction.setBalanceBefore(initialBalance);
        transaction.setBalanceAfter(initialBalance.subtract(BigDecimal.valueOf(100.00)));
        transaction.setReference("TEST-REF-001");
        transaction.setDescription("Test ticket purchase");
        transaction.setCreatedAt(LocalDateTime.now());
        transaction.setCreatedBy(financeUser.getId());
        walletTransactionRepository.save(transaction);
        
        // When & Then - Verify transaction history shows balance tracking
        LocalDate fromDate = LocalDate.now().minusDays(1);
        LocalDate toDate = LocalDate.now().plusDays(1);
        
        mockMvc.perform(get("/api/v1/wallet/transactions/" + testAgency.getId())
                .param("fromDate", fromDate.toString())
                .param("toDate", toDate.toString()))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$[0].balanceBefore").value(initialBalance.doubleValue()))
                .andExpect(jsonPath("$[0].balanceAfter").value(initialBalance.subtract(BigDecimal.valueOf(100.00)).doubleValue()))
                .andExpect(jsonPath("$[0].amount").value(100.00));
    }
    
    private WalletTransaction createTransaction(TransactionType type, BigDecimal amount) {
        WalletTransaction transaction = new WalletTransaction();
        transaction.setId(UUID.randomUUID());
        transaction.setWalletId(testWallet.getId());
        transaction.setTransactionType(type);
        transaction.setAmount(amount);
        transaction.setBalanceBefore(testWallet.getBalance());
        transaction.setBalanceAfter(testWallet.getBalance().add(
                type == TransactionType.DEBIT_TICKET ? amount.negate() : amount));
        transaction.setReference("REF-" + UUID.randomUUID().toString().substring(0, 8));
        transaction.setDescription("Test transaction");
        transaction.setCreatedAt(LocalDateTime.now());
        transaction.setCreatedBy(financeUser.getId());
        return transaction;
    }
}