import sinon, { SinonStub } from 'sinon';
import * as pullExports from '../pull';
import * as versionCheckExports from '../../helpers/version-check';
import * as readAuthAndConfigExports from '../../helpers/read-auth-and-config';
import { rootConfigFileExample } from '../../../test-utils/test-root-funeral-pm';
import * as checkValidProductModuleDirectoryExports from '../../helpers/check-valid-product-module-directory';
import { expect } from '../../../test-utils';
import * as readProductModuleDefinition from '../../helpers/read-product-module-definition';
import * as fetchProductModuleDefinitionExports from '../../helpers/fetch-product-module-definition';
import * as productModuleDefinitionDomainExports from '../../domain/product-module-definition';
import * as writeProductModuleDefinitionExports from '../../helpers/write-product-module-definition';
import * as updateStaticFilesExports from '../../helpers/update-static-files';
import * as fetchSkillFilesExports from '../../helpers/fetch-skill-files';
import * as writeSkillFilesExports from '../../helpers/write-skill-files';

describe('rp pull', function () {
  const sandbox = sinon.createSandbox();
  let pullCollectionModuleStub: SinonStub;
  let pullProductModuleStub: SinonStub;

  beforeEach(function () {
    pullCollectionModuleStub = sandbox.stub(pullExports, 'pullCollectionModule');
    pullProductModuleStub = sandbox.stub(pullExports, 'pullProductModule');
    sandbox.stub(versionCheckExports, 'checkPackageAndNodeVersion').resolves({
      latest: '0.123',
      current: '0.123',
    });
  });

  afterEach(function () {
    // Restore the original functions after each test
    sandbox.verifyAndRestore();
  });

  it('should call pullCollectionModule when reading collection module config', async function () {
    sandbox.stub(readAuthAndConfigExports, 'readAuthAndConfig').returns({
      apiKey: 'string',
      config: {
        collectionModuleKey: 'blank_starter_template',
        collectionModuleName: 'Blank Starter Template',
        organizationId: '00000000-0000-0000-0000-000000000001',
        host: 'http://localhost:4000',
        settings: {},
        manualTransactions: [
          {
            key: 'raise_premium',
            functionName: 'raisePremium',
            displayData: {
              type: '{{ policy.module.type }}',
              sum_assured: '{{ zarString policy.sum_assured }}',
              amount: '{{ zarString policy.module.cover_amount }}',
              name: '{{ policyholder.first_name }}',
              last_name: '{{ policyholder.last_name }}',
              payment_method_type: '{{ payment_method.type }}',
            },
          },
          {
            key: 'add_collection',
            functionName: 'addCollection',
            displayData: undefined,
          },
        ],
      },
    });

    await pullExports.pull({});

    sandbox.assert.calledOnce(pullCollectionModuleStub);
    sandbox.assert.notCalled(pullProductModuleStub);
  });

  it('should call pullProductModule when reading product module config', async function () {
    sandbox.stub(readAuthAndConfigExports, 'readAuthAndConfig').returns({
      apiKey: 'string',
      config: rootConfigFileExample,
    });

    await pullExports.pull({});

    sandbox.assert.calledOnce(pullProductModuleStub);
    sandbox.assert.notCalled(pullCollectionModuleStub);
  });
});

describe('pullProductModule', function () {
  const sandbox = sinon.createSandbox();
  let checkValidProductModuleDirectoryStub: SinonStub;
  let fetchSkillFilesStub: SinonStub;
  let writeSkillFilesStub: SinonStub;

  beforeEach(function () {
    sandbox.stub(readAuthAndConfigExports, 'readAuthAndConfig').returns({
      apiKey: 'string',
      config: rootConfigFileExample,
    });

    sandbox.stub(versionCheckExports, 'checkPackageAndNodeVersion').resolves({
      latest: '0.123',
      current: '0.123',
    });

    // @ts-ignore
    sandbox.stub(fetchProductModuleDefinitionExports, 'fetchProductModuleDefinition').resolves({});

    checkValidProductModuleDirectoryStub = sandbox
      .stub(checkValidProductModuleDirectoryExports, 'checkValidProductModuleDirectory')
      .returns();

    sandbox
      .stub(readProductModuleDefinition, 'readProductModuleDefinition')
      // @ts-ignore
      .returns({});

    // @ts-ignore
    sandbox.stub(productModuleDefinitionDomainExports, 'productModuleDefinitionFromNetwork').returns({});

    // @ts-ignore
    sandbox.stub(writeProductModuleDefinitionExports, 'writeProductModuleDefinition').returns();

    // @ts-ignore
    sandbox.stub(updateStaticFilesExports, 'updateStaticFiles').returns({});

    fetchSkillFilesStub = sandbox.stub(fetchSkillFilesExports, 'fetchSkillFiles').resolves(null);
    writeSkillFilesStub = sandbox.stub(writeSkillFilesExports, 'writeSkillFiles').resolves();
  });

  afterEach(function () {
    sandbox.verifyAndRestore();
  });

  it('should not call checkValidProductModuleDirectory when force is true', async function () {
    await pullExports.pullProductModule({
      apiKey: 'string',
      productModuleConfig: rootConfigFileExample,
      options: { force: true },
    });

    expect(checkValidProductModuleDirectoryStub.called).to.equals(false);
  });

  it('should call checkValidProductModuleDirectory when force is false', async function () {
    await pullExports.pullProductModule({
      apiKey: 'string',
      productModuleConfig: rootConfigFileExample,
      options: { force: false },
    });

    expect(checkValidProductModuleDirectoryStub.called).to.equals(true);
  });

  it('should not call writeSkillFiles when fetchSkillFiles returns null', async () => {
    fetchSkillFilesStub.resolves(null);

    await pullExports.pullProductModule({
      apiKey: 'string',
      productModuleConfig: rootConfigFileExample,
      options: { force: true },
    });

    expect(fetchSkillFilesStub.calledOnce).to.equals(true);
    expect(writeSkillFilesStub.called).to.equals(false);
  });

  it('should not call writeSkillFiles when fetchSkillFiles returns empty skills', async () => {
    fetchSkillFilesStub.resolves({ overview: '', skills: [] });

    await pullExports.pullProductModule({
      apiKey: 'string',
      productModuleConfig: rootConfigFileExample,
      options: { force: true },
    });

    expect(writeSkillFilesStub.called).to.equals(false);
  });

  it('should call writeSkillFiles when fetchSkillFiles returns skill files', async () => {
    const skillFiles = {
      overview: '# Overview',
      skills: [{ domain: 'schema-form', filename: 'overview.mdc', content: 'content' }],
    };
    fetchSkillFilesStub.resolves(skillFiles);

    await pullExports.pullProductModule({
      apiKey: 'string',
      productModuleConfig: rootConfigFileExample,
      options: { force: true },
    });

    expect(writeSkillFilesStub.calledOnce).to.equals(true);
    expect(writeSkillFilesStub.firstCall.args[0].skillFiles).to.deep.equal(skillFiles);
  });
});