import sinon, { SinonStub } from 'sinon';
import { cloneDeep } from 'lodash';
import {
  NetworkProductModuleDefinitionRequest,
  NetworkProductModuleDefinitionResponse,
  productModuleDefinitionFromNetwork,
  productModuleDefinitionToNetwork,
} from '../product-module-definition';
import { expect } from '../../../test-utils';
import { cliDefinitionExample } from '../../../test-utils/test-root-funeral-pm';

describe('Conversion to and from network product module definition', function () {
  let transformedDefinition: NetworkProductModuleDefinitionRequest;
  let consoleLogStub: SinonStub;

  before('Transform the definition both ways', () => {
    consoleLogStub = sinon.stub(console, 'log');
    const pmDefinition = productModuleDefinitionFromNetwork(cliDefinitionExample);
    transformedDefinition = productModuleDefinitionToNetwork(pmDefinition);
  });

  after(() => {
    consoleLogStub.restore();
  });

  it('the root config object should remain unchanged ', () => {
    expect(cliDefinitionExample.root_config).to.eql(transformedDefinition.root_config);
  });

  it('the readme markdown should remain unchanged', function () {
    expect(cliDefinitionExample.readme_markdown).to.eql(transformedDefinition.readme_markdown);
  });

  it('the policy document templates should remain unchanged', function () {
    expect(cliDefinitionExample.documents).to.eql(transformedDefinition.documents);
  });

  it('the workflow items should remain unchanged', function () {
    expect(cliDefinitionExample.workflows).to.eql(transformedDefinition.workflows);
  });

  it('the api docs should fall back to empty object when in legacy array format', () => {
    expect(transformedDefinition.api_docs_schema).to.eql({});
  });

  it('the code files should remain unchanged', function () {
    expect(cliDefinitionExample.code_files).to.to.eql(transformedDefinition.code_files);
    expect(cliDefinitionExample.unit_test_code_files).to.to.eql(transformedDefinition.unit_test_code_files);
  });
});

describe('api_docs_schema coercion', () => {
  let consoleLogStub: SinonStub;

  beforeEach(() => {
    consoleLogStub = sinon.stub(console, 'log');
  });

  afterEach(() => {
    consoleLogStub.restore();
  });

  it('passes a valid JSON object schema through unchanged and does not warn', () => {
    const validSchema = { openapi: '3.0.3', info: { title: 't', version: '1' }, paths: {} };
    const network = {
      ...cloneDeep(cliDefinitionExample),
      api_docs_schema: validSchema,
    } as unknown as NetworkProductModuleDefinitionResponse;

    const result = productModuleDefinitionFromNetwork(network);

    expect(result.apiDocsSchema).to.eql(validSchema);
    expect(consoleLogStub.called).to.equal(false);
  });

  it('warns and falls back to {} when the remote schema is a legacy array', () => {
    const network = {
      ...cloneDeep(cliDefinitionExample),
      api_docs_schema: [] as unknown,
    } as unknown as NetworkProductModuleDefinitionResponse;

    const result = productModuleDefinitionFromNetwork(network);

    expect(result.apiDocsSchema).to.eql({});
    expect(consoleLogStub.called).to.equal(true);
    const warning = consoleLogStub.firstCall.args[0] as string;
    expect(warning).to.contain('remote api_docs_schema');
  });

  it('warns with "local" source when converting a local definition with an invalid schema', () => {
    const pm = productModuleDefinitionFromNetwork(cloneDeep(cliDefinitionExample));
    consoleLogStub.resetHistory();
    pm.apiDocsSchema = [] as unknown as typeof pm.apiDocsSchema;

    const network = productModuleDefinitionToNetwork(pm);

    expect(network.api_docs_schema).to.eql({});
    expect(consoleLogStub.called).to.equal(true);
    const warning = consoleLogStub.firstCall.args[0] as string;
    expect(warning).to.contain('local api_docs_schema');
  });
});