/*
Copyright 2016 Aviral Dasgupta
Copyright 2017 New Vector Ltd

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

// @flow

import type {Component} from 'react';
import CommandProvider from './CommandProvider';
import DuckDuckGoProvider from './DuckDuckGoProvider';
import RoomProvider from './RoomProvider';
import UserProvider from './UserProvider';
import EmojiProvider from './EmojiProvider';
import NotifProvider from './NotifProvider';
import Promise from 'bluebird';

export type SelectionRange = {
    start: number,
    end: number
};

export type Completion = {
    completion: string,
    component: ?Component,
    range: SelectionRange,
    command: ?string,
    // If provided, apply a LINK entity to the completion with the
    // data = { url: href }.
    href: ?string,
};

const PROVIDERS = [
    UserProvider,
    RoomProvider,
    EmojiProvider,
    NotifProvider,
    CommandProvider,
    DuckDuckGoProvider,
];

// Providers will get rejected if they take longer than this.
const PROVIDER_COMPLETION_TIMEOUT = 3000;

export default class Autocompleter {
    constructor(room) {
        this.room = room;
        this.providers = PROVIDERS.map((p) => {
            return new p(room);
        });
    }

    destroy() {
        this.providers.forEach((p) => {
            p.destroy();
        });
    }

    async getCompletions(query: string, selection: SelectionRange, force: boolean = false): Array<Completion> {
        /* Note: This intentionally waits for all providers to return,
         otherwise, we run into a condition where new completions are displayed
         while the user is interacting with the list, which makes it difficult
         to predict whether an action will actually do what is intended
        */
        const completionsList = await Promise.all(
            // Array of inspections of promises that might timeout. Instead of allowing a
            // single timeout to reject the Promise.all, reflect each one and once they've all
            // settled, filter for the fulfilled ones
            this.providers.map((provider) => {
                return provider
                    .getCompletions(query, selection, force)
                    .timeout(PROVIDER_COMPLETION_TIMEOUT)
                    .reflect();
            }),
        );

        return completionsList.filter(
            (inspection) => inspection.isFulfilled(),
        ).map((completionsState, i) => {
            return {
                completions: completionsState.value(),
                provider: this.providers[i],

                /* the currently matched "command" the completer tried to complete
                 * we pass this through so that Autocomplete can figure out when to
                 * re-show itself once hidden.
                 */
                command: this.providers[i].getCurrentCommand(query, selection, force),
            };
        });
    }
}