const TRACE_HEADER_BEHAVIOR = process.env.TRACE_HEADER_BEHAVIOR;
let contextHeaderBehavior: 'default' | 'require' = 'default';
let samplingRate: number = 1/60;
if (TRACE_HEADER_BEHAVIOR === 'require') {
  contextHeaderBehavior = TRACE_HEADER_BEHAVIOR;
  samplingRate = 0;
}

export const tracer = traceAgent.start({
  contextHeaderBehavior,
  enabled: process.env.TRACING === 'enabled',
  keyFilename: process.env.GOOGLE_APPLICATION_CREDENTIALS,
  logLevel: 0,
  projectId: process.env.TRACING_PROJECT,
  samplingRate,
});

export async function runHeartbeat(
  parentLogger: Logger,
  dispatcherUri: string,
  rateHz: number,
) {
  const chance = new Chance();

  const durationMs = 1000 / rateHz;

  return pForever(
    async i =>
      tracer.runInRootSpan({ name: 'heartbeat' }, async rootSpan => {
        const logger = traceLogger(parentLogger);

        const message: Payload = {
          payload: JSON.stringify({
            hops: 0,
            i,
            origin: `heartbeat-${os.hostname}-${i}`,
            [chance.string()]: chance.string(),
          }),
        };

        const uri = `${dispatcherUri}`;

        try {
          await postHeartbeat(logger, uri, message);
        } catch (err) {
          logger.error(
            { message, err, dispatcherUri },
            'Error posting message to Dispatcher',
          );
        } finally {
          rootSpan.endSpan();
        }

        await sleep(durationMs);

        return i + 1;
      }),
    1,
  );
}

async function postHeartbeat(
  parentLogger: Logger,
  uri: string,
  message: Payload,
) {
  const logger = traceLogger(parentLogger);
  logger.trace({ message }, 'Posting heartbeat');

  const response = await got.post(uri, {
    body: JSON.stringify(message),
    headers: {
      'Content-Type': 'application/json',
    },
    timeout: 30_000,
  });

  // SAFETY: ! allowed because we are using a POST and not a st1ream
  const statusCode = response.statusCode!;
  const body = response.body;

  if (statusCode < 200 || statusCode >= 300) {
    logger.error({ body, statusCode }, 'Invalid status code');
  }

  return;
}