class ClientJsonModel(var client: ClientModel, var error: String)

class ClientModel (
    var userId: Int = 0,
    var name: String = "",
    var bankAccount: String = "",
    var agency: String = "",
    var balance: Double = 0.0
)

fun reqGET(reqUrl: String): String? {
    var response: String? = null
    lateinit var conn: HttpURLConnection

    try {
        val url = URL(reqUrl)
        conn = url.openConnection() as HttpURLConnection
        conn.requestMethod = "GET"

        //  lê o response
        val ins = BufferedInputStream(conn.inputStream)
        response = streamToString(ins)

        conn.connect()
        conn.inputStream.close()
    } catch (e: MalformedURLException) {
        Log.e("LOG", "MalformedURLException: " + e.message)
    } catch (e: ProtocolException) {
        Log.e("LOG", "ProtocolException: " + e.message)
    } catch (e: IOException) {
        Log.e("LOG", "IOException: " + e.message)
    } catch (e: Exception) {
        Log.e("LOG", "Exception: " + e.message)
    } finally {
        conn.disconnect()
    }

    return response
}

fun reqPOST(reqUrl: String, params: Map<String, String>): String? {
    var response: String? = ""
    lateinit var conn: HttpURLConnection

    try {
        val url = URL(reqUrl)
        conn = url.openConnection() as HttpURLConnection
        conn.requestMethod = "POST"

        conn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded")
        conn.doOutput = true
        conn.doInput = true
        conn.connectTimeout = 30 * 1000

        var parsedParams = ""
        var isFirst = true

        params.keys.forEach { it ->
            if (!isFirst) {
                parsedParams += "&"
                isFirst = false
            }

            parsedParams += URLEncoder.encode(it + "=" + params[it], "UTF-8")
        }

        conn.connect()

        val bw = BufferedWriter(OutputStreamWriter(conn.outputStream, "UTF-8"))
        bw.write(parsedParams)
        bw.flush()
        conn.outputStream.close()
        bw.close()

        response = streamToString(BufferedInputStream(conn.inputStream))
    } catch (e: MalformedURLException) {
        Log.e("LOG", "MalformedURLException: " + e.message)
    } catch (e: ProtocolException) {
        Log.e("LOG", "ProtocolException: " + e.message)
    } catch (e: IOException) {
        Log.e("LOG", "IOException: " + e.message)
    } catch (e: Exception) {
        Log.e("LOG", "Exception: " + e.message)
    } finally {
        conn.disconnect()
    }

    return response
}

class LoginPresenter : LoginContract.Presenter<ClientJsonModel> {
    override fun showDataFromServer(data: (ClientJsonModel) -> Unit) {

    }

    fun makeLogin(user: String, password: String) {
        MakeLogin(user, password).execute()
    }

    class MakeLogin(var userP: String, var passwordP: String) : AsyncTask<Void, Void, String>() {
        lateinit var callback: (ClientJsonModel) -> Unit
        var dataBody : MutableMap<String, String> = mutableMapOf()

        override fun doInBackground(vararg params: Void?): String {
            dataBody["user"] = userP
            dataBody["password"] = passwordP

            val jsonString = Helper.reqPOST("https://ban-tst-xxhh.herokuapp.com/api/login", dataBody)

            try {
                val jo = JSONObject(jsonString)

                val bill = jo.getJSONObject("userAccount")
                val id = bill.getInt("userId")
                val name = bill.getString("name")
                val bank = bill.getString("bankAccount")
                val agency = bill.getString("agency")
                val balance = bill.getDouble("balance")

                val error = jo.getJSONObject("error")

                callback.invoke(
                    ClientJsonModel(
                        ClientModel(
                            id,
                            name.toString(),
                            bank.toString(),
                            agency.toString(),
                            balance
                        ), error.getString("")
                    )
                )

            } catch (e: Exception) {
                e.printStackTrace()
                Log.e("LOG", "LoginPresenter -> doInBackground: Error -> ${e.message} | Causa: ${e.cause.toString()}")
            }
            return ""
        }

    }
}

class LoginActivity : CoreActivity(), LoginContract.View {
    var presenter : LoginPresenter? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_login)

        setUp()
    }

    fun onLogin(v: View) {
        presenter?.makeLogin(edt_login_user.text.toString(), edt_login_password.text.toString())
        startActivity(Intent(this, AccountActivity::class.java))
    }

    override fun setUp() {
        presenter = LoginPresenter()
    }
}