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

// tested class
import {
  ListenerRSSInfos as ListenerRRSInfo,
  ListenerRss as Listeners,
} from "./../src/index";

// Unit test
import * as chai from "chai";
import * as sinon from "ts-sinon";

const sinonChai = require("sinon-chai");

chai.use(sinonChai);

const expect = chai.expect;

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

  const infosListener: ListenerRRSInfo = {
    name: "my-test-service",
    address: "fake.rss.service",
    timeloop: 15,
    customfields: {
      description: ["media:group", "media:description"],
      icon: ["media:group", "media:thumbnail"],
    },
  };

  // parseURL tests
  let stubListener: sinon.StubbedInstance<Listeners>;
  let stubParser: sinon.StubbedInstance<Parser>;

  const mockedRSSOutput: Parser.Output<{
    "media:group": { [key: string]: string | [any] };
  }> = {
    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",
      },
    ],
  };

  /**
   * The function create my Stubs for my Listener and my Parser
   */
  function fun_initStub(
    myListener: Listeners
  ): sinon.StubbedInstance<Listeners> {
    stubListener = sinon.stubObject<Listeners>(myListener, ["setParser"]);
    stubListener.setParser.callsFake(() => {
      if (stubListener.parser !== undefined) {
        stubParser = sinon.stubObject<Parser>(stubListener.parser, [
          "parseURL",
        ]);
        stubParser.parseURL
          .withArgs(infosListener.address)
          .resolves(mockedRSSOutput);
        stubParser.parseURL
          .withArgs("bad.rss.service")
          .rejects(new Error("connect ECONNREFUSED 127.0.0.1:80"));
      }
      stubListener.parser = stubParser;
    });
    stubListener.setParser();
    // stubListener.fetchRSS.returns(stubParser.parseURL(stubListener.address));
    return stubListener;
  }

  // afterEach(function () {
  //   // restore stubs
  //   myListener = undefined;
  // });

  describe("Building Ytb listener", function () {
    it("The build without issues (infosListener parameters)", function () {
      let 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)
        .to.have.property("options")
        .to.have.property("customFields")
        .to.be.eql({
          feed: [],
          item: ["media:group", "media:group"],
        });
    });
    it("The build without issues (raw infos : 4 params)", function () {
      let myListener = new Listeners({
        name: "my-test-service",
        address: "fake.rss.service",
        timeloop: 15,
        customfields: {
          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)
        .to.have.property("options")
        .to.have.property("customFields")
        .to.be.eql({
          feed: [],
          item: ["media:group", "media:group"],
        });
    });
    it("The build without issues (raw infos : just 2 params)", function () {
      let myListener = new Listeners({
        name: "my-test-service",
        address: "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(undefined);
      expect(myListener.parser)
        .to.have.property("options")
        .to.have.property("customFields")
        .to.be.eql({
          feed: [],
          item: [],
        });
    });
  });
  it("The build without issues (raw infos : just 3 params (no custom fields))", function () {
    let myListener = new Listeners({
      name: "my-test-service",
      address: "fake.rss.service",
      timeloop: 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(undefined);
    expect(myListener.parser)
      .to.have.property("options")
      .to.have.property("customFields")
      .to.be.eql({
        feed: [],
        item: [],
      });
  });
  it("The build without issues (raw infos : just 3 params (no timeloop))", function () {
    let myListener = new Listeners({
      name: "my-test-service",
      address: "fake.rss.service",
      customfields: {
        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)
      .to.have.property("options")
      .to.have.property("customFields")
      .to.be.eql({
        feed: [],
        item: ["media:group", "media:group"],
      });
  });

  describe("fetch some data", function () {
    it("fetch without issues", function () {
      let myListener = new Listeners(infosListener);
      fun_initStub();

      expect(myListener).to.not.be.undefined;
      if (myListener !== undefined) {
        // fetch
        let res = stubListener.fetchRSS();

        //assertion
        // calls
        expect(stubParser.parseURL).to.have.been.calledOnce;
        expect(stubParser.parseURL).to.have.been.calledWith(
          infosListener.address
        );

        res
          .then((obj: any) => {
            expect(obj).to.be.eql(mockedRSSOutput);
          })
          .catch((err) => {
            expect(err).to.be.undefined;
          });
      } else throw new Error("Error into the before instruction");
    });

    it("fetch with bad address", function () {
      let myListener = new Listeners({
        name: "my-test-service",
        address: "bad.rss.service",
        customfields: {
          description: ["media:group", "media:description"],
          icon: ["media:group", "media:thumbnail"],
        },
      });
      let stubListener = fun_initStub(myListener);
      // fetch
      let res = stubListener.fetchRSS();

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

  describe.skip("start", function () {
    it("Let's start the timer", async function () {
      let clock: sinon.default.SinonFakeTimers = sinon.default.useFakeTimers();

      // classic build
      let myListener = new Listeners({
        name: "my-test-service",
        address: "fake.rss.service",
        timeloop: 60,
        customfields: {
          description: ["media:group", "media:description"],
          icon: ["media:group", "media:thumbnail"],
        },
      });
      let stubListener = fun_initStub(myListener);
      stubListener.fetchRSS.reset();
      stubListener.fetchRSS.resolves(mockedRSSOutput);

      //spy
      let fun_spy: sinon.default.SinonSpy = sinon.default.spy((obj, err) => {
        expect(obj).to.be.eql(mockedRSSOutput);
        expect(err).to.be.eql(undefined);
      });

      // start timer
      stubListener.on("update", (obj) => fun_spy(obj));
      // stubListener.start(fun_spy);

      // wait and assertion
      // After 1ms
      await clock.tickAsync(1);
      expect(stubListener.fetchRSS).to.have.been.calledOnce;
      expect(fun_spy).to.have.been.calledOnce;

      // After 60s
      await clock.tickAsync(59999);
      expect(stubListener.fetchRSS).to.have.been.calledTwice;
      expect(fun_spy).to.have.been.calledTwice;

      stubListener.stop();
    });

    it("Let's start the timer (with a bad address)", async function () {
      let clock: sinon.default.SinonFakeTimers = sinon.default.useFakeTimers();

      // classic build
      let myListener = new Listeners({
        name: "my-test-service",
        address: "fake.rss.service",
        timeloop: 60,
        customfields: {
          description: ["media:group", "media:description"],
          icon: ["media:group", "media:thumbnail"],
        },
      });
      let stubListener = fun_initStub(myListener);
      stubListener.fetchRSS.reset();
      stubListener.fetchRSS.rejects(
        new Error("connect ECONNREFUSED 127.0.0.1:80")
      );

      //spy
      let fun_spy: sinon.default.SinonSpy = sinon.default.spy((obj, err) => {
        expect(obj).to.be.eql(undefined);
        expect(err).to.not.be.eql(undefined);
      });

      // start timer
      // stubListener.start(fun_spy);

      // wait and assertion
      // After 1ms
      await clock.tickAsync(1);
      expect(stubListener.fetchRSS).to.have.been.calledOnce;
      expect(fun_spy).to.have.been.calledOnce;

      // After 60s
      await clock.tickAsync(59999);
      expect(stubListener.fetchRSS).to.have.been.calledTwice;
      expect(fun_spy).to.have.been.calledTwice;

      stubListener.stop();
    });
  });
});