import { ContractAddresses } from '@0x/contract-addresses';
import { SignedOrder } from '@0x/types';
import { BigNumber, logUtils } from '@0x/utils';
import { Provider } from 'ethereum-types';
import * as http from 'http';
import * as WebSocket from 'websocket';

import { webSocketUtf8MessageSchema } from '../schemas/websocket_utf8_message_schema';
import { OnOrderStateChangeCallback, OrderWatcherConfig } from '../types';
import { assert } from '../utils/assert';

import { OrderWatcher } from './order_watcher';

const DEFAULT_HTTP_PORT = 8080;

const enum OrderWatcherAction {
    // Actions initiated by the user.
    getStats = 'getStats',
    addOrderAsync = 'addOrderAsync',
    removeOrder = 'removeOrder',
    // These are spontaneous; they are primarily orderstate changes.
    orderWatcherUpdate = 'orderWatcherUpdate',
    // `subscribe` and `unsubscribe` are methods of OrderWatcher, but we don't
    // need to expose them to the WebSocket server user because the user implicitly
    // subscribes and unsubscribes by connecting and disconnecting from the server.
}

// Users have to create a json object of this format and attach it to
// the data field of their WebSocket message to interact with this server.
interface WebSocketRequestData {
    action: OrderWatcherAction;
    params: any;
}

// Users should expect a json object of this format in the data field
// of the WebSocket messages that this server sends out.
interface WebSocketResponseData {
    action: OrderWatcherAction;
    success: number;
    result: any;
}

// Wraps the OrderWatcher functionality in a WebSocket server. Motivations:
// 1) Users can watch orders via non-typescript programs.
// 2) Better encapsulation so that users can work
export class OrderWatcherWebSocketServer {
    public httpServer: http.Server;
    public readonly _orderWatcher: OrderWatcher;
    private readonly _connectionStore: Set<WebSocket.connection>;
    private readonly _wsServer: WebSocket.server;
    /**
     * Instantiate a new web socket server which provides OrderWatcher functionality
     *  @param provider Web3 provider to use for JSON RPC calls (for OrderWatcher)
     *  @param networkId NetworkId to watch orders on (for OrderWatcher)
     *  @param contractAddresses Optional contract addresses. Defaults to known
     *  addresses based on networkId (for OrderWatcher)
     *  @param partialConfig Optional configurations (for OrderWatcher)
     */
    constructor(
        provider: Provider,
        networkId: number,
        contractAddresses?: ContractAddresses,
        partialConfig?: Partial<OrderWatcherConfig>,
    ) {
        this._orderWatcher = new OrderWatcher(provider, networkId, contractAddresses, partialConfig);
        this._connectionStore = new Set();
        this.httpServer = http.createServer();
        this._wsServer = new WebSocket.server({
            httpServer: this.httpServer,
            autoAcceptConnections: false,
        });

        this._wsServer.on('request', (request: any) => {
            // Designed for usage pattern where client and server are run on the same
            // machine by the same user. As such, no security checks are in place.
            const connection: WebSocket.connection = request.accept(null, request.origin);
            logUtils.log(`${new Date()} [Server] Accepted connection from origin ${request.origin}.`);
            connection.on('message', this._messageCallback.bind(this, connection));
            connection.on('close', this._closeCallback.bind(this, connection));
            this._connectionStore.add(connection);
        });

        // Have the WebSocket server subscribe to the OrderWatcher to receive updates.
        // These updates are then broadcast to clients in the _connectionStore.
        this._orderWatcher.subscribe(this._broadcastCallback);
    }

    /**
     * Activates the WebSocket server by having its HTTP server start listening.
     */
    public listen(): void {
        this.httpServer.listen(DEFAULT_HTTP_PORT, () => {
            logUtils.log(`${new Date()} [Server] Listening on port ${DEFAULT_HTTP_PORT}`);
        });
    }

    public close(): void {
        this.httpServer.close();
    }

    private _messageCallback(connection: WebSocket.connection, message: any): void {
        assert.doesConformToSchema('message', message, webSocketUtf8MessageSchema);
        const requestData: WebSocketRequestData = JSON.parse(message.utf8Data);
        const responseData = this._routeRequest(requestData);
        logUtils.log(`${new Date()} [Server] OrderWatcher output: ${JSON.stringify(responseData)}`);
        connection.sendUTF(JSON.stringify(responseData));
    }

    private _closeCallback(connection: WebSocket.connection): void {
        this._connectionStore.delete(connection);
        logUtils.log(`${new Date()} [Server] Client ${connection.remoteAddress} disconnected.`);
    }

    private _routeRequest(requestData: WebSocketRequestData): WebSocketResponseData {
        const responseData: WebSocketResponseData = {
            action: requestData.action,
            success: 0,
            result: undefined,
        };

        try {
            logUtils.log(`${new Date()} [Server] Request received: ${requestData.action}`);
            switch (requestData.action) {
                case 'addOrderAsync': {
                    const signedOrder: SignedOrder = this._parseSignedOrder(requestData);
                    // tslint:disable-next-line:no-floating-promises
                    this._orderWatcher.addOrderAsync(signedOrder); // Ok to fireNforget
                    break;
                }
                case 'removeOrder': {
                    this._orderWatcher.removeOrder(requestData.params.orderHash);
                    break;
                }
                case 'getStats': {
                    responseData.result = this._orderWatcher.getStats();
                    break;
                }
                default:
                    throw new Error(`[Server] Invalid request action: ${requestData.action}`);
            }
            responseData.success = 1;
        } catch (err) {
            responseData.result = { error: err.toString() };
        }
        return responseData;
    }

    /**
     * Broadcasts OrderState changes to ALL connected clients. At the moment,
     * we do not support clients subscribing to only a subset of orders. As such,
     * Client B will be notified of changes to an order that Client A added.
     */
    private readonly _broadcastCallback: OnOrderStateChangeCallback = (err, orderState) => {
        this._connectionStore.forEach((connection: WebSocket.connection) => {
            const responseData: WebSocketResponseData = {
                action: OrderWatcherAction.orderWatcherUpdate,
                success: 1,
                result: orderState || err,
            };
            connection.sendUTF(JSON.stringify(responseData));
        });
        // tslint:disable-next-line:semicolon
    }; // tslint thinks this is a class method, It's actally a property that holds a function.

    /**
     * Recover types lost when the payload is stringified.
     */
    private readonly _parseSignedOrder = (requestData: WebSocketRequestData) => {
        const signedOrder = requestData.params.signedOrder;
        const bigNumberFields = [
            'salt',
            'makerFee',
            'takerFee',
            'makerAssetAmount',
            'takerAssetAmount',
            'expirationTimeSeconds',
        ];
        for (const field of bigNumberFields) {
            signedOrder[field] = new BigNumber(signedOrder[field]);
        }
        return signedOrder;
        // tslint:disable-next-line:semicolon
    }; // tslint thinks this is a class method, It's actally a property that holds a function.
}