OkHttpUtil

package jp.co.gunmabank.util

import android.os.Handler
import android.os.Looper
import com.google.gson.Gson
import com.google.gson.JsonParseException
import com.google.gson.internal.`$Gson$Types`
import com.squareup.okhttp.*
import io.fabric.sdk.android.services.common.AbstractSpiCall.DEFAULT_TIMEOUT
import jp.co.gunmabank.minefocus.BuildConfig
import java.io.IOException
import java.lang.reflect.ParameterizedType
import java.lang.reflect.Type
import java.net.CookieManager
import java.net.CookiePolicy
import java.net.Proxy
import jp.co.gunmabank.util.TrustAllCerts
import java.security.SecureRandom
import java.util.concurrent.TimeUnit
import javax.net.ssl.*
import javax.xml.datatype.DatatypeConstants.SECONDS
import io.fabric.sdk.android.services.settings.IconRequest.build
import com.squareup.okhttp.RequestBody
import jp.co.gunmabank.common.Common
import io.fabric.sdk.android.services.settings.IconRequest.build
import io.fabric.sdk.android.services.settings.IconRequest.build

/**
 * 非同時OkHttpのフォームに基づいてを提出

 * Created by wangsai on 2017/05/12.
 */

object OkHttpUtil {

    private var mOkHttpClient: OkHttpClient
    private val mDelivery: Handler
    private val mGson: Gson
    private var mInstance: OkHttpUtil? = null

    init {
        mOkHttpClient = OkHttpClient()
        //cookie enabled
        mOkHttpClient.cookieHandler = CookieManager(null, java.net.CookiePolicy.ACCEPT_ORIGINAL_SERVER)

        mDelivery = Handler(Looper.getMainLooper())
        mGson = Gson()
        if (mInstance == null) {
            synchronized(OkHttpUtil::class.java) {
                if (mInstance == null) {
                    mInstance = OkHttpUtil
                }
            }
        }
    }

    /**
     * 非同時OkHttpのフォームに基づいてを提出

     * @param url
     * *
     * @param callback
     * *
     * @param sendData
     * *
     * @throws IOException
     */
    @Throws(IOException::class)
    private fun postFormDataAsyn(url: String, callback: ResultCallback<*>, sendData: String, sendLinkData: String, name: String, linkname: String) {
        val request = buildMultipartFormRequest(url, sendData, sendLinkData, name, linkname)
        deliveryResult(callback, request)
    }

    @Throws(IOException::class)
    private fun postJsonDataAsyn(url: String, callback: ResultCallback<*>, sendData: String) {
        val request = buildPostJosnRequest(url, sendData)
        deliveryResult(callback, request)
    }

    /**
     * データを整理

     * @param url
     * *
     * @param sendData
     * *
     * @return
     */
    private fun buildMultipartFormRequest(url: String, sendData: String, sendLinkData: String, name: String, linkname: String): Request {
        var boundary = "--AlamofireBoundary" + Common.randomFor4Num(8)
        val builder = MultipartBuilder(boundary).type(MultipartBuilder.FORM)
        builder.addPart(Headers.of("Content-Disposition", "form-data; name=\"" + name + "\""), RequestBody.create(MediaType.parse("application/json; charset=utf-8"), sendData))
        builder.addPart(Headers.of("Content-Disposition", "form-data; name=\"" + linkname + "\""), RequestBody.create(MediaType.parse("application/json; charset=utf-8"), sendLinkData))
        val requestBody = builder.build()
        return Request.Builder().url(url).post(requestBody).build()
    }

    private fun buildPostJosnRequest(url: String, sendData: String): Request {

        val request = Request.Builder().url(url).post(RequestBody.create(
                MediaType.parse("application/json; charset=utf-8"),
                sendData)).build()
        return request
    }

    /**
     * 結果を処理

     * @param callback
     * *
     * @param request
     */
    private fun deliveryResult(callback: ResultCallback<*>, request: Request) {
        var dnpSendmsg = ""
        mOkHttpClient.newCall(request).enqueue(object : Callback {
            override fun onFailure(request: Request, e: IOException) {
                dnpSendmsg = request.tag().toString()
                sendFailedStringCallback(dnpSendmsg, request, e, callback)
            }

            override fun onResponse(response: Response) {
                try {
                    val str = response.body().string()
                    if (callback.mType === String::class.java) {
                        sendSuccessResultCallback(str, callback)
                    } else {
                        //TODO mGson
                    }
                } catch (e: IOException) {
                    sendFailedStringCallback(dnpSendmsg, response.request(), e, callback)
                } catch (e: JsonParseException) {
                    sendFailedStringCallback(dnpSendmsg, response.request(), e, callback)
                }

            }
        })
    }

    private fun sendFailedStringCallback(dnpSendmsg: String, request: Request, e: Exception, callback: ResultCallback<*>) {
        mDelivery.post {
            callback?.onError(dnpSendmsg, request, e)
        }
    }

    private fun sendSuccessResultCallback(any: String, callback: ResultCallback<*>) {
        mDelivery.post {
            callback?.onResponse(any)
        }
    }

    abstract class ResultCallback<T> {
        internal var mType: Type

        init {
            mType = getSuperclassTypeParameter(javaClass)
        }

        abstract fun onError(dnpSendmsg: String, request: Request, e: Exception)

        abstract fun onResponse(str: String)

        companion object {

            internal fun getSuperclassTypeParameter(subclass: Class<*>): Type {
                val superclass = subclass.genericSuperclass
                if (superclass is Class<*>) {
                    throw RuntimeException("Missing type parameter.")
                }
                val parameterized = superclass as ParameterizedType
                return `$Gson$Types`.canonicalize(parameterized.actualTypeArguments[0])
            }
        }
    }

    /**
     * 非同時OkHttpのフォームに基づいてを提出

     * @param url
     * *
     * @param callback
     * *
     * @param sendData
     * *
     * @throws IOException
     */
    fun postFormAsyn(url: String, callback: ResultCallback<*>, sendData: String, sendLinkData: String, name: String, linkname: String) {
        mOkHttpClient = OkHttpClient()

        mOkHttpClient.setConnectTimeout(100, TimeUnit.SECONDS)
        mOkHttpClient.setReadTimeout(100, TimeUnit.SECONDS)
        //cookie enabled
        mOkHttpClient.cookieHandler = CookieManager(null, java.net.CookiePolicy.ACCEPT_ORIGINAL_SERVER)
        mInstance!!.postFormDataAsyn(url, callback, sendData, sendLinkData, name, linkname)
    }

    /**
     * 非同時OkHttpのフォームに基づいてを提出

     * @param url
     * *
     * @param callback
     * *
     * @param sendData
     * *
     * @throws IOException
     */
    fun postFormAsynForAUth(url: String, callback: ResultCallback<*>, sendData: String, sendLinkData: String, name: String, linkname: String, usename: String, usepassword: String) {
        mOkHttpClient = OkHttpClient()
        if (BuildConfig.FLAVOR == "stg" || BuildConfig.FLAVOR == "jp") {
            mOkHttpClient.authenticator = object : Authenticator {
                override fun authenticate(proxy: Proxy?, response: Response?): Request {
                    val credential = Credentials.basic(usename, usepassword)
                    return response!!.request().newBuilder()
                            .header("Authorization", credential)
                            .build()
                }

                override fun authenticateProxy(proxy: Proxy?, response: Response?): Request? {
                    return null
                }
            }
            mOkHttpClient.sslSocketFactory = createSSLSocketFactory()
            mOkHttpClient.hostnameVerifier = HostnameVerifier { hostname, session -> true }
        }
        mOkHttpClient.setConnectTimeout(100, TimeUnit.SECONDS)
        mOkHttpClient.setReadTimeout(100, TimeUnit.SECONDS)
        mOkHttpClient.setWriteTimeout(100, TimeUnit.SECONDS)
        //cookie enabled
        mOkHttpClient.cookieHandler = CookieManager(null, java.net.CookiePolicy.ACCEPT_ORIGINAL_SERVER)
        mInstance!!.postFormDataAsyn(url, callback, sendData, sendLinkData, name, linkname)
    }

    fun postJsonAsynForAUth(url: String, callback: ResultCallback<*>, sendData: String, usename: String, usepassword: String) {
        mOkHttpClient = OkHttpClient()
        if (BuildConfig.FLAVOR == "stg" || BuildConfig.FLAVOR == "jp") {
            mOkHttpClient.authenticator = object : Authenticator {
                override fun authenticate(proxy: Proxy?, response: Response?): Request {
                    val credential = Credentials.basic(usename, usepassword)
                    return response!!.request().newBuilder()
                            .header("Authorization", credential)
                            .build()
                }

                override fun authenticateProxy(proxy: Proxy?, response: Response?): Request? {
                    return null
                }
            }

            mOkHttpClient.sslSocketFactory = createSSLSocketFactory()
            mOkHttpClient.hostnameVerifier = HostnameVerifier { hostname, session -> true }
        }
        mOkHttpClient.setConnectTimeout(600, TimeUnit.SECONDS)
        mOkHttpClient.setReadTimeout(600, TimeUnit.SECONDS)
        mOkHttpClient.setWriteTimeout(600, TimeUnit.SECONDS)
        //cookie enabled
        mOkHttpClient.cookieHandler = CookieManager(null, java.net.CookiePolicy.ACCEPT_ORIGINAL_SERVER)
        mInstance!!.postJsonDataAsyn(url, callback, sendData)
    }

    private fun createSSLSocketFactory(): SSLSocketFactory? {
        var ssfFactory: SSLSocketFactory? = null

        try {
            val sc = SSLContext.getInstance("TLS")
            sc.init(null, arrayOf<TrustManager>(TrustAllCerts()), SecureRandom())

            ssfFactory = sc.socketFactory
        } catch (e: Exception) {
        }

        return ssfFactory
    }
}