import { Meteor } from 'meteor/meteor';
import { Router } from 'meteor/iron:router';
import { Accounts } from 'meteor/accounts-base';

import { OHIF } from 'meteor/ohif:core';

const url = require("url");
const http = require("http");
const https = require("https");
const querystring = require("querystring");

const doAuth = Meteor.users.find().count() ? true : false;

const authenticateUser = request => {
    // Only allow logged-in users to access this route
    const userId = request.headers['x-user-id']
    const loginToken = request.headers['x-auth-token']
    if (!userId || !loginToken) {
        return;
    }

    const hashedToken = Accounts._hashLoginToken(loginToken);

    return Meteor.users.findOne({
        _id: userId,
        'services.resume.loginTokens.hashedToken': hashedToken
    });
}

// Setup a Route using Iron Router to avoid Cross-origin resource sharing
// (CORS) errors. We only handle this route on the Server.
Router.route(Settings.uri.replace(OHIF.utils.absoluteUrl(), ''), function() {
    const request = this.request;
    const response = this.response;
    const params = this.params;

    let user;
    if (doAuth) {
        user = authenticateUser(request);
        if (!user) {
            response.writeHead(401);
            response.end('Error: You must be logged in to perform this action.\n');
            return;
        }
    }

    // TODO: Merge this with ohif-study-list? There is a circular dependency now...
    const server = Servers.findOne(params.query.serverId);
    if (!server) {
        response.writeHead(500);
        response.end('Error: No Server with the specified Server ID was found.\n');
        return;
    }

    const requestOpt = server.requestOptions;

    // If no Web Access to DICOM Objects (WADO) Service URL is provided
    // return an error for the request.
    const wadoUrl = params.query.url;
    if (!wadoUrl) {
        response.writeHead(500);
        response.end('Error: No WADO URL was provided.\n');
        return;
    }

    if (requestOpt.logRequests) {
        console.log(request.url);
    }

    if (requestOpt.logTiming) {
        console.time(request.url);
    }

    // Use Node's URL parse to decode the query URL
    const parsed = url.parse(wadoUrl);

    // Create an object to hold the information required
    // for the request to the PACS. 
    let options = {
        headers: {},
        method: request.method,
        hostname: parsed.hostname,
        path: parsed.path
    };

    let requester;
    if (parsed.protocol === 'https:') {
        requester = https.request;

        const allowUnauthorizedAgent = new https.Agent({ rejectUnauthorized: false });
        options.agent = allowUnauthorizedAgent
    } else {
        requester = http.request;
    }

    if (parsed.port) {
        options.port = parsed.port;
    }

    Object.keys(request.headers).forEach(entry => {
        const value = request.headers[entry];
        if (entry) {
            options.headers[entry] = value;
        }
    });

    // Retrieve the authorization user:password string for the PACS,
    // if one is required, and include it in the request to the PACS.
    if (requestOpt.auth) {
        options.auth = requestOpt.auth;
    }

    // Use Node's HTTP API to send a request to the PACS
    const proxyRequest = requester(options, proxyResponse => {
        // When we receive data from the PACS, stream it as the
        // response to the original request.
        // console.log(`Got response: ${proxyResponse.statusCode}`);
        response.writeHead(proxyResponse.statusCode, proxyResponse.headers);

        if (requestOpt.logTiming) {
            console.timeEnd(request.url);
        }

        return proxyResponse.pipe(response, {end: true});
    });

    // If our request to the PACS fails, log the error message
    proxyRequest.on('error', error => {
        response.writeHead(500);
        response.end(`Error: Problem with request to PACS: ${error.message}\n`);
    });

    // Stream the original request information into the request
    // to the PACS
    request.pipe(proxyRequest);
}, {
    where: 'server'
});