const assert = require('chai').assert;

import { 
    ConfigParams, Descriptor, IdGenerator, RandomArray, 
    RandomFloat, RandomInteger, References 
} from "pip-services3-commons-nodex";

import { TestCommandableHttpClient } from "pip-services3-rpc-nodex";

import { FireMapTileV1, FireMapUpdateTypeV1 } from "../../../src/data/version1";
import { FireMapUpdateV1 } from "../../../src/data/version1/FireMapUpdateV1";
import { FireMapController } from "../../../src/logic/FireMapController";
import { FireMapUtil } from "../../../src/map_utils/FireMapUtil";
import { FireMapMemoryPersistence } from "../../../src/persistence/FireMapMemoryPersistence";
import { FireMapsCommandableHttpServiceV1 } from "../../../src/services/version1/FireMapsCommandableHttpServiceV1";

suite('FireMapsCommandableHttpServiceV1', () => {

    let persistence: FireMapMemoryPersistence;
    let controller: FireMapController;
    let service: FireMapsCommandableHttpServiceV1;
    let client: TestCommandableHttpClient;

    setup(async () => {
        let restConfig = ConfigParams.fromTuples(
            'connection.protocol', 'http',
            'connection.port', 3000,
            'connection.host', 'localhost'
        );

        persistence = new FireMapMemoryPersistence();
        persistence.configure(new ConfigParams());

        controller = new FireMapController();
        controller.configure(new ConfigParams());

        service = new FireMapsCommandableHttpServiceV1();
        service.configure(restConfig);

        client = new TestCommandableHttpClient('v1/firemap')
        client.configure(restConfig);

        let references = References.fromTuples(
            new Descriptor('eic-stopfires-services-firemap', 'persistence', 'memory', 'default', '1.0'),
            persistence,
            new Descriptor('eic-stopfires-services-firemap', 'controller', 'default', 'default', '1.0'),
            controller,
            new Descriptor('eic-stopfires-services-firemap', 'service', 'commandable-http', 'default', '1.0'),
            service
        );

        controller.setReferences(references);
        service.setReferences(references);
        
        await persistence.open(null);
        await persistence.clear(null);

        await service.open(null);
        await client.open(null);
    });

    teardown(async () => {
        await persistence.close(null);
        await client.close(null);
        await service.close(null);
    });

    test('Get and Update Fire Maps', async () => {
        let updates: FireMapUpdateV1[] = [];
        
        // generate updates
        for (let i = 0; i < 10; i++) {
            updates.push({
                type: RandomArray.pick(Object.values(FireMapUpdateTypeV1)),
                time: new Date(),
                drone_id: IdGenerator.nextLong(),
                long: RandomFloat.nextFloat(-180, 180),
                lat: RandomFloat.nextFloat(-90, 90),
                people: RandomInteger.nextInteger(0, 15)
            });
        }

        await client.callCommand<any>(
            'update_tiles',
            null,
            {
                updates: updates
            }
        );

        let tiles = await client.callCommand<FireMapTileV1[]>('get_tiles', null, null);
        
        assert.isNotNull(tiles);
        assert.isTrue(tiles.length > 0);

        // test filters
        let params = {
            flat: -10,
            flng: -50,
            tlat: 45,
            tlng: 50,
            zoom: 2
        };

        tiles = await client.callCommand<FireMapTileV1[]>(
            'get_tiles', 
            null,
            params
        );

        for (let tile of tiles) {
            assert.equal(tile.zoom, 2);
            assert.isTrue(params.flat <= tile.flat && tile.flat <= params.tlat);
            assert.isTrue(params.flng <= tile.flng && tile.flng <= params.tlng);
            assert.isTrue(params.flat <= tile.tlat && tile.tlat <= params.tlat);
            assert.isTrue(params.flng <= tile.tlng && tile.tlng <= params.tlng);
        }

        // update created tiles
        let update: FireMapUpdateV1 = updates[0];
        update.people = 150;

        let zoom = 0;
        let locator = FireMapUtil.getLocator({ lat: update.lat, long: update.long });
        locator = FireMapUtil.composeTileLocByZoom(locator, zoom);

        await client.callCommand<any>(
            'update_tiles',
            null,
            {
                updates: [update]
            }
        );

        tiles = await client.callCommand<FireMapTileV1[]>(
            'get_tiles',
            null,
            {zoom: zoom}
        );

        assert.isNotNull(tiles);
        assert.isTrue(tiles.length > 0);

        let tile: FireMapTileV1 = tiles.find(t => t.id == locator);

        assert.equal(tile.id, locator);
        assert.equal(tile.people_count, 150);

    });
});