const { join } = require('node:path')
const os = require('node:os')
const Keypair = require('pzp-keypair')

/**
 * @typedef {ReturnType<import('pzp-db').init>} PZPDB
 * @typedef {ReturnType<import('pzp-dict').init>} PZPDict
 * @typedef {ReturnType<import('pzp-set').init>} PZPSet
 * @typedef {ReturnType<import('pzp-goals').init>} PZPGoals
 * @typedef {ReturnType<import('pzp-net').init>} PZPNet
 * @typedef {ReturnType<import('pzp-sync').init>} PZPSync
 * @typedef {ReturnType<import('pzp-gc').init>} PZPGc
 * @typedef {ReturnType<import('pzp-conductor').init>} PZPConductor
 * @typedef {ReturnType<import('pzp-hub-client/plugin').init>} PZPHubClient
 * @typedef {ReturnType<import('pzp-promise').init>} PZPPromise
 * @typedef {ReturnType<import('pzp-invite').init>} PZPInvite
 * @typedef {import('node:events').EventEmitter} Emitter
 * @typedef {{ pubkey: string }} SHSE
 */


/**
 * @typedef {Emitter & {
 *   db: PZPDB,
 *   dict: PZPDict,
 *   set: PZPSet,
 *   goals: PZPGoals,
 *   net: PZPNet,
 *   sync: PZPSync,
 *   gc: PZPGc,
 *   conductor: PZPConductor,
 *   hubClient: PZPHubClient,
 *   promise: PZPPromise,
 *   invite: PZPInvite,
 *   shse: SHSE
 * }} Peer
 */

/**
 * 
 * @param {{ path: string }} opts
 * @returns {Promise<Peer>}
 */
async function createPeer({ path }) {

  if (!path) {
    if (process.env.PZP_DIR) {
      path = process.env.PZP_DIR
    } else {
      path = join(os.tmpdir(), `pzp-${Math.random()}`)
    }
  }

  const keypairPath = join(path, 'keypair.json')
  const keypair = Keypair.loadOrCreateSync(keypairPath)

  /** @type {Peer} */
  const peer = require('secret-stack/bare')()
    .use(require('secret-stack/plugins/net'))
    .use(require('secret-handshake-ext/secret-stack'))
    .use(require('pzp-net'))
    .use(require('pzp-db'))
    .use(require('pzp-set'))
    .use(require('pzp-dict'))
    .use(require('pzp-goals'))
    .use(require('pzp-sync'))
    .use(require('pzp-gc'))
    .use(require('pzp-conductor'))
    .use(require('pzp-hub-client'))
    .use(require('pzp-promise'))
    .use(require('pzp-invite'))
    .call(null, {
      shse: {
        caps: require('pzp-caps'),
      },
      global: {
        keypair,
        path,
        timers: {
          inactivity: 10 * 60e3,
        },
        connections: {
          incoming: {
            tunnel: [{ transform: 'shse', scope: 'public' }],
          },
          outgoing: {
            net: [{ transform: 'shse' }],
            tunnel: [{ transform: 'shse' }],
          },
        },
      },
      net: {
        autostart: false,
      },
    })
  
  await peer.db.loaded()

  await peer.net.start()

  return peer
}

exports = {
  createPeer,
}