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

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

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

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 stubParser: sinon.StubbedInstance<Parser>;
  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.stubObject<Parser>(Parser.prototype, ["parseURL"]);

    stubParser.parseURL
      .withArgs(infosListener.address)
      .resolves(mockedRSSOutput);
    stubParser.parseURL
      .withArgs("bad.rss.service")
      .rejects(new Error("connect ECONNREFUSED 127.0.0.1:80"));

    // constructor
    myListener = undefined;
  });

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

  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"],
      });
      /* // TODO test des champs dans l'objet parser
      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({
        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 () {
      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 () {
    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 () {
    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 () {
      // classic build
      myListener = new Listeners(infosListener);

      myListener.parser = stubParser; // replace the parser by my fake parser
      // fetch
      let res = myListener.fetchRSS();

      //assertion
      // calls
      expect(stubParser.parseURL).to.have.been.calledOnce;
      expect(stubParser.parseURL).to.have.been.calledWith(
        infosListener.address
      );
      // Promise
      //await expect(Promise.resolve(res)).to.be.eql(mockedRSSOutput);
      res
        .then((obj: any) => {
          expect(obj).to.be.eql(mockedRSSOutput);
        })
        .catch((err) => {
          expect(err).to.be.undefined;
        });
    });
    it("fetch with bad address", function () {
      // classic build
      myListener = new Listeners({
        name: "my-test-service",
        address: "bad.rss.service",
        customfields: {
          description: ["media:group", "media:description"],
          icon: ["media:group", "media:thumbnail"],
        },
      });
      myListener.parser = stubParser; // replace the parser by my fake parser
      // fetch
      let res = myListener.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("start", function () {
    it("Let's start the timer", async function (done) {
      this.timeout(5000);
      let clock: sinon.default.SinonFakeTimers = sinon.default.useFakeTimers({
        toFake: ["setTimeout"],
      });

      // let stubTempo = sinon.stubObject<Listeners>(Listeners.prototype, [
      //   "fetchRSS",
      // ]);
      // stubTempo.fetchRSS.returns(
      //   new Promise<any>((callback: any) => {
      //     callback();
      //   })
      // );

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

      //spy
      let fun_spy: sinon.default.SinonSpy = sinon.default.spy((obj) => {
        console.log("ok");
        expect(obj).to.be.eql(mockedRSSOutput);
        done();
      });

      // start timer
      myListener.start(fun_spy);

      await clock.tickAsync(100);
      expect(fun_spy).to.have.been.calledOnce;

      //
      // await clock.tickAsync(4000);
      //
      // expect(fun_spy).to.have.been.calledThrice;

      myListener.stop();
      //assertion
      // calls
      // expect(fun_spy).to.have.been.callCount(3);
      // expect(fun_spy).to.have.been.calledWith(mockedRSSOutput, undefined);
    });

    it.skip("Let's start the timer (with a bad address)", async function () {
      //custom timeout
      // this.timeout(15000);

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

      //spy
      const fun_spy: sinon.default.SinonSpy = sinon.default.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
    });
  });
});