import EventEmitter from "../events.js";
import HookEvent from "../hook.js";

class Xhr extends EventEmitter {
    constructor(ctx) {
        super();
        this.ctx = ctx;
        this.window = ctx.window;
        this.XMLHttpRequest = this.window.XMLHttpRequest;
        this.xhrProto = this.window.XMLHttpRequest ? this.window.XMLHttpRequest.prototype : {};
        this.open = this.xhrProto.open;
        this.abort = this.xhrProto.abort;
        this.send = this.xhrProto.send;
        this.overrideMimeType = this.xhrProto.overrideMimeType
        this.getAllResponseHeaders = this.xhrProto.getAllResponseHeaders;
        this.getResponseHeader = this.xhrProto.getResponseHeader;
        this.setRequestHeader = this.xhrProto.setRequestHeader;
        this.responseURL = ctx.nativeMethods.getOwnPropertyDescriptor(this.xhrProto, 'responseURL');
        this.responseText = ctx.nativeMethods.getOwnPropertyDescriptor(this.xhrProto, 'responseText');
    };
    override() {
        this.overrideOpen();
        this.overrideSend();
        this.overrideMimeType();
        this.overrideGetResHeader();
        this.overrideGetResHeaders();
        this.overrideSetReqHeader();
    };
    overrideOpen() {
        this.ctx.override(this.xhrProto, 'open', (target, that, args) => {
            if (2 > args.length) return target.apply(that, args);

            let [ method, input, async = true, user = null, password = null ] = args;
            const event = new HookEvent({ method, input, async, user, password }, target, that);

            this.emit('open', event);
            if (event.intercepted) return event.returnValue;

            return event.target.call(
                event.that, 
                event.data.method, 
                event.data.input, 
                event.data.async, 
                event.data.user, 
                event.data.password
            );
        });
    };
    overrideResponseUrl() {
        this.ctx.overrideDescriptor(this.xhrProto, 'responseURL', {
            get: (target, that) => {
                const event = new HookEvent({ value: target.call(that) }, target, that);
                this.emit('responseUrl', event);

                if (event.intercepted) return event.returnValue;
                return event.data.value;
            },
        });
    };
    overrideSend() {
        this.ctx.override(this.xhrProto, 'send', (target, that, [ body = null ]) => {
            const event = new HookEvent({ body }, target, that);

            this.emit('send', event);
            if (event.intercepted) return event.returnValue;

            return event.target.call(
                event.that,
                event.data.body,
            );
        });
    };
    overrideSetReqHeader() {
        this.ctx.override(this.xhrProto, 'setRequestHeader', (target, that, args) => {
            if (2 > args.length) return target.apply(that, args);

            let [ name, value ] = args;
            const event = new HookEvent({ name, value }, target, that);

            this.emit('setReqHeader', event);
            if (event.intercepted) return event.returnValue;

            return event.target.call(event.that, event.data.name, event.data.value);
        });
    };
    overrideGetResHeaders() {
        this.ctx.override(this.xhrProto, 'getAllResponseHeaders', (target, that) => {
            const event = new HookEvent({ value: target.call(that) }, target, that);

            this.emit('getAllResponseHeaders', event);
            if (event.intercepted) return event.returnValue;

            return event.data.value;
        });
    };
    overrideGetResHeader() {
        this.ctx.override(this.xhrProto, 'getResponseHeader', (target, that, args) => {
            if (!args.length) return target.apply(that, args);
            let [ name ] = args;

            const event = new HookEvent({ name, value: target.call(that, name) }, target, that);
            if (event.intercepted) return event.returnValue;

            return event.data.value;
        });
    };
}; 

export default Xhr