package zw.qantra.tm.domain.services;

import lombok.Getter;
import lombok.RequiredArgsConstructor;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.List;
import java.util.UUID;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.stereotype.Service;

import zw.qantra.tm.domain.enums.CurrencyType;
import zw.qantra.tm.domain.enums.RequestType;
import zw.qantra.tm.domain.models.AdditionalData;
import zw.qantra.tm.domain.models.Currency;
import zw.qantra.tm.domain.models.Transaction;
import zw.qantra.tm.domain.repositories.TransactionRepository;
import zw.qantra.tm.exceptions.ApiException;
import zw.qantra.tm.utils.Utils;

@Service
@RequiredArgsConstructor
public class TransactionService {
    Logger logger = LoggerFactory.getLogger(TransactionService.class);

    @Getter
    private final TransactionRepository transactionRepository;
    private final AdditionalDataService additionalDataService;
    private final CurrencyService currencyService;

    public BigDecimal calculateCurrencyExchangeValue(CurrencyType from, CurrencyType to, BigDecimal amount) {
        if (to == null) {
            return BigDecimal.ZERO;
        }

        Currency debitCurrency = currencyService.findCurrencyByIsoCode(from.name());
        Currency creditCurrency = currencyService.findCurrencyByIsoCode(to.name());

        BigDecimal debitBankRate = new BigDecimal(debitCurrency.getBankRate());
        BigDecimal creditBankRate = new BigDecimal(creditCurrency.getBankRate());

        BigDecimal bankRate = creditBankRate.divide(debitBankRate, 4, RoundingMode.HALF_UP);

        return amount.multiply(bankRate).setScale(4, RoundingMode.HALF_UP);
    }

    public void reassignTransactions(UUID oldWorkspaceId, UUID newWorkspaceId){
        List<Transaction> transactions = transactionRepository.findAllByWorkspaceId(oldWorkspaceId);
        transactions.forEach(transaction -> {
            transaction.setWorkspaceId(newWorkspaceId);
            transactionRepository.save(transaction);
        });
    }

    public void reassignTransactions(String oldUserId, String newUserId){
        List<Transaction> transactions = transactionRepository.findAllByUserId(oldUserId);
        transactions.forEach(transaction -> {
            transaction.setUserId(newUserId);
            transactionRepository.save(transaction);
        });
    }

    public Transaction getTransaction(UUID id, UUID workspaceId) {
        return transactionRepository.findByIdAndWorkspaceId(id, workspaceId)
                .orElseThrow(() -> new ApiException("Transaction not found"));
    }

    public Transaction findById(UUID id) {
        Transaction transaction = transactionRepository.findById(id).orElseThrow(() ->
                new ApiException("Transaction not found for ID: " + id));

        try {
            AdditionalData additionalData = additionalDataService.getAdditionalDataRepository()
                    .findByTransactionIdAndRequestType(id.toString(), RequestType.INTEGRATION).orElseThrow(() ->
                    new ApiException("Additional data not found for transaction ID: " + id + " and request type: " + RequestType.INTEGRATION));
            transaction.setAdditionalData(Utils.fromJson(additionalData.getJsonString(), List.class));
        } catch (ApiException e) {
            // TODO Auto-generated catch block
            logger.info(e.getMessage());
        }

        return transaction;
    }

    public Page<Transaction> findAll(Specification<Transaction> spec, Pageable pageable) {
        return transactionRepository.findAll(spec, pageable);
    }

    public Transaction save(Transaction transaction) {
        return transactionRepository.save(transaction);
    }
}