/*
 * Copyright (C) 2020 StApps
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
import {ApiResponse, Client} from '@elastic/elasticsearch';
import {
  SCMonitoringConfiguration,
  SCMonitoringLogAction,
  SCMonitoringMailAction,
  SCMonitoringWatcher, SCThings
} from '@openstapps/core';
import {Logger} from '@openstapps/logger';
import {SearchResponse} from 'elasticsearch';
import {MailQueue} from '../../../src/notification/mail-queue';
import {setUp} from '../../../src/storage/elasticsearch/monitoring';

import {getTransport} from '../../common';
import { expect } from 'chai';
import sinon from 'sinon';
import cron from 'node-cron';
import * as templating from '../../../src/storage/elasticsearch/templating';

describe('Monitoring', async function () {
  const sandbox = sinon.createSandbox();
  const logAction: SCMonitoringLogAction = {
    message: 'Foo monitoring message',
    prefix: 'Backend Monitoring',
    type: 'log'
  };
  const mailAction: SCMonitoringMailAction = {
    message: 'Bar monitoring message',
    recipients: ['xyz@xyz.com'],
    subject: 'Backend Monitoring',
    type: 'mail'
  };
  let transport: any;
  // @ts-ignore
  let mailQueue: any;
  beforeEach(async function () {
    transport = getTransport(true);
    mailQueue = new MailQueue(transport);
    cronScheduleStub = sandbox.stub(cron, 'schedule');
    sandbox.stub(templating, 'checkESTemplate');
  });
  afterEach(async function () {
    sandbox.restore();
  });
  // const sandbox = sinon.createSandbox();
  let cronScheduleStub: sinon.SinonStub
  const minLengthWatcher: SCMonitoringWatcher = {
    actions: [logAction, mailAction],
    conditions: [
      {
        length: 10,
        type: 'MinimumLength'
      }
    ],
    name: 'foo watcher',
    query: {foo: 'bar'},
    triggers: [
      {
        executionTime: 'monthly',
        name: 'beginning of month'
      },
      {
        executionTime: 'daily',
        name: 'every night'
      }
    ]
  };
  const maxLengthWatcher: SCMonitoringWatcher = {
    actions: [logAction, mailAction],
    conditions: [
      {
        length: 30,
        type: 'MaximumLength'
      }
    ],
    name: 'foo watcher',
    query: {bar: 'foo'},
    triggers: [
      {
        executionTime: 'hourly',
        name: 'every hour'
      },
      {
        executionTime: 'weekly',
        name: 'every week'
      },
    ]
  };
  const monitoringConfig: SCMonitoringConfiguration = {
    actions: [logAction, mailAction],
    watchers: [minLengthWatcher, maxLengthWatcher]
  };

  it('should create a schedule for each trigger', async function () {
    await setUp(monitoringConfig, new Client({node: 'http://foohost:9200'}), mailQueue);

    expect(cronScheduleStub.callCount).to.be.equal(4);
  });

  it('should log errors where conditions failed', async function () {
    const fakeSearchResponse: Partial<ApiResponse<SearchResponse<SCThings>>> = {
      // @ts-ignore
      body: {
       took: 12,
       timed_out: false,
       // @ts-ignore
       _shards: {},
       // @ts-ignore
       hits: {
         total: 123
       },
      },
    };
    let fakeClient = new Client({node: 'http://foohost:9200'});
    const loggerErrorStub = sandbox.stub(Logger, 'error');
    const mailQueueSpy = sinon.spy(mailQueue, 'push');
    cronScheduleStub.yields();
    sandbox.stub(fakeClient, 'search').resolves(fakeSearchResponse);
    await setUp(monitoringConfig, fakeClient, mailQueue);

    expect(loggerErrorStub.callCount).to.be.equal(2);
    expect(mailQueueSpy.callCount).to.be.equal(2);
  });
});