/*
 * Copyright (C) 2019 StApps
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation, version 3.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program. If not, see <https://www.gnu.org/licenses/>.
 */
// eslint-disable-next-line unicorn/prevent-abbreviations
import {
  SCBulkAddResponse,
  SCBulkAddRoute,
  SCBulkDoneResponse,
  SCBulkDoneRoute,
  SCBulkResponse,
  SCBulkRoute,
  SCSearchResponse,
  SCSearchRoute,
  SCThings,
} from '@openstapps/core';
import chai from 'chai';
import chaiAsPromised from 'chai-as-promised';
import chaiSpies from 'chai-spies';
import clone = require('rfdc');
import {existsSync, mkdirSync, rmdirSync, unlinkSync} from 'fs';
import {createFileSync} from 'fs-extra';
// eslint-disable-next-line unicorn/prevent-abbreviations
import {e2eRun, getItemsFromSamples, ApiError, HttpClient, RequestOptions, Response} from '../src/index.js';
import {RecursivePartial} from './client.spec.js';
import {expect} from "chai";
import path from "path";
import {fileURLToPath} from "url";

chai.should();
chai.use(chaiSpies);
chai.use(chaiAsPromised);

const sandbox = chai.spy.sandbox();

const bulkRoute = new SCBulkRoute();
const bulkAddRoute = new SCBulkAddRoute();
const bulkDoneRoute = new SCBulkDoneRoute();

const searchRoute = new SCSearchRoute();

const httpClient = new HttpClient();

const storedThings: Map<string, SCThings> = new Map();

describe('e2e Connector', function () {
  afterEach(function () {
    sandbox.restore();
  });

  it('should get core test samples', async function () {
    const items = await getItemsFromSamples('./node_modules/@openstapps/core/test/resources');
    expect(items).to.not.be.empty;
  });

  it('should fail to get core test samples', async function () {
    await chai.expect(getItemsFromSamples('./non-existent-directory')).to.be.rejectedWith(Error);
  });

  it('should run e2e simulation', async function () {
    type responses = Response<SCBulkAddResponse | SCBulkDoneResponse | SCBulkResponse | SCSearchResponse>;

    let failOnCompare = false;
    let failOnLookup = false;

    sandbox.on(
      httpClient,
      'request',
      async (request: RequestOptions): Promise<RecursivePartial<responses>> => {
        if (request.url.toString() === `http://localhost${bulkRoute.getUrlPath().toString()}`) {
          return {
            body: {
              state: 'in progress',
              uid: 'foo',
            },
            statusCode: bulkRoute.statusCodeSuccess,
          };
        }

        if (
          request.url.toString() === `http://localhost${bulkAddRoute.getUrlPath({UID: 'foo'}).toString()}`
        ) {
          storedThings.set(request.body.uid, clone()(request.body));

          return {
            body: {},
            statusCode: bulkAddRoute.statusCodeSuccess,
          };
        }

        if (
          request.url.toString() === `http://localhost${bulkDoneRoute.getUrlPath({UID: 'foo'}).toString()}`
        ) {
          return {
            body: {},
            statusCode: bulkDoneRoute.statusCodeSuccess,
          };
        }

        if (request.url.toString() === `http://localhost${searchRoute.getUrlPath().toString()}`) {
          const thing = storedThings.get(request.body.filter.arguments.value);
          if (failOnCompare) {
            thing!.origin!.modified = 'altered';
          }
          const returnThing = failOnLookup ? [] : [thing];
          const returnBody = {
            data: returnThing,
            facets: [],
            pagination: {
              count: returnThing.length,
              offset: 0,
              total: returnThing.length,
            },
            stats: {
              time: 42,
            },
          };

          return {
            body: returnBody,
            statusCode: searchRoute.statusCodeSuccess,
          };
        }

        return {
          body: {},
          statusCode: searchRoute.statusCodeSuccess,
        };
      },
    );

    // tslint:disable-next-line: max-line-length
    await e2eRun(httpClient, {
      to: 'http://localhost',
      samplesLocation: './node_modules/@openstapps/core/test/resources',
    });

    failOnLookup = true;
    failOnCompare = false;
    // tslint:disable-next-line: max-line-length
    await e2eRun(httpClient, {
      to: 'http://localhost',
      samplesLocation: './node_modules/@openstapps/core/test/resources',
    }).should.be.rejectedWith('Search for single SCThing with uid');

    failOnLookup = false;
    failOnCompare = true;
    // tslint:disable-next-line: max-line-length
    await e2eRun(httpClient, {
      to: 'http://localhost',
      samplesLocation: './node_modules/@openstapps/core/test/resources',
    }).should.be.rejectedWith('Unexpected difference');
  });

  it('should fail to index', async function () {
    type responses = Response<SCBulkAddResponse | SCBulkDoneResponse | SCBulkResponse>;

    sandbox.on(httpClient, 'request', async (): Promise<RecursivePartial<responses>> => {
      return {
        body: {},
        statusCode: Number.MAX_SAFE_INTEGER,
      };
    });

    // tslint:disable-next-line: max-line-length
    return e2eRun(httpClient, {
      to: 'http://localhost',
      samplesLocation: './node_modules/@openstapps/core/test/resources',
    }).should.be.rejectedWith(ApiError);
  });

  it('should fail to index directory without data', async function () {
    const emptyDirectoryPath = path.join(path.dirname(fileURLToPath(import.meta.url)), 'emptyDir');
    if (!existsSync(emptyDirectoryPath)) {
      mkdirSync(emptyDirectoryPath);
    }
    await e2eRun(httpClient, {to: 'http://localhost', samplesLocation: emptyDirectoryPath}).should.be.rejectedWith(
      'Could not index samples. None were retrieved from the file system.',
    );
    rmdirSync(emptyDirectoryPath);
  });

  it('should fail to index directory without json data', async function () {
    const somewhatFilledDirectoryPath = path.join(path.dirname(fileURLToPath(import.meta.url)), 'somewhatFilledDir');
    if (!existsSync(somewhatFilledDirectoryPath)) {
      mkdirSync(somewhatFilledDirectoryPath);
    }
    const nonJsonFile = path.join(somewhatFilledDirectoryPath, 'nonjson.txt');
    createFileSync(nonJsonFile);
    await e2eRun(httpClient, {
      to: 'http://localhost',
      samplesLocation: somewhatFilledDirectoryPath,
    }).should.be.rejectedWith('Could not index samples. None were retrieved from the file system.');
    unlinkSync(nonJsonFile);
    rmdirSync(somewhatFilledDirectoryPath);
  });
});