csamsclient/app/src/main/java/com/gyf/csams/association/ui/ExamActivity.kt

package com.gyf.csams.association.ui

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.rememberLazyListState
import androidx.compose.material.*
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.livedata.observeAsState
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.unit.Dp
import androidx.compose.ui.unit.dp
import androidx.lifecycle.viewmodel.compose.viewModel
import com.gyf.csams.R
import com.gyf.csams.association.model.*
import com.gyf.csams.uikit.*

/**
 * 题库管理
 *
 */
class ExamActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            Body { scaffoldState ->
                MainFrame(background = { Background(image = BackgroundImage.exam) }) {
                    Spacer(modifier = Modifier.weight(0.1F))
                    Title(modifier = Modifier.weight(0.1F))
                    Exam(modifier = Modifier.weight(0.8F))
                    ShowSnackbar(scaffoldState = scaffoldState)
                }
            }
        }
    }
}

/**
 * 底部按钮
 *
 */
@Composable
private fun BottomButton(
    modifier: Modifier = Modifier,
    model: ExamViewModel = viewModel(),
    scaffoldModel: ScaffoldModel = viewModel()
) {
    val context = LocalContext.current as ExamActivity
    Row(modifier = modifier, horizontalArrangement = Arrangement.Center) {
        OutlinedButton(onClick = {
            model.updateExam { scaffoldModel.update(message=it) }
        }, modifier = Modifier.background(color = MaterialTheme.colors.primary)) {
            Text(text = model.updateExam)
        }
        Spacer(modifier = Modifier.width(10.dp))
        OutlinedButton(onClick = {
            context.onBackPressed()
        }, modifier = Modifier.background(color = MaterialTheme.colors.secondary)) {
            Text(text = model.back)
        }
    }
}

/**
 * 标题
 *
 * @param modifier
 * @param model
 */
@Composable
private fun Title(modifier: Modifier = Modifier, model: ExamViewModel = viewModel()) {
    Row(horizontalArrangement = Arrangement.Center, modifier = modifier.fillMaxWidth()) {
        Text(text = model.menuName, style = MaterialTheme.typography.h4)
    }
}

@Composable
private fun ExamChild(it:Exam,examHeight: Dp,isAdd: Boolean=false){
    val questionWeight=0.3F
    when (it) {
        is OpenQuestionsVo -> ExamOQ(
            openQuestionsVo = it,
            modifier = Modifier.height(examHeight*questionWeight),
            isAdd = isAdd
        )
        is ChoiceQuestionVo -> ExamCQ(
            choiceQuestionVo = it,
            modifier = Modifier.height(examHeight),
            questionWeight = questionWeight,
            isAdd = isAdd
        )
    }
}

/**
 * 题目列表
 *
 * @param modifier
 * @param model
 */
@Composable
private fun Exam(
    modifier: Modifier = Modifier,
    model: ExamViewModel = viewModel(),
    scaffoldModel: ScaffoldModel = viewModel(),
    examHeight: Dp = 350.dp
) {
    val listState = rememberLazyListState()
    val data by model.data.observeAsState()
    val newExam by model.newExam.observeAsState()
    LazyColumn(state = listState, modifier = modifier) {
        data?.forEach {
            item {
                ExamChild(it = it, examHeight = examHeight)
                Spacer(modifier = Modifier.height(20.dp))
            }
        }
        newExam?.let {
            item {
                Column {
                    OutlinedButton(onClick = { model.switchType(it) }) {
                        Text(text = "切换到${if (newExam is ChoiceQuestionVo) "开放题" else "选择题"}")
                    }
                    ExamChild(it = it, examHeight = examHeight,isAdd = true)
                }
            }
        }

        item {
            Column {
                Divider(color = MaterialTheme.colors.background)
                Spacer(modifier = Modifier.height(30.dp))
                BottomButton(modifier = Modifier.fillMaxWidth())
            }
        }


    }
    if (listState.layoutInfo.totalItemsCount - listState.firstVisibleItemIndex == model.initSize / 2 - 1) {
        model.loadMore { scaffoldModel.update(message=it) }
    }


}

/**
 * 问题
 *
 * @param modifier
 * @param exam
 */
@Composable
private fun Question(modifier: Modifier = Modifier, exam: Exam) {
    BaseTextField(
        form = exam.question,
        modifier = modifier
            .fillMaxSize()
            .background(color = MaterialTheme.colors.background)
    )

}

/**
 * 操作按钮
 *
 */
@Composable
private fun ActionButton(modifier: Modifier = Modifier, isAdd: Boolean,
                         model: ExamViewModel= viewModel(),
                         scaffoldModel: ScaffoldModel= viewModel(),
                         exam: Exam) {
    val list by model.data.observeAsState()
    val newExam by model.newExam.observeAsState()
    Box(
        contentAlignment = Alignment.Center,
        modifier = modifier
    ) {
        IconButton(onClick = {
            if(isAdd){
                if((newExam?.question?.formValue?.value ?: "").isNotEmpty()){
                    scaffoldModel.update(message=model.addTip,actionLabel = model.actionLabel){
                        model.addQuestion()
                    }
                }else{
                    scaffoldModel.update(message = model.questionIsNull)
                }

            }else{
                if(list?.size==1){
                    scaffoldModel.update(model.deleteLeastOne)
                }else{
                    scaffoldModel.update(message=model.deleteTip,actionLabel = model.actionLabel){
                        model.deleteQuestion(exam = exam)
                    }
                }
            }
        }) {
            Icon(
                painter = painterResource(id = if (isAdd) R.drawable.ic_add_select else R.drawable.ic_sami_select),
                contentDescription = null
            )
        }
    }
}


/**
 * 开放题
 *
 * @param openQuestionsVo
 */
@Composable
private fun ExamOQ(
    modifier: Modifier = Modifier,
    openQuestionsVo: OpenQuestionsVo,
    isAdd: Boolean = false
) {
    Row(modifier = modifier) {
        Question(
            exam = openQuestionsVo, modifier = Modifier
                .weight(0.8F)
                .fillMaxHeight()
        )
        ActionButton(
            modifier = Modifier
                .weight(0.2F)
                .fillMaxHeight(),
            isAdd = isAdd,
            exam = openQuestionsVo
        )
    }
}

/**
 * 选择题
 *
 * @param choiceQuestionVo
 */
@Composable
private fun ExamCQ(
    modifier: Modifier = Modifier,
    choiceQuestionVo: ChoiceQuestionVo,
    isAdd: Boolean = false,
    model: ExamViewModel = viewModel(),
    questionWeight:Float
) {
    Row(modifier = modifier) {
        Column(
            modifier = Modifier
                .weight(0.8F)
                .fillMaxHeight()
        ) {
            Question(
                exam = choiceQuestionVo,
                modifier = Modifier
                    .fillMaxWidth()
                    .weight(questionWeight)
            )
            Card(
                backgroundColor = MaterialTheme.colors.secondaryVariant,
                modifier = Modifier
                    .fillMaxWidth()
                    .weight(1 - questionWeight)
            ) {

                choiceQuestionVo.answers.apply {
                    Column {
                        forEach {
                            Row(modifier = Modifier
                                .fillMaxWidth()
                                .weight(1F / ANSWER_SIZE)) {
                                val answerIndex: Int = indexOf(it)
                                val click = {
                                    model.update(
                                        oldExam = choiceQuestionVo,
                                        newExam = choiceQuestionVo.copy(rightAnswer = answerIndex)
                                    )
                                }
                                val isRightAnswer =
                                    choiceQuestionVo.rightAnswer == answerIndex
                                RadioButton(selected = isRightAnswer, onClick = click)
                                BaseTextField(form = it)
                            }
                        }
                    }
                }
            }
        }

        ActionButton(
            modifier = Modifier
                .weight(0.2F)
                .fillMaxHeight(),
            isAdd = isAdd,
            exam = choiceQuestionVo
        )

    }
}