upload Activity

package codify.generator.activities.crea_qr

import android.content.ContentResolver
import android.content.Context
import android.content.Intent
import android.net.Uri
import android.os.Bundle
import android.provider.OpenableColumns
import android.util.Base64
import android.util.Log
import android.view.View
import android.widget.*
import androidx.appcompat.app.AppCompatActivity
import androidx.core.content.ContextCompat
import androidx.lifecycle.lifecycleScope
import codify.generator.R
import codify.generator.activities.DashboardActivity
import codify.generator.api.CollectionAPI
import codify.generator.api.FileUploadAPI
import com.google.android.material.snackbar.Snackbar
import kotlinx.android.synthetic.main.crea_qr.*
import kotlinx.android.synthetic.main.test.*
import kotlinx.coroutines.CompletableDeferred
import kotlinx.coroutines.launch
import models.requests.GetCollectionRequestModel
import models.requests.UploadFileRequestModel
import models.responses.UploadFileResponseModel
import okhttp3.OkHttpClient
import okhttp3.logging.HttpLoggingInterceptor
import retrofit2.Call
import retrofit2.Callback
import retrofit2.Response
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
import java.io.File
import java.io.FileInputStream
import java.io.Serializable


class CreaQrActivity: AppCompatActivity() {

    private var selectedImageUri: Uri? = null

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

        initButtons()


    }

    private fun initButtons() {
        val buttonQrFree = findViewById<Button>(R.id.buttonQrFree)
        val buttonQrMonthly = findViewById<Button>(R.id.buttonQrMonthly)
        val buttonQrTemp = findViewById<Button>(R.id.buttonQrTemp)
        val frame = findViewById<View>(R.id.frame_layout_tab_content) as FrameLayout


        //frameLayout.removeAllViews()
        //frameLayout.addView(newLayout)


        buttonQrFree.setOnClickListener {
            this.changeButtonState(1)
            this.setFrameOnQrLink(frame)
        }

        buttonQrMonthly.setOnClickListener {


            lifecycleScope.launch {
                try {
                    val response =  getCollections().await()
                    this@CreaQrActivity.changeButtonState(2)
                    this@CreaQrActivity.setFrameOnQrMensile(frame)
                    val spinner: Spinner = findViewById(R.id.qr_collection)
                    val adapter = ArrayAdapter(this@CreaQrActivity, android.R.layout.simple_spinner_item, response)
                    adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item)
                    spinner.adapter = adapter

                    //Toast.makeText(this@CreaQrActivity, response.toString(), Toast.LENGTH_LONG).show()
                } catch (e: Exception) {
                    Log.d("exception", e.toString())
                }
            }



        }

        buttonQrTemp.setOnClickListener {
           this.setFrameOnQrTemp(frame)
           this.changeButtonState(3)

        }

    }

    private fun setFrameOnQrLink(frame: FrameLayout)
    {
        frame.removeAllViews()
    }

    private fun setFrameOnQrMensile(frame: FrameLayout)
    {

        val newLayout = layoutInflater.inflate(R.layout.test, null)
        frame.removeAllViews()
        frame.addView(newLayout)
        val buttonUpload = findViewById<Button>(R.id.button_upload)

        image_view.setOnClickListener {

            opeinImageChooser()
        }

        button_upload.setOnClickListener {
            lifecycleScope.launch {
                try {
                    val spinner = findViewById<Spinner>(R.id.qr_collection)
                    val selectedValue = spinner.selectedItem.toString()
                    val editText = findViewById<EditText>(R.id.qr_name_text)
                    val qr_name = editText.text.toString()
                    val response = uploadImage( 1,selectedValue,qr_name).await()
                    Log.d("QR_DEBUG",response.base64)
                    val intent = Intent(this@CreaQrActivity, DashboardActivity::class.java)
                    intent.putExtra("response_model", response as Serializable)
                    startActivity(intent)
                } catch (e: Exception) {
                    Log.d("exception", e.toString())
                }
            }
        }
    }

    private fun setFrameOnQrTemp(frame: FrameLayout)
    {
        frame.removeAllViews()
    }

    private fun changeButtonState(selectedButton: Int)
    {
        when (selectedButton) {
            1 ->
            {
                buttonQrFree.isSelected = true
                buttonQrMonthly.isSelected = false
                buttonQrTemp.isSelected = false

                buttonQrFree.setTextColor(ContextCompat.getColor(this, R.color.green))
                buttonQrMonthly.setTextColor(ContextCompat.getColor(this, R.color.black))
                buttonQrTemp.setTextColor(ContextCompat.getColor(this, R.color.black))
            }
            2 ->
            {
                buttonQrFree.isSelected = false
                buttonQrMonthly.isSelected = true
                buttonQrTemp.isSelected = false

                buttonQrFree.setTextColor(ContextCompat.getColor(this, R.color.black))
                buttonQrMonthly.setTextColor(ContextCompat.getColor(this, R.color.green))
                buttonQrTemp.setTextColor(ContextCompat.getColor(this, R.color.black))
            }
            3 ->
            {
                buttonQrFree.isSelected = false
                buttonQrMonthly.isSelected = false
                buttonQrTemp.isSelected = true

                buttonQrFree.setTextColor(ContextCompat.getColor(this, R.color.black))
                buttonQrMonthly.setTextColor(ContextCompat.getColor(this, R.color.black))
                buttonQrTemp.setTextColor(ContextCompat.getColor(this, R.color.green))
            }

        }
    }

private fun getCollections(): CompletableDeferred<List<String>> {

    val deferred = CompletableDeferred<List<String>>()

    val retrofit = Retrofit.Builder()
        .baseUrl("https://codify.ovh/")
        .addConverterFactory(GsonConverterFactory.create())
        .client(
            OkHttpClient.Builder()
                .addInterceptor(HttpLoggingInterceptor().apply {
                    level = HttpLoggingInterceptor.Level.BODY
                })
                .build()
        )
        .build()

    val retrofitAPI = retrofit.create(CollectionAPI::class.java)

    val uploadModel = GetCollectionRequestModel(this.getTokenFromStorage())

    retrofitAPI.getCollection(uploadModel)?.enqueue(object : Callback<List<String>>  {
        override fun onResponse(call: Call<List<String>>, response: Response<List<String>>) {
            if (response.isSuccessful) {
                val responseModel = response.body();
                if (responseModel != null) {

                    deferred.complete(responseModel)
                }
                else {
                    deferred.completeExceptionally(NullPointerException("Response body is null"))
                }
            }
            else {
                val errorBody = response.errorBody()?.string()
                deferred.completeExceptionally(Exception("Error response from server: $errorBody"))
            }
        }

        override fun onFailure(call: Call<List<String>>, t: Throwable) {
            t.message?.let { Log.d("error request", it) }
            deferred.completeExceptionally(t)
        }

    })
    return deferred
}


    private fun uploadImage(fileType:  Int,selectedCollection: String,qr_name: String): CompletableDeferred<UploadFileResponseModel>{

        val deferred = CompletableDeferred<UploadFileResponseModel>()

        if (selectedImageUri == null) {
            layout_root.snackbar("Select an Image First")
            deferred.completeExceptionally(java.lang.Exception("Select an Image First"))
            return deferred;
        }

        val parcelFileDescriptor = contentResolver.openFileDescriptor(
            selectedImageUri!!, "r", null
        ) ?: return deferred

        val inputStream = FileInputStream(parcelFileDescriptor.fileDescriptor)
        val file = File(cacheDir,contentResolver.getFileName(selectedImageUri!!))
        val base64File = this.convertToBase64(file)

        val retrofit = Retrofit.Builder()
            .baseUrl("https://codify.ovh/")
            // as we are sending data in json format so
            // we have to add Gson converter factory
            .addConverterFactory(GsonConverterFactory.create()) // at last we are building our retrofit builder.
            .client(
                OkHttpClient.Builder()
                    .addInterceptor(HttpLoggingInterceptor().apply {
                        level = HttpLoggingInterceptor.Level.BODY
                    })
                    .build()
            )
            .build()


        // below line is to create an instance for our retrofit api class.
        val retrofitAPI = retrofit.create(FileUploadAPI::class.java)

        // passing data from our text fields to our modal class.
        val uploadModel = UploadFileRequestModel(
            base64File,
            this.getTokenFromStorage(),
            fileType,
            selectedCollection,
            qr_name
        )

        // calling a method to create a post and passing our modal class.

        // on below line we are executing our method.

        retrofitAPI.uploadFile(uploadModel)?.enqueue(object : Callback<UploadFileResponseModel> {
            override fun onResponse(call: Call<UploadFileResponseModel>, response: Response<UploadFileResponseModel>) {
                if (response.isSuccessful) {
                    val responseModel = response.body()
                    if (responseModel != null) {
                        /*
                        val base64 = responseModel.base64
                        val modelWithBase64 = UploadFileResponseModel(responseModel.url, base64)
                        deferred.complete(modelWithBase64)
                         */
                    } else {
                        deferred.completeExceptionally(NullPointerException("Response body is null"))
                    }
                } else {
                    val errorBody = response.errorBody()?.string()
                    deferred.completeExceptionally(Exception("Error response from server: $errorBody"))
                }
            }

            override fun onFailure(call: Call<UploadFileResponseModel>, t: Throwable) {
                // setting text to our text view when
                // we get error response from API.
                t.message?.let { Log.d("error request", it) }
                deferred.completeExceptionally(t)
            }

        })
        return deferred



    }

    private fun convertToBase64(attachment: File): String {
        return Base64.encodeToString(attachment.readBytes(), Base64.NO_WRAP)
    }
    private fun opeinImageChooser() {

        Intent(Intent.ACTION_PICK).also {
            it.type = "image/*"
            val mimeTypes = arrayOf("image/jpeg", "image/png","image/jpg","image/gif","image/webp")
            it.putExtra(Intent.EXTRA_MIME_TYPES, mimeTypes)
            startActivityForResult(it, REQUEST_CODE_IMAGE)
        }
    }

    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)
        if (resultCode == RESULT_OK) {
            when (requestCode) {
                REQUEST_CODE_IMAGE -> {
                    selectedImageUri = data?.data
                    image_view.setImageURI(selectedImageUri)
                }
            }
        }
    }



    companion object {
        const val REQUEST_CODE_IMAGE = 101
    }

    fun onProgressUpdate(percentage: Int) {
        progress_bar.progress = percentage
    }

    private fun getTokenFromStorage(): String {
        val sharedPref = getSharedPreferences("CODIFY_PREFERENCES", Context.MODE_PRIVATE)
        //Toast.makeText(this, sharedPref.getString("G_AUTH_TOKEN", "null"), Toast.LENGTH_LONG).show()
        return sharedPref.getString("G_AUTH_TOKEN", "null") ?: "null"
    }

}

private fun ContentResolver.getFileName(selectedImageUri: Uri): String {
    var name = ""
    val returnCursor = this.query(selectedImageUri,null,null,null,null)
    if (returnCursor!=null){
        val nameIndex = returnCursor.getColumnIndex(OpenableColumns.DISPLAY_NAME)
        returnCursor.moveToFirst()
        name = returnCursor.getString(nameIndex)
        returnCursor.close()
    }

    return name
}

private fun View.snackbar(message: String) {
    Snackbar.make(this, message, Snackbar.LENGTH_LONG).also { snackbar ->
        snackbar.setAction("OK") {
            snackbar.dismiss()
        }
    }.show()


}