source: src/main/java/mk/ukim/finki/wp/bankappfinal/service/AccountService.java

package mk.ukim.finki.wp.bankappfinal.service;


import com.fasterxml.jackson.databind.ObjectMapper;
import jakarta.transaction.Transactional;
import mk.ukim.finki.wp.bankappfinal.model.Account;
import mk.ukim.finki.wp.bankappfinal.model.Transaction;
import mk.ukim.finki.wp.bankappfinal.repository.AccountRepository;
import mk.ukim.finki.wp.bankappfinal.repository.TransactionRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.io.ClassPathResource;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;

import java.io.IOException;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.*;

@Service
public class AccountService implements UserDetailsService {

    @Autowired
    PasswordEncoder passwordEncoder;

    @Autowired
    private AccountRepository accountRepository;

    @Autowired
    private TransactionRepository transactionRepository;

    private Map<String, BigDecimal>exchangeRates;

    private void loadExchangeRates() {
        try {
            ObjectMapper objectMapper = new ObjectMapper();

            Map<String, Object> rates = objectMapper.readValue(
                    new ClassPathResource("exchange_rates.json").getInputStream(),
                    Map.class
            );


            exchangeRates = new HashMap<>();
            for (Map.Entry<String, Object> entry : rates.entrySet()) {
                BigDecimal rate = convertToBigDecimal(entry.getValue());
                exchangeRates.put(entry.getKey(), rate);
            }
        } catch (IOException e) {
            throw new RuntimeException("Failed to load exchange rates", e);
        }
    }


    private BigDecimal convertToBigDecimal(Object value) {
        if (value instanceof Double) {
            return BigDecimal.valueOf((Double) value);
        } else if (value instanceof Integer) {
            return BigDecimal.valueOf((Integer) value);
        } else if (value instanceof BigDecimal) {
            return (BigDecimal) value;
        } else {
            throw new RuntimeException("Unsupported value type for exchange rate: " + value.getClass());
        }
    }

    public AccountService(){
        loadExchangeRates();
    }

    public Account findAccountByUsername(String username) {
        return accountRepository.findByUsername(username).orElseThrow(() -> new RuntimeException("Account not found"));
    }

    @Transactional
    public Account registerAccount(String username,String email, String password) {
        if (accountRepository.findByUsername(username).isPresent()) {
            throw new RuntimeException("Username already exists");
        }

        Account account = new Account();
        account.setUsername(username);
        account.setEmail(email);
        account.setPassword(passwordEncoder.encode(password)); // Encrypt password
        account.setBalance(BigDecimal.ZERO); // Initial balance set to 0
        return accountRepository.save(account);
    }

    @Transactional
    public void deposit(Account account, BigDecimal amount) {
        account.setBalance(account.getBalance().add(amount));
        accountRepository.save(account);

        Transaction transaction = new Transaction(
                amount,
                "(MKD)",
                "Deposit",
                LocalDateTime.now(),
                account
        );
        transactionRepository.save(transaction);
    }

    @Transactional
    public void withdraw(Account account, BigDecimal amount) {
        if (account.getBalance().compareTo(amount) < 0) {
            throw new RuntimeException("Insufficient funds");
        }
        account.setBalance(account.getBalance().subtract(amount));
        accountRepository.save(account);

        Transaction transaction = new Transaction(
                amount,
                "(MKD)",
                "Withdrawal",
                LocalDateTime.now(),
                account
        );
        transactionRepository.save(transaction);
    }

    @Transactional
    public List<Transaction> getTransactionHistory(Account account) {
        return transactionRepository.findByAccountId(account.getId());
    }

    @Transactional
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {

        Account account = findAccountByUsername(username);
        if (account == null) {
            throw new UsernameNotFoundException("Username or Password not found");
        }
        return new Account(
                account.getUsername(),
                account.getEmail(),
                account.getPassword(),
                account.getBalance(),
                account.getTransactions(),
                authorities());
    }

    public Collection<? extends GrantedAuthority> authorities() {
        return Arrays.asList(new SimpleGrantedAuthority("USER"));
    }

    @Transactional
    public void transferAmount(Account fromAccount, String toUsername, BigDecimal amount, String currency) {

        if(fromAccount.getUsername().compareTo(toUsername) == 0){
            throw new RuntimeException("No transaction allowed to yourself");
        }

        Account toAccount = accountRepository.findByUsername(toUsername)
                .orElseThrow(() -> new RuntimeException("Recipient account not found"));

        BigDecimal rate = exchangeRates.getOrDefault(currency, BigDecimal.ONE);
        BigDecimal convertedAmount = amount.multiply(rate);


        if(currency.compareTo("(MKD)")==0){
            if (fromAccount.getBalance().compareTo(convertedAmount) < 0) {
                throw new RuntimeException("Insufficient funds");
            }
            else{
                // Deduct from sender's account
                fromAccount.setBalance(fromAccount.getBalance().subtract(convertedAmount));
                accountRepository.save(fromAccount);

                // Add to recipient's account
                toAccount.setBalance(toAccount.getBalance().add(convertedAmount));
                accountRepository.save(toAccount);

                // Create transaction records for both accounts
                Transaction debitTransaction = new Transaction(
                        amount,
                        currency,
                        "(MKD) Transfer Out to " + toAccount.getUsername(),
                        LocalDateTime.now(),
                        fromAccount
                );
                transactionRepository.save(debitTransaction);

                Transaction creditTransaction = new Transaction(
                        amount,
                        currency,
                        "(MKD) Transfer In from " + fromAccount.getUsername(),
                        LocalDateTime.now(),
                        toAccount
                );
                transactionRepository.save(creditTransaction);
            }
        }

        if(currency.compareTo("(EUR)")==0){
            if (fromAccount.getBalance().compareTo(convertedAmount) < 0) {
                throw new RuntimeException("Insufficient funds");
            }
            else{
                // Deduct from sender's account
                fromAccount.setBalance(fromAccount.getBalance().subtract(convertedAmount));
                accountRepository.save(fromAccount);

                // Add to recipient's account
                toAccount.setBalance(toAccount.getBalance().add(convertedAmount));
                accountRepository.save(toAccount);

                // Create transaction records for both accounts
                Transaction debitTransaction = new Transaction(
                        amount,
                        currency,
                        "(EUR) Transfer Out to " + toAccount.getUsername(),
                        LocalDateTime.now(),
                        fromAccount
                );

                transactionRepository.save(debitTransaction);

                Transaction creditTransaction = new Transaction(
                        amount,
                        currency,
                        "(EUR) Transfer In from " + fromAccount.getUsername(),
                        LocalDateTime.now(),
                        toAccount
                );
                transactionRepository.save(creditTransaction);
            }
        }

        if(currency.compareTo("(USD)")==0){
            if (fromAccount.getBalance().compareTo(convertedAmount)<0) {
                throw new RuntimeException("Insufficient funds");
            }
            else{
                // Deduct from sender's account
                fromAccount.setBalance(fromAccount.getBalance().subtract(convertedAmount));
                accountRepository.save(fromAccount);

                // Add to recipient's account
                toAccount.setBalance(toAccount.getBalance().add(convertedAmount));
                accountRepository.save(toAccount);

                // Create transaction records for both accounts
                Transaction debitTransaction = new Transaction(
                        amount,
                        currency,
                        "(USD) Transfer Out to " + toAccount.getUsername(),
                        LocalDateTime.now(),
                        fromAccount
                );
                transactionRepository.save(debitTransaction);

                Transaction creditTransaction = new Transaction(
                        amount,
                        currency,
                        "(USD) Transfer In from " + fromAccount.getUsername(),
                        LocalDateTime.now(),
                        toAccount
                );
                transactionRepository.save(creditTransaction);
            }
        }

        if(currency.compareTo("(GBP)")==0){
            if (fromAccount.getBalance().compareTo(convertedAmount)<0) {
                throw new RuntimeException("Insufficient funds");
            }
            else{
                // Deduct from sender's account
                fromAccount.setBalance(fromAccount.getBalance().subtract(convertedAmount));
                accountRepository.save(fromAccount);

                // Add to recipient's account
                toAccount.setBalance(toAccount.getBalance().add(convertedAmount));
                accountRepository.save(toAccount);

                // Create transaction records for both accounts
                Transaction debitTransaction = new Transaction(
                        amount,
                        currency,
                        "(GBP) Transfer Out to " + toAccount.getUsername(),
                        LocalDateTime.now(),
                        fromAccount
                );
                transactionRepository.save(debitTransaction);

                Transaction creditTransaction = new Transaction(
                        amount,
                        currency,
                        "(GBP) Transfer In from " + fromAccount.getUsername(),
                        LocalDateTime.now(),
                        toAccount
                );
                transactionRepository.save(creditTransaction);
            }
        }

    }

}