package com.example.exvesta.Screans.Responses

import android.content.Context
import android.net.Uri
import android.util.Log
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.example.exvesta.domain.utils.Constants
import com.example.exvesta.model.Bows
import com.example.exvesta.model.Consists_bows
import com.example.exvesta.model.Consists_wardrob
import com.example.exvesta.model.Things_user
import io.github.jan.supabase.postgrest.from
import io.github.jan.supabase.storage.storage
import kotlinx.coroutines.launch

class  ResponseUser(private val context: Context): ViewModel() {
    fun deleteItem(userthing: Things_user, status: Boolean) {
        var response: List<Things_user>
        response = ArrayList()
        viewModelScope.launch {
            if (status == false) {
                try {
                    Constants.supabase.from("Things_user").delete {

                        filter {
                            Things_user::id eq userthing.id
                        }
                    }
//                refreshUserThings()
                } catch (e: Exception) {
                    println("Error")
                    println(e.message.toString())
                }
            } else if (status == true) {
                try {
                    Constants.supabase.from("Consists_wardrob").delete {

                        filter {
                            Consists_wardrob::id_thing eq userthing.id
                        }
                    }

                } catch (e: Exception) {
                    println("Error")
                    println(e.message.toString())
                }
            }
        }

    }

    fun deleteBow(bows: Bows) {
        var response: List<Bows>
        response = ArrayList()
        viewModelScope.launch {

            try {
                Constants.supabase.from("Bows").delete {

                    filter {
                        Bows::id eq bows.id
                    }
                }

            } catch (e: Exception) {
                println("Error")
                println(e.message.toString())
            }
        }

    }

    fun insertItem(
        season: Int,
        styles: Int,
        title: String,
        subtype: Int,
        imgUri: Uri?,
        idWardrob: Int
    ) {
        viewModelScope.launch {
            try {
                val imageUrl = imgUri?.let { uri ->
                    val inputStream = context.contentResolver.openInputStream(uri)
                    inputStream?.use { stream ->
                        val byteArray =
                            stream.readBytes() // Читаем содержимое файла в массив байтов
                        val bucket =
                            Constants.supabase.storage.from("exvesta") // Укажите имя вашего бакета

                        val fileName = uri.lastPathSegment
                            ?: "default_image_name.jpg" // Получаем имя файла из Uri
                        val uploadResponse =
                            bucket.upload(fileName, byteArray) // Используем имя файла
                        Log.d("UploadResponse", uploadResponse.toString())

                        // Формируем URL изображения
                        "https://vkxcxcimqqswxqxncmof.supabase.co/storage/v1/object/public/exvesta/$fileName"
                    }
                }
                // Создаем объект Things_user
                val thing = Things_user(
                    id = null,
                    style = styles,
                    title = title,
                    subtype = subtype,
                    img = imageUrl,
                    id_season = season,
                    no = false,
                    public_status = false
                )

                // Вставка элемента в базу данных
                val insertResponse = Constants.supabase.from("Things_user").insert(thing) {
                    select()
                }.decodeSingle<Things_user>().id
                Log.d("InsertResponse1", insertResponse.toString())
                try {
                    val newId = insertResponse
                    Log.d("newBowId", newId.toString())
                    if (newId != null) {
                        val conw = Consists_wardrob(
                            id = null,
                            id_thing = newId,
                            id_wardrob = idWardrob
                        )
                        val insertRespon = Constants.supabase.from("Consists_wardrob").insert(conw)
                        Log.d("InsertConsistResponse", insertRespon.toString())
                    }

                } catch (e: Exception) {
                    println("Error during insertion: ${e.message}")
                }


            } catch (e: Exception) {
                println("Error during insertion: ${e.message}")
            }
        }
    }


    fun addBow(
        title: String,
        selectedThings: List<Things_user?>,
        imageUri: Uri?,
        userId: Int,
        pub: Boolean
    ) {
        viewModelScope.launch {
            try {
                // Проверяем, есть ли изображение для загрузки
                val imageUrl = imageUri?.let { uri ->
                    val inputStream = context.contentResolver.openInputStream(uri)
                    inputStream?.use { stream ->
                        val byteArray =
                            stream.readBytes() // Читаем содержимое файла в массив байтов
                        val bucket =
                            Constants.supabase.storage.from("exvesta") // Укажите имя вашего бакета

                        val fileName = uri.lastPathSegment
                            ?: "default_image_name.jpg" // Получаем имя файла из Uri
                        val uploadResponse =
                            bucket.upload(fileName, byteArray) // Используем имя файла
                        Log.d("UploadResponse", uploadResponse.toString())

                        // Формируем URL изображения
                        "https://vkxcxcimqqswxqxncmof.supabase.co/storage/v1/object/public/exvesta/$fileName"
                    }
                }
                // Создаем объект Bows
                val bow = Bows(
                    id = null, // ID будет сгенерирован автоматически
                    title_bow = title,
                    id_user = userId,
                    status = pub, // Установите статус по вашему усмотрению
                    img = imageUrl
                )

                // Вставка образа в базу данных
                val insertBowResponse = Constants.supabase.from("Bows").insert(bow) {
                    select()
                }.decodeSingle<Bows>().id
                Log.d("InsertBowResponse", insertBowResponse.toString())

                try {
                    val newBowId = insertBowResponse
                    Log.d("newBowId", newBowId.toString())
                    if (newBowId != null) {
                        // Преобразуем список selectedThings в список идентификаторов
                        val selectedThingIds =
                            selectedThings.mapNotNull { it?.id } // Предполагаем, что у Things_user есть свойство id

                        // Вставка выбранных вещей в таблицу Consists_bows
                        selectedThingIds.forEach { thingId ->
                            val consistBow = Consists_bows(
                                id = null, // ID будет сгенерирован автоматическиу
                                id_components = thingId,
                                id_bow = newBowId
                            )

                            val insertConsistResponse =
                                Constants.supabase.from("Consists_bows").insert(consistBow)
                            Log.d("InsertConsistResponse", insertConsistResponse.toString())
                        }
                    } else {
                        Log.d("все плохо", "newBowId is null")
                    }
                } catch (e: Exception) {
                    Log.e(
                        "InsertConsistError",
                        "Error retrieving newBowId or inserting into consists_bows: ${e.message}"
                    )
                }


            } catch (e: Exception) {
                println("Error during insertion: ${e.message}")
            }
        }
    }

    fun addpublickthing(
        userthing: List<Things_user>,
        conwar: List<Consists_wardrob>,
        id_wardrob: Int,
        selectstyle: Int,
        selectsubtype: Int,
        selecttitle: String,
        selectseason: Int,
        selectimg: String
    ) {

        val sortusthing =
            userthing.filter { it.id_season == selectseason && it.title == selecttitle && it.style == selectstyle && it.img == selectimg }

        viewModelScope.launch {
            if (sortusthing.isNotEmpty()) { // Проверяем, не пустой ли список
                val sort = sortusthing.firstOrNull()?.id

                try {
                    if (sort != null) { // Проверяем, что sort не null
                        // Проверяем, существует ли уже запись в Consists_wardrob
                        val exists =
                            conwar.any { it.id_thing == sort && it.id_wardrob == id_wardrob }
                        if (!exists) {
                            val conw = Consists_wardrob(
                                id = null,
                                id_thing = sort,
                                id_wardrob = id_wardrob
                            )
                            val insertRespon =
                                Constants.supabase.from("Consists_wardrob").insert(conw)
                            Log.d("InsertConsistResponse", insertRespon.toString())
                        } else {
                            Log.d("Info", "Item already exists in Consists_wardrob")
                        }
                    } else {
                        Log.e("Error", "sort is null")
                    }
                } catch (e: Exception) {
                    println("Error during insertion: ${e.message}")
                }
            } else { // Если список пустой, создаем новый элемент
                val thing = Things_user(
                    id = null,
                    style = selectstyle,
                    title = selecttitle,
                    subtype = selectsubtype,
                    img = selectimg,
                    id_season = selectseason,
                    no = false,
                    public_status = true
                )

                try {
                    // Вставка элемента в базу данных
                    val insertResponse = Constants.supabase.from("Things_user").insert(thing) {
                        select()
                    }.decodeSingle<Things_user>()

                    val newId = insertResponse.id // Получаем id вставленного элемента
                    Log.d("newBowId", newId.toString())

                    if (newId != null) {
                        // Проверяем, существует ли уже запись в Consists_wardrob
                        val exists =
                            conwar.any { it.id_thing == newId && it.id_wardrob == id_wardrob }
                        if (!exists) {
                            val conw = Consists_wardrob(
                                id = null,
                                id_thing = newId,
                                id_wardrob = id_wardrob
                            )
                            val insertRespon =
                                Constants.supabase.from("Consists_wardrob").insert(conw)
                            Log.d("InsertConsistResponse", insertRespon.toString())
                        } else {
                            Log.d("Info", "Item already exists in Consists_wardrob")
                        }
                    } else {
                        Log.e("Error", "newId is null")
                    }
                } catch (e: Exception) {
                    println("Error during insertion: ${e.message}")
                }
            }
        }

    }
}