// external lib
import Parser from "rss-parser";

// tested class
import {
  ListenerRss as Listeners,
  ListenerRSSInfo as ListenerRRSInfo,
} from "/src/index"; // TODO import bloque ?? not found

// Unit test
import chai from "chai";
import sinon from "ts-sinon";
import sinon_chai from "sinon-chai";
import { SinonSpy } from "sinon";
chai.use(sinon_chai);

const expect = chai.expect;

describe("test class RSS: jsonfile", function () {
  let myListener: Listeners | undefined = undefined;

  const infosListener: ListenerRRSInfo = new ListenerRRSInfo(
    "my-test-service",
    "fake.rss.service",
    15,
    [
      ["description", ["media:group", "media:description"]],
      ["icon", ["media:group", "media:thumbnail"]],
    ]
  );

  // parseURL tests
  let stubParser: sinon.SinonStub;
  const mockedRSSOutput: any = {
    // TODO any = pas bien
    items: [
      {
        title: "my title 00",
        "media:group": {
          "media:description": "my description 00",
          "media:thumbnail": [
            { $: { height: 360, width: 420, url: "my_image00.jpg" } },
          ],
        },
        link: "my_url_00.com",
        pubDate: "myDate00",
      },
      {
        title: "my title 01",
        "media:group": {
          "media:description": "my description 01",
          "media:thumbnail": [
            { $: { height: 360, width: 420, url: "my_image01.jpg" } },
          ],
        },
        link: "my_url_01.com",
        pubDate: "myDate01",
      },
      {
        title: "my title 02",
        "media:group": {
          "media:description": "my description 02",
          "media:thumbnail": [
            { $: { height: 360, width: 420, url: "my_image02.jpg" } },
          ],
        },
        link: "my_url_02.com",
        pubDate: "myDate02",
      },
    ],
  };

  beforeEach(function () {
    // stubs
    stubParser = sinon.stub(Parser.prototype, "parseURL");
    stubParser.withArgs(infosListener.address).resolves(mockedRSSOutput);
    stubParser
      .withArgs("bad.rss.service")
      .resolves(new Error("connect ECONNREFUSED 127.0.0.1:80"));

    // constructor
    myListener = undefined;
  });

  afterEach(function () {
    // restore stubs
    stubParser.restore();
  });

  describe("Building Ytb listener", function () {
    it("The build without issues (infosListener parameters)", function () {
      myListener = new Listeners(infosListener);

      // assertions
      // myListener data
      expect(myListener.timeloop).to.eql(15);
      expect(myListener.name).to.eql("my-test-service");
      expect(myListener.address).to.eql("fake.rss.service");
      expect(myListener.customfields).to.eql([
        ["description", ["media:group", "media:description"]],
        ["icon", ["media:group", "media:thumbnail"]],
      ]);
      expect(myListener.parser.options.customFields).to.eql({
        feed: [],
        item: ["media:group", "media:group"],
      });
    });
    it("The build without issues (raw infos : 4 params)", function () {
      myListener = new Listeners("my-test-service", "fake.rss.service", 15, [
        ["description", ["media:group", "media:description"]],
        ["icon", ["media:group", "media:thumbnail"]],
      ]);

      // assertions
      // myListener data
      expect(myListener.timeloop).to.eql(15);
      expect(myListener.name).to.eql("my-test-service");
      expect(myListener.address).to.eql("fake.rss.service");
      expect(myListener.customfields).to.eql([
        ["description", ["media:group", "media:description"]],
        ["icon", ["media:group", "media:thumbnail"]],
      ]);
      expect(myListener.parser.options.customFields).to.eql({
        feed: [],
        item: ["media:group", "media:group"],
      });
    });
    it("The build without issues (raw infos : just 2 params)", function () {
      myListener = new Listeners("my-test-service", "fake.rss.service");

      // assertions
      // myListener data
      expect(myListener.timeloop).to.eql(5 * 60);
      expect(myListener.name).to.eql("my-test-service");
      expect(myListener.address).to.eql("fake.rss.service");
      expect(myListener.customfields).to.eql([]);
      expect(myListener.parser.options.customFields).to.eql({
        feed: [],
        item: [],
      });
    });
    it("The build without issues (raw infos : just 3 params (no custom fields))", function () {
      myListener = new Listeners("my-test-service", "fake.rss.service", 15);

      // assertions
      // myListener data
      expect(myListener.timeloop).to.eql(15);
      expect(myListener.name).to.eql("my-test-service");
      expect(myListener.address).to.eql("fake.rss.service");
      expect(myListener.customfields).to.eql([]);
      expect(myListener.parser.options.customFields).to.eql({
        feed: [],
        item: [],
      });
    });
    it("The build without issues (raw infos : just 3 params (no timeloop))", function () {
      myListener = new Listeners(
        "my-test-service",
        "fake.rss.service",
        undefined,
        [
          ["description", ["media:group", "media:description"]],
          ["icon", ["media:group", "media:thumbnail"]],
        ]
      );

      // assertions
      // myListener data
      expect(myListener.timeloop).to.eql(5 * 60);
      expect(myListener.name).to.eql("my-test-service");
      expect(myListener.address).to.eql("fake.rss.service");
      expect(myListener.customfields).to.eql([
        ["description", ["media:group", "media:description"]],
        ["icon", ["media:group", "media:thumbnail"]],
      ]);
      expect(myListener.parser.options.customFields).to.eql({
        feed: [],
        item: ["media:group", "media:group"],
      });
    });
  });

  describe("fetch some data", function () {
    it("fetch without issues", function () {
      // classic build
      myListener = new Listeners(infosListener);
      // fetch
      let res = myListener.fetchRSS();

      //assertion
      // calls
      expect(stubParser).to.have.been.calledOnce;
      expect(stubParser).to.have.been.calledWith(infosListener._address);
      // Promise
      //await expect(Promise.resolve(res)).to.be.eql(mockedRSSOutput);
      res.then((obj: any, err: Error) => {
        // TODO
        expect(obj).to.be.eql(mockedRSSOutput);
        expect(err).to.be.undefined;
      });
    });
    it("fetch with bad address", function () {
      // classic build
      myListener = new Listeners(
        "my-test-service",
        "bad.rss.service",
        undefined,
        [
          ["description", ["media:group", "media:description"]],
          ["icon", ["media:group", "media:thumbnail"]],
        ]
      );
      // fetch
      let res = myListener.fetchRSS();

      //assertion
      // calls
      expect(stubParser).to.have.been.calledOnce;
      expect(stubParser).to.have.been.calledWith("bad.rss.service");
      // Promise
      res.then((obj: any, err: Error) => {
        expect(obj).to.be.undefined;
        expect(err).to.be.eql(new Error("connect ECONNREFUSED 127.0.0.1:80"));
      });
    });
  });

  describe("start", function () {
    it("Let's start the timer", async function () {
      //custom timeout
      this.timeout(15000);

      // classic build
      myListener = new Listeners("my-test-service", "fake.rss.service", 2, [
        ["description", ["media:group", "media:description"]],
        ["icon", ["media:group", "media:thumbnail"]],
      ]);

      //spy
      const fun_spy: SinonSpy = sinon.spy();

      // start timer
      myListener.start(fun_spy);

      await new Promise((res) => setTimeout(res, 5 * 1000));

      myListener.stop();

      //assertion
      // calls
      expect(1).to.be.eql(1);
      expect(fun_spy).to.have.been.callCount(3);
      expect(fun_spy).to.have.been.calledWith(mockedRSSOutput, undefined);
    });
    it("Let's start the timer (with a bad address)", async function () {
      //custom timeout
      this.timeout(15000);

      // classic build
      myListener = new Listeners("my-test-service", "bad.rss.service", 2, [
        ["description", ["media:group", "media:description"]],
        ["icon", ["media:group", "media:thumbnail"]],
      ]);

      //spy
      const fun_spy: SinonSpy = sinon.spy();

      // start timer
      myListener.start(fun_spy);

      await new Promise((res) => setTimeout(res, 5 * 1000));

      myListener.stop();
      //assertion
      // calls
      expect(1).to.be.eql(1);
      expect(fun_spy).to.have.been.callCount(3);
      expect(fun_spy).to.have.been.calledWith(undefined, Error); //yagni
    });
  });
});