import { Report } from "../../src/services/choicesTopic.service";
import sinon from "sinon";
import { expect } from "chai";
import IDeliveryMonitoringMessage = ogury.delivery.monitoring.IDeliveryMonitoringMessage;
import fs from "fs";
import { ogury } from "../../src/protos/protos";

const KafkaConnector = require("@ogury/ogury-kafka-connector");

export function initKafkaSpy(): sinon.SinonSpy {
  sinon.stub(KafkaConnector.prototype, "setupProducer").value((kafkaConfig: any, cb: any) => {});
  return sinon.stub(KafkaConnector.prototype, "sendMessage");
}

export function expectKafkaTopicMessagesCount(
  spy: sinon.SinonSpy,
  topic: string,
  messagesCount: number
) {
  const calls = spy.getCalls().filter((call) => call.args[0] === topic);
  if (calls.length !== messagesCount) {
    expect.fail(
      `App should have produced ${messagesCount} in topic ${topic}, but found ${calls.length}`
    );
  }
}

export function getKafkaChoicesMessage(spy: sinon.SinonSpy): Report {
  const calls = spy.getCalls();
  const callArg = calls.find((call) => call.args[0] === "choices");
  if (!callArg) {
    expect.fail(`kafka message for topic choices was not sent`);
  }
  return callArg.args[1];
}

export function expectedDeliveryMonitoringSteps(
  spy: sinon.SinonSpy,
  expectedStepsCampaigns: { [key: string]: number[] }
) {
  const calls = spy.getCalls();
  const callArg = calls.find((call) => call.args[0] === "DeliveryMonitoring");
  if (!callArg) {
    expect.fail(`kafka DeliveryMonitoring for topic choices was not sent`);
  }
  const actualMessage: IDeliveryMonitoringMessage = callArg.args[1];
  actualMessage.steps_statuses?.forEach((stepStatus) => {
    if (!stepStatus.step) {
      return;
    }
    const expectedPassingCampaigns: number[] = expectedStepsCampaigns[stepStatus.step];
    if (!expectedPassingCampaigns) {
      // do not check this step result if not given
      return;
    }

    // check that we have as many passing campaign than expected
    const actualPassingCampaignsLength = stepStatus.campaigns_statuses?.filter(
      (cs) => cs.campaign_passing
    ).length;
    if (actualPassingCampaignsLength !== expectedPassingCampaigns.length) {
      expect.fail(
        `Expecting ${expectedPassingCampaigns.length} passing campaigns in step '${stepStatus.step}', but got ${actualPassingCampaignsLength}`
      );
    }

    expectedPassingCampaigns.forEach((expectedPassingCampaign) => {
      const actualCampaignStatus = stepStatus.campaigns_statuses?.find(
        (campaignStatus) => campaignStatus.campaign_id === expectedPassingCampaign
      );
      if (!actualCampaignStatus) {
        expect.fail(
          `Campaign ${expectedPassingCampaign} should pass step '${stepStatus.step}', but was not even candidate`
        );
      }
      if (!actualCampaignStatus.campaign_passing) {
        expect.fail(
          `Campaign ${expectedPassingCampaign} should pass step '${stepStatus.step}', but did not`
        );
      }
    });
  });
}

export function expectKafkaDeliveryMonitoringMessage(
  spy: sinon.SinonSpy,
  expectedMessageFile: string
) {
  const calls = spy.getCalls();
  const callArg = calls.find((call) => call.args[0] === "DeliveryMonitoring");
  if (!callArg) {
    expect.fail(`kafka DeliveryMonitoring for topic choices was not sent`);
  }
  const actualMessage: IDeliveryMonitoringMessage = callArg.args[1];

  const filepath = `./test/integration/data/expected/deliveryMonitoringMessages/${expectedMessageFile}`;

  if (process.env.OVERWRITE_EXPECTED_DELIVERY_MONITORING_MESSAGES) {
    fs.writeFileSync(filepath, JSON.stringify(actualMessage, null, 2), "utf-8");
  }

  const expectedMessage: IDeliveryMonitoringMessage = JSON.parse(
    fs.readFileSync(filepath, "utf-8")
  );
  expectedMessage.request_time = actualMessage.request_time;
  expect(actualMessage).to.deep.equal(expectedMessage);
}