summaryrefslogtreecommitdiffstats
path: root/app/src/main/java/com/example/alcagotchi/AlcoGotchi.kt
blob: 349eac9bdb460241650ff12d3fbe4aae09b1169f (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
package com.example.alcagotchi

import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import okhttp3.Call
import okhttp3.Callback
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.RequestBody.Companion.toRequestBody
import okhttp3.Response
import org.json.JSONObject
import java.io.IOException

class AlcoGotchi private constructor() {

    private val client = OkHttpClient()
    private val jsonMediaType = "application/json; charset=utf-8".toMediaType()

    var baseUrl = "http://192.168.4.1:80"
    var coins = 100
    var drunk = 0

    companion object {
        @Volatile private var instance: AlcoGotchi? = null

        fun getInstance() =
            instance ?: synchronized(this) {
                instance ?: AlcoGotchi().also { instance = it }
            }
    }

    private fun buildUrl(path: String): String {
        return "$baseUrl/$path"
    }

    val basicCallback = object : Callback {
        override fun onFailure(call: Call, e: IOException) {
            e.printStackTrace()
        }

        override fun onResponse(call: Call, response: Response) {
            response.use {
                handleStateResponse(response)
            }
        }
    }

    fun handleStateResponse(response: Response) {
        if (!response.isSuccessful) throw IOException("Unexpected code $response")

        val json = JSONObject(response.body!!.string())

        coins = json.getJSONObject("data").getInt("alco_coin")
        drunk = json.getJSONObject("data").getInt("drunk")
    }

    suspend fun getState() {
        val request = Request.Builder()
            .url(buildUrl(""))
            .build()

        return withContext(Dispatchers.IO) {
            handleStateResponse(client.newCall(request).execute())
        }
    }

    suspend fun postGamble(amount: Int) {
        val body = JSONObject()
        body.put("bet", amount)

        val request = Request.Builder()
            .url(buildUrl("gamble"))
            .post(body.toString().toRequestBody(jsonMediaType))
            .build()

        client.newCall(request).enqueue(basicCallback)
        return withContext(Dispatchers.IO) {
            handleStateResponse(client.newCall(request).execute())
        }
    }
    suspend fun postDrink(drink: String) {
        val body = JSONObject()
        body.put("drink", drink)

        val request = Request.Builder()
            .url(buildUrl("drink"))
            .post(body.toString().toRequestBody(jsonMediaType))
            .build()

        return withContext(Dispatchers.IO) {
            handleStateResponse(client.newCall(request).execute())
        }
    }
    suspend fun postBuy(choice: String) {
        val body = JSONObject()
        body.put("item", choice)

        val request = Request.Builder()
            .url(buildUrl("buy"))
            .post(body.toString().toRequestBody(jsonMediaType))
            .build()

        client.newCall(request).enqueue(basicCallback)
        return withContext(Dispatchers.IO) {
            handleStateResponse(client.newCall(request).execute())
        }
    }
}