import { CONTENT_TYPES, HEADER_NAMES, ODATA_PARAMS, SF_PARAMS } from "../constants";
import { RequestOptionsBase } from "../Data";
import { Query } from "../Query";
import { TypeOptions } from "../Sitefinity";
import { utils } from "../utils";

export class RequestBase {
    public successCb: Function;
    public failureCb: Function;
    public progressCb: Function;
    public key: string | number;
    public urlOptions: TypeOptions;
    protected query: Query;
    protected action: string;
    private fallbackProperties: string[];

    constructor(options: RequestOptionsBaseExtended) {
        this.successCb = options.successCb;
        this.failureCb = options.failureCb;
        this.progressCb = options.progressCb;
        this.urlOptions = options.urlOptions;
        this.key = options.key;
        this.action = options.action;
        this.fallbackProperties = options.fallbackProperties;
        this.query = options.query;
    }

    getQueryString(urlOptions: TypeOptions, query: Query): string {
        const paramDictionary: { [key: string]: string } = {};

        this.getQueryParameters(paramDictionary, urlOptions, query);
        const keys = Object.keys(paramDictionary);
        if (keys.length == 0)
            return null;

        let queryString = "?";
        for (const prop in paramDictionary) {
            queryString += prop + "=" + paramDictionary[prop] + "&";
        }

        queryString = queryString.substring(0, queryString.length - 1);

        return queryString;
    }

    getBody(): object {
        return undefined;
    }

    getMethod(): string {
        return null;
    }

    getHeaders(): { [key: string]: string } {
        const headers = this.urlOptions.additionalHeaders ?? {};
        if (headers[HEADER_NAMES.contentType] == undefined) {
            headers[HEADER_NAMES.contentType] = CONTENT_TYPES.json;
        }

        return headers;
    }

    buildUrl(): string {
        let url = this.urlOptions.baseUrl + (this.urlOptions.entitySet || "");
        url += this.key ? ("(" + this.key + ")") : "";
        if (this.action) {
            url += url.endsWith("/") ? "" : "/";
            url += this.action;
        }

        // including count here
        // not the best solution as build() is called once more in getQueryString
        // but not that big of an issue right now
        if (this.query) {
            const getCount = this.query.build().$count;

            if (utils.isBoolean(getCount) && !getCount) {
                url += "/$count";
            }
        }

        return this.addQueryParameters(url);
    }

    protected parseResponse(http: XMLHttpRequest): string | any {
        const data = utils.parseStringToJson(http.responseText);
        if (data) {
            if (http.status >= 400 && data.error) {
                return data.error;
            }

            return data;
        }

        return http.responseText;
    }

    protected addQueryParameters(url: string): string {
        let queryString = this.getQueryString(this.urlOptions, this.query);

        if (queryString) {
            if (url.indexOf("?") > -1 && queryString[0] == "?") {
                queryString = "&" + queryString.substring(1);
            }

            url += queryString;
        }

        return url;
    }

    private getQueryParameters(paramDictionary: { [key: string]: string }, urlOptions: TypeOptions, query: Query) {
        if (query) {
            const builtQuery = query.build();
            if (utils.isString(builtQuery.$filter))
                paramDictionary[ODATA_PARAMS.$filter] = builtQuery.$filter;
            if (utils.isString(builtQuery.$select))
                paramDictionary[ODATA_PARAMS.$select] = builtQuery.$select;
            if (utils.isString(builtQuery.$expand))
                paramDictionary[ODATA_PARAMS.$expand] = builtQuery.$expand;
            if (utils.isString(builtQuery.$orderby))
                paramDictionary[ODATA_PARAMS.$orderby] = builtQuery.$orderby;
            if (utils.isNumber(builtQuery.$skip))
                paramDictionary[ODATA_PARAMS.$skip] = builtQuery.$skip;
            if (utils.isNumber(builtQuery.$top))
                paramDictionary[ODATA_PARAMS.$top] = builtQuery.$top;
            if (utils.isString(builtQuery.$search))
                paramDictionary[ODATA_PARAMS.$search] = builtQuery.$search;

            // inline count
            if (utils.isBoolean(builtQuery.$count) && builtQuery.$count)
                paramDictionary[ODATA_PARAMS.$count] = builtQuery.$count;
        }

        if (urlOptions.provider) {
            paramDictionary[SF_PARAMS.provider] = urlOptions.provider;
        }

        if (urlOptions.culture) {
            paramDictionary[SF_PARAMS.culture] = urlOptions.culture;
        }

        if (urlOptions.siteId) {
            paramDictionary[SF_PARAMS.siteId] = urlOptions.siteId;
        }

        if (this.fallbackProperties) {
            paramDictionary[SF_PARAMS.fallbackParams] = this.fallbackProperties.join();
        }

        if (urlOptions.additionalQueryParams) {
            for (const key in urlOptions.additionalQueryParams) {
                if (urlOptions.additionalQueryParams.hasOwnProperty(key)) {
                    paramDictionary[key] = urlOptions.additionalQueryParams[key];
                }
            }
        }
    }
}

export interface RequestOptionsBaseExtended extends RequestOptionsBase {
    urlOptions: TypeOptions;
}