//
//  MockPGPInterface.swift
//  passKitTests
//

import Foundation
@testable import passKit

class MockPGPInterface: PGPInterface {
    // MARK: - Configuration

    var keyIDs: [String] = []
    var shortKeyIDs: [String] = []
    var publicKeyIDs: Set<String> = []
    var privateKeyIDs: Set<String> = []

    var decryptResult: Data?
    var decryptError: Error?
    var encryptResult = Data()
    var encryptError: Error?

    /// When set, the mock calls `passPhraseForKey` with this key ID during `decrypt`,
    /// simulating the PGP backend selecting a key and requesting its passphrase.
    var selectedKeyForPassphrase: String?

    // MARK: - Call tracking

    struct DecryptCall {
        let encryptedData: Data
        let keyID: String?
        let passPhraseForKey: (String) -> String
    }

    struct EncryptCall {
        let plainData: Data
        let keyID: String?
    }

    struct EncryptMultiKeyCall {
        let plainData: Data
        let keyIDs: [String]
    }

    struct EncryptWithAllKeysCall {
        let plainData: Data
    }

    var decryptCalls: [DecryptCall] = []
    var resolvedPassphrases: [String] = []
    var encryptMultiKeyCalls: [EncryptMultiKeyCall] = []
    var encryptWithAllKeysCalls: [EncryptWithAllKeysCall] = []
    var containsPublicKeyCalls: [String] = []
    var containsPrivateKeyCalls: [String] = []

    // MARK: - PGPInterface

    func decrypt(encryptedData: Data, keyIDHint keyID: String?, passPhraseForKey: @escaping (String) -> String) throws -> Data? {
        decryptCalls.append(DecryptCall(encryptedData: encryptedData, keyID: keyID, passPhraseForKey: passPhraseForKey))
        if let selectedKey = selectedKeyForPassphrase {
            resolvedPassphrases.append(passPhraseForKey(selectedKey))
        }
        if let error = decryptError {
            throw error
        }
        return decryptResult
    }

    func encryptWithAllKeys(plainData: Data) throws -> Data {
        encryptWithAllKeysCalls.append(EncryptWithAllKeysCall(plainData: plainData))
        if let error = encryptError {
            throw error
        }
        return encryptResult
    }

    func encrypt(plainData: Data, keyIDs: [String]) throws -> Data {
        encryptMultiKeyCalls.append(EncryptMultiKeyCall(plainData: plainData, keyIDs: keyIDs))
        if let error = encryptError {
            throw error
        }
        return encryptResult
    }

    func containsPublicKey(with keyID: String) -> Bool {
        containsPublicKeyCalls.append(keyID)
        return publicKeyIDs.contains { $0.hasSuffix(keyID.lowercased()) }
    }

    func containsPrivateKey(with keyID: String) -> Bool {
        containsPrivateKeyCalls.append(keyID)
        return privateKeyIDs.contains { $0.hasSuffix(keyID.lowercased()) }
    }

    var keyID: [String] { keyIDs }
    var shortKeyID: [String] { shortKeyIDs }
}