import assert from 'node:assert/strict';
import test from 'node:test';
import {
  assertMindSpaceServerAdapterContract,
  createMindSpaceServerAdapter,
  resolveMindSpaceServerAdapterKind,
} from './mindspace-server-adapter.mjs';
import {
  MINDSPACE_SERVER_ADAPTER_BINDINGS,
  MINDSPACE_SERVER_ADAPTER_CONTRACT_VERSION,
  MINDSPACE_SERVER_ADAPTER_REQUIRED_CAPABILITIES,
} from './mindspace-server-adapter-contract.mjs';

test('resolveMindSpaceServerAdapterKind defaults to local and rejects unknown kinds', () => {
  assert.equal(resolveMindSpaceServerAdapterKind({}), 'local');
  assert.equal(resolveMindSpaceServerAdapterKind({ MINDSPACE_SERVER_ADAPTER: 'REMOTE' }), 'remote');
  assert.throws(
    () => resolveMindSpaceServerAdapterKind({ MINDSPACE_SERVER_ADAPTER: 'legacy' }),
    /Unsupported MINDSPACE_SERVER_ADAPTER/,
  );
});

test('createMindSpaceServerAdapter returns a contract-complete local adapter by default', () => {
  const adapter = createMindSpaceServerAdapter({
    pool: {
      query: async () => {
        throw new Error('not implemented in unit test');
      },
    },
    h5Root: '/tmp/h5',
    env: {
      MINDSPACE_STORAGE_ROOT: '/srv/mindspace-data',
      H5_PUBLIC_BASE_URL: 'https://example.com',
    },
    maxFileBytes: 4096,
    publicPageLimit: 3,
    resolveUserIdForAgentSession: async () => 'user-1',
    resolveWorkspaceRoot: async () => '/tmp/workspace',
    logger: { log() {}, warn() {}, error() {} },
  });

  assert.equal(adapter.kind, 'local');
  assert.equal(adapter.implementationStatus, 'ready');
  assert.equal(assertMindSpaceServerAdapterContract(adapter), adapter);
});

test('createMindSpaceServerAdapter exposes a remote stub that validates contract when selected', async () => {
  const adapter = createMindSpaceServerAdapter({
    env: {
      MINDSPACE_SERVER_ADAPTER: 'remote',
      MINDSPACE_REMOTE_BASE_URL: 'https://mindspace.example.com',
    },
    fetchFn: async () => ({
      ok: true,
      status: 200,
      async text() {
        return JSON.stringify({
          contractVersion:
            MINDSPACE_SERVER_ADAPTER_CONTRACT_VERSION,
          bindings: MINDSPACE_SERVER_ADAPTER_BINDINGS,
          requiredCapabilities:
            MINDSPACE_SERVER_ADAPTER_REQUIRED_CAPABILITIES,
        });
      },
    }),
    logger: { log() {}, warn() {}, error() {} },
  });

  assert.equal(adapter.kind, 'remote');
  assert.equal(adapter.implementationStatus, 'scaffold');
  assert.equal(assertMindSpaceServerAdapterContract(adapter), adapter);
  assert.equal(await adapter.assertReady(), true);
  assert.deepEqual(adapter.startBackgroundJobs(), {
    publicationCleanup: null,
    agentWorker: null,
    workspaceMaintenance: null,
  });
});