// node
import * as assert from 'assert';
import * as fs from 'fs';
import * as path from 'path';
import { Server } from 'http';
import { RedisClient } from 'redis';
// ownzones
import { Queue, Rrtq } from '@ownzones/rrtq';

import { connectApiInit } from './utils/zypline-mock';
import { config, log } from '../config';
import { Worker } from '../lib/workers/worker';
import { LongWorker } from '../lib/workers/long-worker';
import { Driver } from '../driver';
import {
  CacheManager, DynamodbCacheManager, ICacheManager, RedisCacheManager,
} from '../lib/cache';
import { ensureTestDynamoDBTable, flushDynamoDBTable } from './utils/dynamodb';
import { IJob } from '../lib/connect-api';
import { TaskResponse } from '../utils/types';

describe('Cache Builder', () => {
  let rrtq: Rrtq;
  let driverQueue: Queue;
  let connectApi: Server;
  let driver: Driver;
  let worker: Worker;
  let longWorker: LongWorker;
  let cacheManagerInstance: ICacheManager;

  // eslint-disable-next-line mocha/no-hooks-for-single-case
  before(async () => {
    rrtq = new Rrtq({ redis: config.redis });
    await (rrtq.redisClient as RedisClient).flushdbAsync();

    cacheManagerInstance = CacheManager.getInstance();

    if (cacheManagerInstance instanceof RedisCacheManager) {
      await cacheManagerInstance.options.client.flushdbAsync();
    } else if (cacheManagerInstance instanceof DynamodbCacheManager) {
      await ensureTestDynamoDBTable();
      await flushDynamoDBTable();
    }

    connectApi = connectApiInit();

    // create driver queue
    driverQueue = await rrtq.createQueue(
      'driver',
      { ...config.rrtq, namespace: config.rrtq.driverNamespace },
    );

    // start driver consumer
    driver = await Driver.create(config);

    // start worker
    worker = new Worker(config, config.rrtq.videoNamespacePreCache);
    longWorker = new LongWorker(config, config.rrtq.audioNamespaceChannelExtract);
  });

  // eslint-disable-next-line mocha/no-hooks-for-single-case
  after(async () => {
    await driver.stop();
    await rrtq.stop();
    connectApi.close();
    cacheManagerInstance.stopCacheGC();
    await worker.stop();
    await longWorker.stop();
    CacheManager.destroyInstance();
  });

  it('should run a cache builder job', async () => {
    const taskArgs = JSON.parse((fs.readFileSync(path.join(__dirname, 'files/driver-job.json'))).toString()) as IJob;

    const task = await driverQueue.addTask(taskArgs);

    const response = await task.waitForResponse() as TaskResponse<IJob>;

    log.info(response as any);

    assert.equal(response.error, false);
  });
});