mia/src/main/kotlin/ui/Profiles.kt

package ui

import androidx.compose.foundation.ExperimentalFoundationApi
import androidx.compose.foundation.background
import androidx.compose.foundation.clickable
import androidx.compose.foundation.combinedClickable
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.verticalScroll
import androidx.compose.material.AlertDialog
import androidx.compose.material.Button
import androidx.compose.material.Icon
import androidx.compose.material.MaterialTheme
import androidx.compose.material.Text
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Cancel
import androidx.compose.material.icons.filled.Check
import androidx.compose.material.icons.filled.Create
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.MutableState
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
import cafe.adriel.voyager.navigator.LocalNavigator
import cafe.adriel.voyager.navigator.currentOrThrow
import com.fasterxml.jackson.core.JsonEncoding
import kotlinx.coroutines.delay
import kotlinx.serialization.ExperimentalSerializationApi
import kotlinx.serialization.SerialName
import kotlinx.serialization.Serializable
import kotlinx.serialization.SerializationException
import kotlinx.serialization.json.Json
import kotlinx.serialization.json.decodeFromStream
import kotlinx.serialization.json.encodeToStream
import transparentButton
import ui.Capture.Companion.getCaptureDuration
import ui.screens.ProfileDetails
import ui.screens.ProfilesManager
import ui.screens.ProfilesManager.Companion.profileListItem
import ui.screens.Settings
import java.io.File
import java.io.FileInputStream
import java.io.FileNotFoundException
import java.io.FileOutputStream
import java.nio.file.Path
import java.nio.file.Paths
import kotlin.io.path.absolutePathString

class Profiles {
    companion object {
        val activeProfile = mutableStateOf(getCurrentProfile())
        val profiles = mutableStateOf(getProfiles())

        fun getCurrentProfile() = load(Settings.userSettings.getProperty("current_profile"))
        fun getProfileLocation(profile: String?) = Paths.get("profiles/$profile.profile").absolutePathString()
        fun getProfiles(): MutableList<Profile> {
            val files = File(Paths.get("profiles/").absolutePathString()).listFiles()

            files.ifEmpty {
                Settings.userSettings.remove("current_profile")
            }

            return files.map { file ->
                load(file)
            } as MutableList<Profile>
        }

        @OptIn(ExperimentalFoundationApi::class)
        @Composable
        fun profileList() {
            var showActivateDialog by rememberSaveable { mutableStateOf(false) }
            var showDeleteDialog by rememberSaveable { mutableStateOf(false) }
            var selectedProfile by rememberSaveable { mutableStateOf<Profile>(Profile()) }

            val navigator = LocalNavigator.currentOrThrow
            profiles.value = getProfiles()

            Column(
                modifier = Modifier
                    .padding(horizontal = 25.dp)
                    .padding(top = 10.dp, bottom = 50.dp)
                    .verticalScroll(rememberScrollState()),
                horizontalAlignment = Alignment.End,
            ) {

                profileListItem(
                    modifier = Modifier
                        .background(MaterialTheme.colors.onBackground.copy(alpha = 0.05f), CircleShape),
                    profileName = "Profile Name",
                    programName = "Program Name",
                    aiName = "AI Name"
                )

                var count = 1
                profiles.value.forEach { profile ->
                    val backgroundColor = if (count % 2 == 0) MaterialTheme.colors.onBackground.copy(alpha = 0.05f) else MaterialTheme.colors.background

                    profileListItem(
                        modifier = Modifier
                            .background(backgroundColor, CircleShape)
                            .combinedClickable(
                                onClick = {
                                    navigator.push(ProfileDetails(profile))
                                },
                                onDoubleClick = {
                                    selectedProfile = profile
                                    showActivateDialog = true
                                },
                                onLongClick = {
                                    selectedProfile = profile
                                    showDeleteDialog = true
                                },
                            ),
                        profileName = profile.name,
                        programName = profile.programName,
                        aiName = profile.aiName,
                    )
                    count++
                }

                if (showActivateDialog) {
                    profileDialog(
                        title = "Confirm Activation",
                        text = "Activate ${selectedProfile.name}?",
                        confirmClick = {
                            activeProfile.value = selectedProfile
                            Settings.userSettings.setProperty("current_profile", selectedProfile.name)
                            Settings.userSettings.save()
                            showActivateDialog = false
                        },
                        cancelClick = {
                            showActivateDialog = false
                        },
                    )
                }
                if (showDeleteDialog) {
                    profileDialog(
                        title = "Confirm Deletion",
                        text = "Delete ${selectedProfile.name}?",
                        confirmClick = {
                            File(getProfileLocation(selectedProfile.name)).delete()

                            if (activeProfile.value == selectedProfile) {
                                Settings.userSettings.remove("current_profile")
                                Settings.userSettings.save()
                                activeProfile.value = getCurrentProfile()
                            }
                            showDeleteDialog = false
                        },
                        cancelClick = {
                            showDeleteDialog = false
                        }
                    )
                }
            }

        }

        @Composable
        fun profileDialog(title: String, text: String, confirmClick: () -> Unit, cancelClick: () -> Unit) {
            AlertDialog(
                title = { Text(text = title) },
                text = { Text(text = text) },
                onDismissRequest = {
                    cancelClick
                },
                confirmButton = {
                    Button(
                        onClick = confirmClick
                    ) {
                        Icon(
                            imageVector = Icons.Filled.Check,
                            contentDescription = "Accept"
                        )
                    }
                },
                dismissButton = {
                    Button(
                        onClick = cancelClick
                    ) {
                        Icon(
                            imageVector = Icons.Filled.Cancel,
                            contentDescription = "Cancel"
                        )
                    }
                }
            )
        }

        @Composable
        fun createProfile(modifier: Modifier) {
            val navigator = LocalNavigator.currentOrThrow

            Box(
                modifier = modifier
                    .background(MaterialTheme.colors.primary, CircleShape)
            ) {
                transparentButton(
                    modifier = Modifier,
                    icon = Icons.Filled.Create,
                    contentDescription = "Create new profile",
                    onClick = {
                        navigator.push(ProfileDetails(null))
                    },
                )
            }
        }

        @OptIn(ExperimentalFoundationApi::class)
        @Composable
        fun currentProfile(modifier: Modifier) {
            val navigator = LocalNavigator.currentOrThrow

            Text(
                modifier = modifier
                    .background(MaterialTheme.colors.primary, CircleShape)
                    .padding(5.dp)
                    .width(150.dp)
                    .combinedClickable(
                        onClick = { navigator.push(ProfileDetails(activeProfile.value)) },
                        onDoubleClick = {
                            if (navigator.lastItem !is ProfilesManager) {
                                navigator.push(ProfilesManager())
                            }
                        }
                    ),
                color = MaterialTheme.colors.onPrimary,
                textAlign = TextAlign.Center,
                text = activeProfile.value.name
            )
        }

        @Serializable
        data class Profile(
            val name: String = "{NO NAME}",
            @SerialName("ai_name")
            val aiName: String = "{NO NAME}",
            @SerialName("program_name")
            val programName: String = "{NO NAME}",
            @SerialName("program_path")
            val programPath: String = "{NO NAME}",
            @SerialName("commands")
            val commands: List<Command>? = null,
        )

        @Serializable
        data class Command(
            @SerialName("wording_Variants")
            val wordingVariants: List<String>? = null,
            val triggers: List<String>? = null
        )

        @OptIn(ExperimentalSerializationApi::class)
        fun load(profile: File?): Profile {
            var file: Profile

            try {
                val stream = FileInputStream(profile!!)
                file = Json.decodeFromStream<Profile>(stream).copy(name = profile.nameWithoutExtension)
                stream.close()
            }
            catch (ne: FileNotFoundException) {
                file = Profile(name = "Not Selected")
            }
            catch (je: SerializationException) {
                file = Profile(name = profile!!.nameWithoutExtension)
            }

            return file
            //TODO: Add logging messages
        }

        fun load(profile: String?): Profile = load(File(getProfileLocation(profile)))

        @OptIn(ExperimentalSerializationApi::class)
        fun save(profile: Profile) {
            val stream = FileOutputStream(getProfileLocation(profile.name))
            Json.encodeToStream(profile, stream)
            stream.flush()
            stream.close()
        }

    }
}