import com.google.gson.JsonDeserializationContext
import com.google.gson.JsonDeserializer
import com.google.gson.JsonElement
import com.google.gson.JsonPrimitive
import com.google.gson.JsonSerializationContext
import com.google.gson.JsonSerializer
import com.moneyforward.android.expenses.extensions.toCamelCase
import com.moneyforward.android.expenses.extensions.toSnakeCase
import java.lang.IllegalArgumentException
import java.lang.reflect.Type

class EnumSerializer<T : kotlin.Enum<T>>(
        private val unsupportedValue: T,
        private val jsonNamingConvention: NamingConvention = NamingConvention.LowerSnakeCase,
        private val enumNamingConvention: NamingConvention = NamingConvention.UpperCamelCase
) : JsonSerializer<T>, JsonDeserializer<T> {
    enum class NamingConvention {
        UpperSnakeCase,
        LowerSnakeCase,
        UpperCamelCase,
        LowerCamelCase
    }

    override fun deserialize(json: JsonElement?, typeOfT: Type?, context: JsonDeserializationContext?) =
            json?.asString?.let {
                try {
                    @Suppress("UNCHECKED_CAST")
                    java.lang.Enum.valueOf(typeOfT as Class<T>, it.convertNamingConvertion(jsonNamingConvention, enumNamingConvention))
                } catch (e: IllegalArgumentException) {
                    // Unsupported
                    unsupportedValue
                }
            } ?: unsupportedValue

    override fun serialize(src: T, typeOfSrc: Type?, context: JsonSerializationContext?) =
            JsonPrimitive(src.name.convertNamingConvertion(enumNamingConvention, jsonNamingConvention))

    private fun String.convertNamingConvertion(from: NamingConvention, to: NamingConvention): String {
        if (from == to || length <= 0) return this

        return when (from) {
            NamingConvention.UpperSnakeCase, NamingConvention.LowerSnakeCase ->
                when (to) {
                    NamingConvention.UpperSnakeCase -> toUpperCase()
                    NamingConvention.LowerSnakeCase -> toLowerCase()
                    NamingConvention.UpperCamelCase -> toCamelCase(false)
                    NamingConvention.LowerCamelCase -> toCamelCase(true)
                }
            NamingConvention.UpperCamelCase, NamingConvention.LowerCamelCase ->
                when (to) {
                    NamingConvention.UpperSnakeCase -> toSnakeCase(false)
                    NamingConvention.LowerSnakeCase -> toSnakeCase(true)
                    NamingConvention.UpperCamelCase -> get(0).toLowerCase() + substring(1)
                    NamingConvention.LowerCamelCase -> get(0).toUpperCase() + substring(1)
                }
        }
    }
}