var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
import { Level } from 'level';
import { DataStoreLevel, EventEmitterEventLog, MessageStoreLevel, ResumableTaskStoreLevel, StateIndexLevel } from '@enbox/dwn-sdk-js';
import { DidDht, DidJwk, DidResolverCacheMemory } from '@enbox/dids';
import { LevelStore, MemoryStore } from '@enbox/common';
import { AgentCryptoApi } from './crypto-api.js';
import { AgentDidApi } from './did-api.js';
import { AgentDidResolverCache } from './agent-did-resolver-cache.js';
import { AgentDwnApi } from './dwn-api.js';
import { AgentIdentityApi } from './identity-api.js';
import { AgentPermissionsApi } from './permissions-api.js';
import { EnboxRpcClient } from '@enbox/dwn-clients';
import { HdIdentityVault } from './hd-identity-vault.js';
import { LocalKeyManager } from './local-key-manager.js';
import { SyncEngineLevel } from './sync-engine-level.js';
import { DwnDidStore, InMemoryDidStore } from './store-did.js';
import { DwnIdentityStore, InMemoryIdentityStore } from './store-identity.js';
import { DwnKeyStore, InMemoryKeyStore } from './store-key.js';
export class PlatformAgentTestHarness {
    constructor(params) {
        this.agent = params.agent;
        this.agentStores = params.agentStores;
        this.didResolverCache = params.didResolverCache;
        this.dwn = params.dwn;
        this.dwnDataStore = params.dwnDataStore;
        this.dwnStateIndex = params.dwnStateIndex;
        this.dwnMessageStore = params.dwnMessageStore;
        this.syncStore = params.syncStore;
        this.vaultStore = params.vaultStore;
        this.dwnResumableTaskStore = params.dwnResumableTaskStore;
        this.dwnStores = params.dwnStores;
    }
    clearStorage() {
        return __awaiter(this, void 0, void 0, function* () {
            // first stop any ongoing sync operations
            yield this.agent.sync.stopSync();
            // @ts-expect-error since normally this property shouldn't be set to undefined.
            this.agent.agentDid = undefined;
            yield this.didResolverCache.clear();
            yield this.dwnDataStore.clear();
            yield this.dwnStateIndex.clear();
            yield this.dwnMessageStore.clear();
            yield this.dwnResumableTaskStore.clear();
            yield this.syncStore.clear();
            yield this.vaultStore.clear();
            this.agent.vault['_cachedInitialized'] = undefined;
            yield this.agent.permissions.clear();
            this.dwnStores.clear();
            // Reset the indexes and caches for the Agent's DWN data stores.
            // if (this.agentStores === 'dwn') {
            //   const { didApi, identityApi } = PlatformAgentTestHarness.useDiskStores({ testDataLocation: '__TESTDATA__', agent: this.agent });
            //   this.agent.crypto = cryptoApi;
            //   this.agent.did = didApi;
            //   this.agent.identity = identityApi;
            // }
            // Easiest way to start with fresh in-memory stores is to re-instantiate Agent components.
            if (this.agentStores === 'memory') {
                const { didApi, identityApi, permissionsApi, keyManager } = PlatformAgentTestHarness.useMemoryStores({ agent: this.agent });
                this.agent.did = didApi;
                this.agent.identity = identityApi;
                this.agent.keyManager = keyManager;
                this.agent.permissions = permissionsApi;
            }
        });
    }
    /**
     * Clear only DWN-level stores (data, messages, state index, resumable tasks,
     * sync, permissions) and the DWN-backed store caches — but preserve the
     * agent DID, vault, and all key/DID/identity material.
     *
     * Use this in `beforeEach` when `createAgentDid()` (and optionally
     * `createIdentity()`) was called once in `beforeAll` to avoid expensive
     * DID re-creation on every test.
     */
    clearDwnStores() {
        return __awaiter(this, void 0, void 0, function* () {
            yield this.syncStore.clear();
            yield this.dwnDataStore.clear();
            yield this.dwnStateIndex.clear();
            yield this.dwnMessageStore.clear();
            yield this.dwnResumableTaskStore.clear();
            yield this.agent.permissions.clear();
            this.dwnStores.clear();
        });
    }
    closeStorage() {
        return __awaiter(this, void 0, void 0, function* () {
            yield this.didResolverCache.close();
            yield this.dwnDataStore.close();
            yield this.dwnStateIndex.close();
            yield this.dwnMessageStore.close();
            yield this.dwnResumableTaskStore.close();
            yield this.syncStore.close();
            yield this.vaultStore.close();
        });
    }
    createAgentDid() {
        return __awaiter(this, void 0, void 0, function* () {
            var _a;
            // Create a DID for the Agent with Ed25519 (signing) and X25519 (keyAgreement).
            // X25519 is required by DwnKeyStore for JWE record-level encryption.
            // Must be published so the DWN can resolve it for JWS signature verification.
            this.agent.agentDid = yield DidDht.create({
                options: {
                    publish: true,
                    gatewayUri: (_a = process.env.DID_DHT_GATEWAY_URI) !== null && _a !== void 0 ? _a : 'http://localhost:7527',
                    verificationMethods: [
                        {
                            algorithm: 'Ed25519',
                            id: 'sig',
                            purposes: ['assertionMethod', 'authentication']
                        },
                        {
                            algorithm: 'X25519',
                            id: 'enc',
                            purposes: ['keyAgreement']
                        }
                    ]
                }
            });
        });
    }
    createIdentity(_a) {
        return __awaiter(this, arguments, void 0, function* ({ name, testDwnUrls }) {
            const bearerIdentity = yield this.agent.identity.create({
                didMethod: 'dht',
                didOptions: {
                    services: [
                        {
                            id: 'dwn',
                            type: 'DecentralizedWebNode',
                            serviceEndpoint: testDwnUrls,
                        }
                    ],
                    verificationMethods: [
                        {
                            algorithm: 'Ed25519',
                            id: 'sig',
                            purposes: ['assertionMethod', 'authentication']
                        },
                        {
                            algorithm: 'X25519',
                            id: 'enc',
                            purposes: ['keyAgreement']
                        }
                    ]
                },
                metadata: { name }
            });
            return bearerIdentity;
        });
    }
    static setup(_a) {
        return __awaiter(this, arguments, void 0, function* ({ agentClass, agentStores, testDataLocation }) {
            agentStores !== null && agentStores !== void 0 ? agentStores : (agentStores = 'memory');
            testDataLocation !== null && testDataLocation !== void 0 ? testDataLocation : (testDataLocation = '__TESTDATA__');
            const testDataPath = (path) => `${testDataLocation}/${path}`;
            // Instantiate Agent's Crypto API.
            const cryptoApi = new AgentCryptoApi();
            // Instantiate Agent's RPC Client.
            const rpcClient = new EnboxRpcClient();
            const dwnStores = {
                keyStore: new DwnKeyStore(),
                identityStore: new DwnIdentityStore(),
                didStore: new DwnDidStore(),
                clear: () => {
                    var _a, _b, _c;
                    (_a = dwnStores.keyStore['_protocolInitializedCache']) === null || _a === void 0 ? void 0 : _a.clear();
                    (_b = dwnStores.identityStore['_protocolInitializedCache']) === null || _b === void 0 ? void 0 : _b.clear();
                    (_c = dwnStores.didStore['_protocolInitializedCache']) === null || _c === void 0 ? void 0 : _c.clear();
                }
            };
            const { agentVault, didApi, identityApi, keyManager, didResolverCache, vaultStore, permissionsApi } = (agentStores === 'memory')
                ? PlatformAgentTestHarness.useMemoryStores()
                : PlatformAgentTestHarness.useDiskStores({ testDataLocation, stores: dwnStores });
            // Instantiate custom stores to use with DWN instance.
            // Note: There is no in-memory store for DWN, so we always use LevelDB-based disk stores.
            const dwnDataStore = new DataStoreLevel({ blockstoreLocation: testDataPath('DWN_DATASTORE') });
            const dwnStateIndex = new StateIndexLevel({ location: testDataPath('DWN_STATEINDEX') });
            const dwnEventLog = new EventEmitterEventLog();
            const dwnResumableTaskStore = new ResumableTaskStoreLevel({ location: testDataPath('DWN_RESUMABLETASKSTORE') });
            const dwnMessageStore = new MessageStoreLevel({
                blockstoreLocation: testDataPath('DWN_MESSAGESTORE'),
                indexLocation: testDataPath('DWN_MESSAGEINDEX')
            });
            // Instantiate DWN instance using the custom stores.
            const dwn = yield AgentDwnApi.createDwn({
                dataPath: testDataLocation,
                dataStore: dwnDataStore,
                didResolver: didApi,
                stateIndex: dwnStateIndex,
                eventLog: dwnEventLog,
                messageStore: dwnMessageStore,
                resumableTaskStore: dwnResumableTaskStore
            });
            // Instantiate Agent's DWN API using the custom DWN instance.
            // Disable local DWN discovery so tests don't accidentally probe localhost.
            const dwnApi = new AgentDwnApi({ dwn, localDwnStrategy: 'off' });
            // Instantiate Agent's Sync API using a custom LevelDB-backed store.
            const syncStore = new Level(testDataPath('SYNC_STORE'));
            const syncApi = new SyncEngineLevel({ db: syncStore });
            // Create EnboxPlatformAgent instance
            const agent = new agentClass({
                agentVault,
                cryptoApi,
                didApi,
                dwnApi,
                identityApi,
                keyManager,
                permissionsApi,
                rpcClient,
                syncApi,
            });
            return new PlatformAgentTestHarness({
                agent,
                agentStores,
                didResolverCache,
                dwn,
                dwnDataStore,
                dwnStateIndex,
                dwnMessageStore,
                dwnResumableTaskStore,
                dwnStores,
                syncStore,
                vaultStore
            });
        });
    }
    static useDiskStores({ agent, testDataLocation, stores }) {
        const testDataPath = (path) => `${testDataLocation}/${path}`;
        const vaultStore = new LevelStore({ location: testDataPath('VAULT_STORE') });
        const agentVault = new HdIdentityVault({ keyDerivationWorkFactor: 1, store: vaultStore });
        const { didStore, identityStore, keyStore } = stores;
        // Setup DID Resolver Cache
        const didResolverCache = new AgentDidResolverCache({
            location: testDataPath('DID_RESOLVERCACHE')
        });
        const didApi = new AgentDidApi({
            agent: agent,
            didMethods: [DidDht, DidJwk],
            resolverCache: didResolverCache,
            store: didStore
        });
        const identityApi = new AgentIdentityApi({ agent, store: identityStore });
        const keyManager = new LocalKeyManager({ agent, keyStore: keyStore });
        const permissionsApi = new AgentPermissionsApi({ agent });
        return { agentVault, didApi, didResolverCache, identityApi, keyManager, permissionsApi, vaultStore };
    }
    static useMemoryStores({ agent } = {}) {
        const vaultStore = new MemoryStore();
        const agentVault = new HdIdentityVault({ keyDerivationWorkFactor: 1, store: vaultStore });
        // Setup DID Resolver Cache
        const didResolverCache = new DidResolverCacheMemory();
        const didApi = new AgentDidApi({
            agent: agent,
            didMethods: [DidDht, DidJwk],
            resolverCache: didResolverCache,
            store: new InMemoryDidStore()
        });
        const keyManager = new LocalKeyManager({ agent, keyStore: new InMemoryKeyStore() });
        const identityApi = new AgentIdentityApi({ agent, store: new InMemoryIdentityStore() });
        const permissionsApi = new AgentPermissionsApi({ agent });
        return { agentVault, didApi, didResolverCache, identityApi, keyManager, permissionsApi, vaultStore };
    }
}
//# sourceMappingURL=test-harness.js.map