// Copyright © 2022 Olo Inc. All rights reserved.
// This software is made available under the Olo Pay SDK License (See LICENSE.md file)
package com.olopaysdkreactnative.extensions

import com.facebook.react.bridge.Promise
import com.olopaysdkreactnative.data.EmptyValueException
import com.olopaysdkreactnative.data.ErrorCodes
import com.olopaysdkreactnative.data.MissingKeyException
import com.olopaysdkreactnative.data.NullValueException
import com.olopaysdkreactnative.data.UnexpectedTypeException

inline fun <reified T> HashMap<String, Any?>.getArgOrReject(
    key: String,
    baseError: String,
    promise: Promise
): T {
    return getArgOrReject(key, baseError, promise, T::class.java)
}

fun <T> HashMap<String, Any?>.getArgOrReject(
    key: String,
    baseError: String,
    promise: Promise,
    tClass: Class<T>
): T {
    try {
        return getArgOrThrow(key, tClass)
    } catch (e: MissingKeyException) {
        val errorMessage = "$baseError: Missing parameter '$key'"
        promise.reject(ErrorCodes.MissingParameter, errorMessage)
        throw MissingKeyException(errorMessage, e)
    } catch (e: NullValueException) {
        val errorMessage = "$baseError: Missing parameter '$key'"
        promise.reject(ErrorCodes.MissingParameter, errorMessage)
        throw NullValueException(errorMessage, e)
    } catch (e: UnexpectedTypeException) {
        val errorMessage = "$baseError: Value for '$key' is not of type ${tClass.simpleName}"
        promise.reject(ErrorCodes.InvalidParameter, errorMessage)
        throw UnexpectedTypeException(errorMessage, e)
    }
}

inline fun <reified T> HashMap<String, Any?>.getArgOrReject(
    key: String,
    default: T,
    baseError: String,
    promise: Promise
): T {
    return getArgOrReject(key, default, baseError, promise, T::class.java)
}

fun <T> HashMap<String, Any?>.getArgOrReject(
    key: String,
    default: T,
    baseError: String,
    promise: Promise,
    tClass: Class<T>
): T {
    try {
        return getArgOrThrow(key, default, tClass)
    } catch (e: UnexpectedTypeException) {
        val errorMessage = "$baseError: Value for '$key' is not of type ${tClass.simpleName}"
        promise.reject(ErrorCodes.InvalidParameter, errorMessage)
        throw UnexpectedTypeException(errorMessage, e)
    }
}

fun HashMap<String, Any?>.getStringArgOrReject(
    key: String,
    default: String,
    baseError: String,
    acceptEmptyValue: Boolean,
    promise: Promise
): String {
    try {
        var value = getArgOrThrow(key, default, String::class.java).trim()

        if (!acceptEmptyValue && value.isEmpty()) {
            value = default
        }

        return value
    } catch (e: UnexpectedTypeException) {
        val errorMessage = "$baseError: Value for '$key' is not of type ${String::class.java.simpleName}"
        promise.reject(ErrorCodes.InvalidParameter, errorMessage)
        throw UnexpectedTypeException(errorMessage, e)
    }
}

fun HashMap<String, Any?>.getStringArgOrReject(
    key: String,
    baseError: String,
    acceptEmptyValue: Boolean,
    promise: Promise
): String {
    val value = getArgOrReject(key, baseError, promise, String::class.java).trim()

    if (!acceptEmptyValue && value.isEmpty()) {
        val errorMessage = "$baseError: Value for '$key' cannot be empty"
        promise.reject(ErrorCodes.InvalidParameter, errorMessage)
        throw EmptyValueException(errorMessage)
    }

    return value
}

inline fun <reified T> HashMap<String, Any?>.getArgOrThrow(key: String): T {
    return getArgOrThrow(key, T::class.java)
}

fun <T> HashMap<String, Any?>.getArgOrThrow(
    key: String,
    tClass: Class<T>
): T {
    if (!this.containsKey(key)) {
        throw MissingKeyException("Missing key '$key'")
    }

    this[key]?.let {
        if (it::class.java != tClass) {
            throw UnexpectedTypeException("Value for '$key' is not of type ${tClass.simpleName}")
        }

        return tClass.cast(it) as T
    }

    throw NullValueException("Value for '$key' is null")
}

inline fun<reified T> HashMap<String, Any?>.getArgOrThrow(key: String, defaultValue: T): T {
    return getArgOrThrow(key, defaultValue, T::class.java)
}

fun <T> HashMap<String, Any?>.getArgOrThrow(
    key: String,
    defaultValue: T,
    tClass: Class<T>
): T {
    return try {
        getArgOrThrow(key, tClass)
    } catch (e: MissingKeyException) {
        defaultValue
    } catch (e: NullValueException) {
        defaultValue
    }
}