//
//  MemPool.swift
//  SwiftChain
//
//  Created by Victor on 27/11/2024.
//

public class MemPool {
    private var pendingTransactions: [Transaction] = []
    private let maxTransactionsPerBlock: Int = 10
    private let accountManager: AccountManager

    init(accountManager: AccountManager) {
        self.accountManager = accountManager
    }

    /**
     Ajoute une transaction au mempool après validation
     */
    func addTransaction(_ transaction: Transaction) -> Bool {
        if validateTransaction(transaction) {
            pendingTransactions.append(transaction)
            return true
        }
        return false
    }

    /**
     Valide une transaction avant de l'ajouter au pool
     */
    private func validateTransaction(_ transaction: Transaction) -> Bool {
        // Vérifications basiques
        if transaction.amount <= 0 {
            print("MemPool: Transaction refusée - montant invalide")
            return false
        }

        // Pas besoin de vérifier la signature pour les récompenses de minage
        if transaction.type == "MINING_REWARD" {
            return true
        }

        // Vérifier la signature
        if !transaction.isSignatureValid() {
            print("MemPool: Transaction refusée - signature invalide")
            return false
        }

        // Vérifier le solde
        if !accountManager.canProcessTransaction(transaction) {
            print("MemPool: Transaction refusée - solde insuffisant")
            return false
        }

        print("MemPool: Transaction validée avec succès")
        return true
    }

    /**
     Récupère un lot de transactions prêtes pour le prochain bloc
     */
    func getTransactionsForBlock() -> [Transaction] {
        var validTransactions: [Transaction] = []
        var remainingTransactions: [Transaction] = []

        for transaction in pendingTransactions {
            if validTransactions.count >= maxTransactionsPerBlock {
                break
            }

            if validateTransaction(transaction) {
                validTransactions.append(transaction)
            } else {
                remainingTransactions.append(transaction)
            }
        }

        // Update pending transactions, removing the selected ones
        pendingTransactions = remainingTransactions + pendingTransactions.dropFirst(validTransactions.count)

        return validTransactions
    }

    /**
     Vérifie si il y a des transactions en attente
     */
    var hasPendingTransactions: Bool {
        return !pendingTransactions.isEmpty
    }

    /**
     Retourne toutes les transactions en attente sans les retirer
     */
    func getAllPendingTransactions() -> [Transaction] {
        return pendingTransactions
    }

    /**
     * Nettoie le mempool en retirant les transactions qui sont dans la chaîne
     */
    func cleanupMempool(chain: [Block]) {
        var remainingTransactions: [Transaction] = []

        for pendingTx in pendingTransactions {
            // On vérifie si la transaction est dans un des blocs
            var isInChain = false

            for block in chain {
                if block.transactions.contains(where: { chainTx in
                    chainTx.sender == pendingTx.sender &&
                        chainTx.receiver == pendingTx.receiver &&
                        chainTx.amount == pendingTx.amount &&
                        chainTx.type == pendingTx.type
                }) {
                    isInChain = true
                    break
                }
            }

            // Si la transaction n'est pas dans la chaîne, on la garde
            if !isInChain {
                remainingTransactions.append(pendingTx)
            }
        }

        // Mettre à jour les transactions en attente
        print("Mempool cleanup: removed \(pendingTransactions.count - remainingTransactions.count) transactions")
        pendingTransactions = remainingTransactions
    }
}