import { File, HttpResponseEncoding, ImageSource, Utils } from '@nativescript/core';
import { CacheOptions, HttpsFormDataParam, HttpsRequest, HttpsRequestOptions, HttpsSSLPinningOptions, HttpsResponseLegacy as IHttpsResponseLegacy } from '.';

import { getFilenameFromUrl, interceptors, networkInterceptors, parseJSON } from './request.common';
export { addNetworkInterceptor, addInterceptor } from './request.common';

interface Ipeer {
    enabled: boolean;
    allowInvalidCertificates: boolean;
    validatesDomainName: boolean;
    host?: string;
    commonName?: string;
    certificate?: string;
    x509Certificate?: java.security.cert.Certificate;
}

const peer: Ipeer = {
    enabled: false,
    allowInvalidCertificates: false,
    validatesDomainName: true
};

let cache: okhttp3.Cache;
let forceCache = false;
export function setCache(options?: CacheOptions) {
    if (options) {
        forceCache = options.forceCache === true;
        cache = new okhttp3.Cache(new java.io.File(options.diskLocation), options.diskSize);
    } else {
        cache = null;
    }
    if (Client) {
        //we need to force a new client for the builder to use cache
        getClient(undefined, true);
    }
}
export function clearCache() {
    if (cache) {
        cache.evictAll();
    }
}

// TODO: rewrite this to not have to handle
// every single property
let _timeout = 10;
let _cookiesEnabled = true;

class HttpsResponseLegacy implements IHttpsResponseLegacy {
    private callback?: com.nativescript.https.OkHttpResponse.OkHttpResponseAsyncCallback;
    constructor(private response: com.nativescript.https.OkHttpResponse, private tag: string, private url: string) {}

    get contentLength() {
        return this.response.contentLength();
    }
    getOrCreateCloseCallback() {
        if (!notClosedResponses[this.tag]) {
            // we need to store handling request to be able to cancel them
            notClosedResponses[this.tag] = this.response;
            this.response.closeCallback = new OkHttpResponse.OkHttpResponseCloseCallback({
                onClose() {
                    delete notClosedResponses[this.tag];
                }
            });
        }
    }
    getCallback(resolve, reject) {
        return new com.nativescript.https.OkHttpResponse.OkHttpResponseAsyncCallback({
            onBitmap(res) {
                resolve(new ImageSource(res));
            },
            onString(res) {
                resolve(res);
            },
            onByteArray(res) {
                resolve((ArrayBuffer as any).from(res));
            },
            onFile(res) {
                resolve(res);
            },
            onException(err) {
                reject(err);
            }
        });
    }

    // cache it because asking it again wont work as the socket is closed
    arrayBuffer: ArrayBuffer;
    toArrayBuffer() {
        try {
            this.arrayBuffer = this.arrayBuffer || (ArrayBuffer as any).from(this.response.toByteArray());
            return this.arrayBuffer;
        } catch {
            return null;
        }
    }
    toArrayBufferAsync(): Promise<ArrayBuffer> {
        if (this.arrayBuffer) {
            return Promise.resolve(this.arrayBuffer);
        }
        return new Promise((resolve, reject) => {
            this.getOrCreateCloseCallback();
            this.response.toByteArrayAsync(this.getCallback(resolve, reject));
        }).then((r: ArrayBuffer) => {
            this.arrayBuffer = r;
            return this.arrayBuffer;
        });
    }

    // cache it because asking it again wont work as the socket is closed
    stringResponse: string;
    toString() {
        // TODO: handle arraybuffer already stored
        this.stringResponse = this.stringResponse || this.response.asString();
        return this.stringResponse;
    }
    async toStringAsync(): Promise<string> {
        if (this.stringResponse) {
            return this.stringResponse;
        }
        // TODO: handle arraybuffer already stored
        this.stringResponse = await new Promise<string>((resolve, reject) => {
            this.getOrCreateCloseCallback();
            this.response.asStringAsync(this.getCallback(resolve, reject));
        });
        return this.stringResponse;
    }

    // cache it because asking it again wont work as the socket is closed
    jsonResponse: any;
    toJSON(encoding?: HttpResponseEncoding) {
        if (this.jsonResponse !== undefined) {
            return this.jsonResponse;
        }
        // TODO: handle arraybuffer already stored
        this.stringResponse = this.stringResponse || this.response.asString();
        this.jsonResponse = this.stringResponse ? parseJSON(this.stringResponse) : null;
        return this.jsonResponse;
    }

    async toJSONAsync() {
        if (this.jsonResponse !== undefined) {
            return this.jsonResponse;
        }
        if (this.stringResponse !== undefined) {
            this.jsonResponse = this.stringResponse ? parseJSON(this.stringResponse) : null;
            return this.jsonResponse;
        }
        // TODO: handle arraybuffer already stored
        const r = await this.toStringAsync();
        this.jsonResponse = r ? parseJSON(r) : null;
        return this.jsonResponse;
    }

    // cache it because asking it again wont work as the socket is closed
    imageSource: ImageSource;
    async toImage(): Promise<ImageSource> {
        if (this.imageSource) {
            return this.imageSource;
        }
        return new Promise<ImageSource>((resolve, reject) => {
            this.getOrCreateCloseCallback();
            this.response.toBitmapAsync(this.getCallback(resolve, reject)).then((r) => {
                this.imageSource = r;
                return r;
            });
        });
    }
    // toFile(destinationFilePath: string): File {
    //     if (!destinationFilePath) {
    //         destinationFilePath = getFilenameFromUrl(this.url);
    //     }
    //     const file = this.response.toFile(destinationFilePath);
    //     return File.fromPath(destinationFilePath);
    // }
    // cache it because asking it again wont work as the socket is closed
    file: File;
    toFile(destinationFilePath: string): Promise<File> {
        if (this.file) {
            return Promise.resolve(this.file);
        }
        if (!destinationFilePath) {
            destinationFilePath = getFilenameFromUrl(this.url);
        }
        return new Promise((resolve, reject) => {
            this.getOrCreateCloseCallback();
            this.response.toFileAsync(destinationFilePath, this.getCallback(resolve, reject));
        }).then(() => {
            this.file = File.fromPath(destinationFilePath);
            return this.file;
        });
    }
}

export function enableSSLPinning(options: HttpsSSLPinningOptions) {
    if (!peer.host && !peer.certificate) {
        let certificate: string;
        let inputStream: java.io.FileInputStream;
        try {
            const file = new java.io.File(options.certificate);
            inputStream = new java.io.FileInputStream(file);
            const x509Certificate = java.security.cert.CertificateFactory.getInstance('X509').generateCertificate(inputStream);
            peer.x509Certificate = x509Certificate;
            certificate = okhttp3.CertificatePinner.pin(x509Certificate);
            inputStream.close();
        } catch (error) {
            try {
                if (inputStream) {
                    inputStream.close();
                }
            } catch (e) {}
            console.error('@nativescript-community/https > enableSSLPinning error', error);
            return;
        }
        peer.host = options.host;
        peer.commonName = options.commonName || options.host;
        peer.certificate = certificate;
        if (options.allowInvalidCertificates === true) {
            peer.allowInvalidCertificates = true;
        }
        if (options.validatesDomainName === false) {
            peer.validatesDomainName = false;
        }
    }
    peer.enabled = true;
    getClient(undefined, true);
}

export function disableSSLPinning() {
    peer.enabled = false;
    getClient(undefined, true);
}
const SDKVersion = android.os.Build.VERSION.SDK_INT;

let Client: okhttp3.OkHttpClient;
let cookieJar: com.nativescript.https.QuotePreservingCookieJar;
let cookieManager: java.net.CookieManager;
export function getClient(opts: Partial<HttpsRequestOptions> = {}, reload: boolean = false): okhttp3.OkHttpClient {
    if (!Client) {
        // ssl error fix on KitKat. Only need to be done once.
        // client will be null only onced so will run only once
        if (SDKVersion >= 16 && SDKVersion < 22 && (org as any).conscrypt) {
            java.security.Security.insertProviderAt((org as any).conscrypt.Conscrypt.newProvider(), 1);
        }
    }
    // if (!Client) {
    // 	Client = new okhttp3.OkHttpClient()
    // }
    // if (Client) {
    // 	Client.connectionPool().evictAll()
    // 	Client = null
    // }
    const timeout = opts.timeout ?? 10;
    const cookiesEnabled = opts.cookiesEnabled ?? true;
    if (Client && reload === false) {
        const needTimeoutChange = timeout === _timeout;
        const needCookiesChange = cookiesEnabled === _cookiesEnabled;
        if (!needTimeoutChange && !needCookiesChange) {
            return Client;
        } else {
            const builder = Client.newBuilder();
            if (needTimeoutChange) {
                builder
                    .connectTimeout(timeout, java.util.concurrent.TimeUnit.SECONDS)
                    .writeTimeout(timeout, java.util.concurrent.TimeUnit.SECONDS)
                    .readTimeout(timeout, java.util.concurrent.TimeUnit.SECONDS);
            }
            if (needCookiesChange) {
                if (cookiesEnabled) {
                    if (!cookieJar) {
                        cookieManager = new java.net.CookieManager();
                        cookieManager.setCookiePolicy(java.net.CookiePolicy.ACCEPT_ALL);
                        cookieJar = new com.nativescript.https.QuotePreservingCookieJar(cookieManager);
                    }
                    builder.cookieJar(cookieJar);
                } else {
                    // builder.cookieJar(null);
                }
            }
            return builder.build();
        }
    }
    const builder = new okhttp3.OkHttpClient.Builder();

    _cookiesEnabled = cookiesEnabled;
    if (cookiesEnabled) {
        if (!cookieJar) {
            cookieManager = new java.net.CookieManager();
            cookieManager.setCookiePolicy(java.net.CookiePolicy.ACCEPT_ALL);
            cookieJar = new com.nativescript.https.QuotePreservingCookieJar(cookieManager);
        }
        builder.cookieJar(cookieJar);
    }

    interceptors.forEach((interceptor) => builder.addInterceptor(interceptor));
    networkInterceptors.forEach((interceptor) => builder.addNetworkInterceptor(interceptor));
    if (peer.enabled === true) {
        if (peer.host || peer.certificate) {
            // const spec = okhttp3.ConnectionSpec.MODERN_TLS;
            // builder.connectionSpecs(java.util.Collections.singletonList(spec));

            const pinner = new okhttp3.CertificatePinner.Builder();
            pinner.add(peer.host, [peer.certificate]);
            builder.certificatePinner(pinner.build());

            if (peer.allowInvalidCertificates === false) {
                try {
                    const x509Certificate = peer.x509Certificate;
                    const keyStore = java.security.KeyStore.getInstance(java.security.KeyStore.getDefaultType());
                    keyStore.load(null, null);
                    // keyStore.setCertificateEntry(peer.host, x509Certificate)
                    keyStore.setCertificateEntry('CA', x509Certificate);

                    // let keyManagerFactory = javax.net.ssl.KeyManagerFactory.getInstance(
                    // 	javax.net.ssl.KeyManagerFactory.getDefaultAlgorithm()
                    // )
                    const keyManagerFactory = javax.net.ssl.KeyManagerFactory.getInstance('X509');
                    keyManagerFactory.init(keyStore, null);
                    const keyManagers = keyManagerFactory.getKeyManagers();

                    const trustManagerFactory = javax.net.ssl.TrustManagerFactory.getInstance(javax.net.ssl.TrustManagerFactory.getDefaultAlgorithm());
                    trustManagerFactory.init(keyStore);

                    const sslContext = javax.net.ssl.SSLContext.getInstance('TLS');
                    const trustManagers = trustManagerFactory.getTrustManagers();
                    if (trustManagers.length !== 1 || !(trustManagers[0] instanceof javax.net.ssl.X509TrustManager)) {
                        throw new Error('Unexpected default trust managers:' + trustManagers);
                    }
                    sslContext.init(keyManagers, trustManagers, null);
                    builder.sslSocketFactory(sslContext.getSocketFactory(), trustManagers[0]);
                } catch (error) {
                    console.error('@nativescript-community/https > client.allowInvalidCertificates error', error);
                }
            }

            if (peer.validatesDomainName === true) {
                try {
                    builder.hostnameVerifier(
                        new javax.net.ssl.HostnameVerifier({
                            verify: (hostname: string, session: javax.net.ssl.SSLSession): boolean => {
                                const pp = session.getPeerPrincipal().getName();
                                const hv = javax.net.ssl.HttpsURLConnection.getDefaultHostnameVerifier();
                                if (peer.commonName && peer.commonName[0] === '*') {
                                    return hv.verify(peer.host, session) && hostname.indexOf(peer.host) > -1 && hostname.indexOf(session.getPeerHost()) > -1 && pp.indexOf(peer.commonName) !== -1;
                                } else {
                                    return hv.verify(peer.host, session) && peer.host === hostname && peer.host === session.getPeerHost() && pp.indexOf(peer.host) !== -1;
                                }
                            }
                        })
                    );
                } catch (error) {
                    console.error('@nativescript-community/https > client.validatesDomainName error', error);
                }
            }
        } else {
            console.warn('@nativescript-community/https > Undefined host or certificate. SSL pinning NOT working!!!');
        }
    }

    _timeout = timeout;
    builder.connectTimeout(timeout, java.util.concurrent.TimeUnit.SECONDS).writeTimeout(timeout, java.util.concurrent.TimeUnit.SECONDS).readTimeout(timeout, java.util.concurrent.TimeUnit.SECONDS);

    if (cache) {
        builder.cache(cache);
        if (forceCache) {
            builder.addInterceptor(com.nativescript.https.CacheInterceptor.INTERCEPTOR);
        }
    }

    Client = builder.build();
    return Client;
}

export function cancelRequest(tag: string, client: okhttp3.OkHttpClient = runningClients[tag]) {
    if (notClosedResponses[tag]) {
        notClosedResponses[tag].cancel();
        return;
    }
    if (!client) {
        return;
    }
    const dispatcher = client.dispatcher();
    //When you want to cancel:
    //A) go through the queued calls and cancel if the tag matches:
    if (dispatcher.queuedCallsCount() > 0) {
        const queuedCalls = dispatcher.queuedCalls();
        for (let index = 0; index < queuedCalls.size(); index++) {
            const call = queuedCalls.get(index);
            if (call.request().tag() === tag) {
                call.cancel();
                return;
            }
        }
    }

    //B) go through the running calls and cancel if the tag matches:
    if (dispatcher.runningCallsCount() > 0) {
        const runningCalls = dispatcher.runningCalls();
        for (let index = 0; index < runningCalls.size(); index++) {
            const call = runningCalls.get(index);
            if (call.request().tag() === tag) {
                call.cancel();
                return;
            }
        }
    }
}

export function cancelAllRequests() {
    Object.values(notClosedResponses).forEach((req) => req.cancel());

    Object.values(runningClients).forEach((client) => {
        const dispatcher = client.dispatcher();
        //When you want to cancel:
        //A) go through the queued calls and cancel if the tag matches:
        if (dispatcher.queuedCallsCount() > 0) {
            const queuedCalls = dispatcher.queuedCalls();
            for (let index = 0; index < queuedCalls.size(); index++) {
                const call = queuedCalls.get(index);
                call.cancel();
            }
        }

        //B) go through the running calls and cancel if the tag matches:
        if (dispatcher.runningCallsCount() > 0) {
            const runningCalls = dispatcher.runningCalls();
            for (let index = 0; index < runningCalls.size(); index++) {
                const call = runningCalls.get(index);
                call.cancel();
            }
        }
    });
}

export function clearCookies() {
    if (cookieJar) {
        cookieJar = null;
        cookieManager = null;
    }
}

let CALL_ID = 0;
const notClosedResponses: {
    [k: string]: com.nativescript.https.OkHttpResponse;
} = {};

const runningClients: { [k: string]: okhttp3.OkHttpClient } = {};

let OkHttpResponse: typeof com.nativescript.https.OkHttpResponse;
export function createRequest(opts: HttpsRequestOptions, useLegacy: boolean = true): HttpsRequest {
    const client = getClient(opts, false);

    const request = new okhttp3.Request.Builder();
    request.url(opts.url);

    if (opts.headers) {
        Object.keys(opts.headers).forEach((key) => request.addHeader(key, opts.headers[key] as any));
    }

    if (opts.cachePolicy) {
        let cacheControlBuilder = new okhttp3.CacheControl.Builder();
        switch (opts.cachePolicy) {
            case 'noCache':
                cacheControlBuilder = cacheControlBuilder.noStore();
                break;
            case 'onlyCache':
                cacheControlBuilder = cacheControlBuilder.onlyIfCached();
                break;
            case 'ignoreCache':
                cacheControlBuilder = cacheControlBuilder.noCache();
                break;
        }
        request.cacheControl(cacheControlBuilder.build());
    }

    const methods = {
        GET: 'get',
        HEAD: 'head',
        DELETE: 'delete',
        POST: 'post',
        PUT: 'put',
        PATCH: 'patch'
    };
    let type;
    if (['GET', 'HEAD'].indexOf(opts.method) !== -1 || (opts.method === 'DELETE' && !Utils.isDefined(opts.body) && !Utils.isDefined(opts.content))) {
        request[methods[opts.method]]();
    } else {
        type = opts.headers && opts.headers['Content-Type'] ? opts.headers['Content-Type'] : 'application/json';
        const MEDIA_TYPE = okhttp3.MediaType.parse(type);
        let okHttpBody: okhttp3.RequestBody;
        if (type.startsWith('multipart/form-data')) {
            const builder = new okhttp3.MultipartBody.Builder();
            builder.setType(MEDIA_TYPE);

            (opts.body as HttpsFormDataParam[]).forEach((param) => {
                if (param.fileName && param.contentType) {
                    if (param.data instanceof okhttp3.RequestBody) {
                        builder.addFormDataPart(param.parameterName, param.fileName, param.data);
                    } else {
                        builder.addFormDataPart(param.parameterName, param.fileName, okhttp3.RequestBody.create(param.data, okhttp3.MediaType.parse(param.contentType)));
                    }
                } else {
                    if (typeof param.data === 'string') {
                        builder.addFormDataPart(param.parameterName, param.data);
                    } else {
                        builder.addFormDataPart(param.parameterName, param.data + '');
                    }
                }
            });
            okHttpBody = builder.build();
        } else if (type === 'application/x-www-form-urlencoded') {
            const builder = new okhttp3.FormBody.Builder();
            Object.keys(opts.body).forEach((key) => {
                builder.add(key, opts.body[key]);
            });
            okHttpBody = builder.build();
        } else {
            let body;
            if (opts.body) {
                try {
                    body = JSON.stringify(opts.body);
                } catch (ignore) {}
            } else if (opts.content) {
                body = opts.content;
            }
            if (body instanceof okhttp3.RequestBody) {
                okHttpBody = body;
            } else {
                okHttpBody = okhttp3.RequestBody.create(body, okhttp3.MediaType.parse(type));
            }
        }

        if (opts.onProgress) {
            okHttpBody = new com.nativescript.https.ProgressRequestWrapper(
                okHttpBody,
                new com.nativescript.https.ProgressRequestWrapper.ProgressListener({
                    onRequestProgress(bytesWritten: number, contentLength: number) {
                        opts.onProgress(bytesWritten, contentLength);
                    }
                })
            );
        }
        request[methods[opts.method]](okHttpBody);
    }
    const tag = opts.tag || `okhttp_request_${CALL_ID++}`;
    const call = client.newCall(request.tag(tag).build());
    runningClients[tag] = client;
    // We have to allow networking on the main thread because larger responses will crash the app with an NetworkOnMainThreadException.
    // Note that it would probably be better to offload it to a Worker or (natively running) AsyncTask.
    // Also note that once set, this policy remains active until the app is killed.
    if (useLegacy === false && opts.allowLargeResponse) {
        android.os.StrictMode.setThreadPolicy(android.os.StrictMode.ThreadPolicy.LAX);
    }
    return {
        nativeRequest: call,
        cancel: () => cancelRequest(tag, client),
        run(resolve, reject) {
            call.enqueue(
                new okhttp3.Callback({
                    onResponse(call, response) {
                        delete runningClients[tag];
                        if (!OkHttpResponse) {
                            OkHttpResponse = com.nativescript.https.OkHttpResponse;
                        }
                        try {
                            const responseBody = OkHttpResponse.getBody(response);
                            const message = OkHttpResponse.getMessage(response);
                            const statusCode = OkHttpResponse.getStatusCode(response);
                            const getHeaders = function () {
                                const heads = OkHttpResponse.getHeaders(response);
                                return JSON.parse(heads);
                            };
                            if (useLegacy) {
                                const nResponse = new OkHttpResponse(responseBody);
                                if (opts.onProgress) {
                                    nResponse.progressCallback = new OkHttpResponse.OkHttpResponseProgressCallback({
                                        onProgress: opts.onProgress
                                    });
                                }

                                resolve({
                                    response,
                                    content: new HttpsResponseLegacy(nResponse, tag, opts.url),
                                    contentLength: nResponse.contentLength(),
                                    statusCode,
                                    reason: message,
                                    get headers() {
                                        return getHeaders();
                                    }
                                });
                            } else {
                                resolve({
                                    response,
                                    content: responseBody.string(),
                                    contentLength: responseBody.contentLength(),
                                    reason: message,
                                    statusCode,
                                    get headers() {
                                        return getHeaders();
                                    }
                                });
                            }
                        } catch (error) {
                            console.error(error);
                            delete runningClients[tag];
                            reject(error);
                        }
                    },
                    onFailure(task, error) {
                        console.error(error);
                        delete runningClients[tag];
                        reject(error);
                    }
                })
            );
        }
    };
}

export function request(opts: HttpsRequestOptions, useLegacy: boolean = true) {
    return new Promise((resolve, reject) => {
        try {
            createRequest(opts, useLegacy).run(resolve, reject);
        } catch (error) {
            reject(error);
        }
    });
}