package com.appypie.snappy.appsheet.asformula

import android.util.Log
import android.util.SparseArray
import com.appypie.snappy.appsheet.extensions.isDigitsOnly
import com.appypie.snappy.appsheet.pagedata.model.FieldItem
import java.lang.Exception
import java.util.*
import kotlin.collections.ArrayList

object FormulaUtil {
    var squareBracesRegex = "\\[[^\\[]*\\]"
    var stackTokenArr: MutableList<String>? = null
    var strTst = "CONCATENATE(UPPER([FName]),[LName],LOWER([FName]))"  //"CONCATENATE(UPPER([FName]),[LName],LOWER([FName]),UPPER([FName]))"
    var operatorArr = arrayOf("+", "-", "/", "%", "*")
    var functionArr = arrayOf(
            "UPPER", "LOWER", "CONCATENATE", "SQRT",
            "DISTANCE", "POWER", "ABS", "MAX", "MIN", "AVERAGE", "COUNT", "ROUND",
            "STDEVP", "FLOOR", "CEILING", "NUMBER", "DECIMAL", "SUM","LIST","LEFT"
    )


    fun getStackTokenArr(str: String): ArrayList<String> {
        var stackArr: ArrayList<String> = arrayListOf<String>()
        var getVal: String = ""
        var breakExpressions = "(,)"
        str.forEachIndexed { index, charData ->
            if (charData != null && breakExpressions.contains(charData)) {
                stackArr.add(getVal)
                stackArr.add(charData.toString())
                getVal = ""
            } else {
                getVal = "${getVal}${charData}"
            }
        }
        stackArr.add(getVal)
        return stackArr
    }

    //Function To Get Type Of Variables in Operator Operand Stack
    fun checkVariableType(position: Int, fieldsList: ArrayList<FieldItem>?): VARIABLE_TYPE {
        var checkVar = stackTokenArr?.get(position)
        if (functionArr.any { it == checkVar }) {
            return VARIABLE_TYPE.FUNCTION
        } else if (operatorArr.any { it == checkVar }) {
            return VARIABLE_TYPE.OPERATOR
        } else if ((checkVar ?: "").contains("[") && (checkVar ?: "").contains("]")) {
            fieldsList?.forEachIndexed { index, fieldItem ->
                var regex = fieldItem.fieldTitle?.toRegex()
                if (regex?.containsMatchIn((checkVar ?: "")) ?: false) {
                    stackTokenArr?.get(position)?.replace(checkVar ?: "", fieldItem.fieldValue ?: "")
                }
            }
            return VARIABLE_TYPE.COLOUM_VALUE
        } else if (checkVar.equals("(")) {
            return VARIABLE_TYPE.START_BRACKET
        } else if (checkVar.equals(")")) {
            return VARIABLE_TYPE.POP_TO_EVALUATE
        } else if ((checkVar ?: "").isDigitsOnly()) {
            return VARIABLE_TYPE.CONSTANT
        }
        return VARIABLE_TYPE.IGNORE
    }

    fun checkVariableType(position: Int): VARIABLE_TYPE {
        var checkVar = stackTokenArr?.get(position)
        if (functionArr.any { it == checkVar }) {
            return VARIABLE_TYPE.FUNCTION
        } else if (operatorArr.any { it == checkVar }) {
            return VARIABLE_TYPE.OPERATOR
        } else if ((checkVar ?: "").contains("[") && (checkVar ?: "").contains("]")) {
            return VARIABLE_TYPE.COLOUM_VALUE
        } else if (checkVar.equals("(")) {
            return VARIABLE_TYPE.START_BRACKET
        } else if (checkVar.equals(")")) {
            return VARIABLE_TYPE.POP_TO_EVALUATE
        } /*else if ((checkVar?:"").isDigitsOnly()) {
            return VARIABLE_TYPE.CONSTANT
        }*/
        return VARIABLE_TYPE.IGNORE
    }


    fun checkReplace(stackToken: String?, fieldsList: ArrayList<FieldItem>?): SparseArray<FieldItem> {
        var isColumnContains = SparseArray<FieldItem>()
        fieldsList?.forEachIndexed { index, fieldItem ->
            var regex = fieldItem.fieldTitle?.toRegex()
            if (regex?.containsMatchIn((stackToken ?: "")) ?: false) {
                isColumnContains.put(index,fieldItem)
            }
        }
        return isColumnContains
    }

    @JvmStatic
    fun manageFormulaStack(formula: String, fieldsList: ArrayList<FieldItem>?):String{
        stackTokenArr = getStackTokenArr(formula)
        var ops = Stack<String>()
        var vals = Stack<String>()
        stackTokenArr?.forEachIndexed { index, strData ->
            var args = checkVariableType(index)
            if (args.equals(VARIABLE_TYPE.COLOUM_VALUE)) {
                var data = checkReplace(strData,fieldsList)
                if(data.size()>0){
                    stackTokenArr?.set(index, data.valueAt(0).fieldValue?:"")
                    println("replacedData:${stackTokenArr?.get(index)}")
                }
            }

            if (args.equals(VARIABLE_TYPE.IGNORE))
            else if (args.equals(VARIABLE_TYPE.START_BRACKET))
            else if (args.equals(VARIABLE_TYPE.FUNCTION)) {
                ops.push(strData)
            } else if (args.equals(VARIABLE_TYPE.POP_TO_EVALUATE)) {
                var op = ops.pop()
                if (functionArr.any { it == op }) {
                    when (op) {
                        "UPPER" -> {
                            var value = vals.pop()
                            value = value.toUpperCase()
                            vals.push(value)
                        }
                        "LOWER" -> {
                            var value = vals.pop()
                            value = value.toLowerCase()
                            vals.push(value)
                        }
                        "SQRT" -> {
                            var value = vals.pop()
                            value = Math.sqrt(value?.toDouble()?:0.0).toString()
                            vals.push(value)
                        }
                        "POWER" -> {
                            var valueB = vals.pop()
                            var valueA = vals.pop()
                            try {
                                vals.push(Math.pow(valueA.toDouble(),valueB.toDouble()).toString())
                            }catch (e:Exception){
                                Log.e("POWER",e.message)
                            }
                        }
                        "LIST" -> {
                            for (index in 0 until vals.size) {
                                var value = vals.pop()
                                Regex("[,]").replace(value,"")
                                vals.push(value)
                            }
                        }
                        "CONCATENATE" -> {
                            var value = vals.pop()
                            for (index in 0 until vals.size) {
                                Regex("[,]").replace(value,"")
                                value = vals.pop() + value
                            }
                            vals.push(value)
                        }
                    }
                }
            } else {
                vals.push(stackTokenArr?.get(index))
            }
        }
        var resultPoped = vals.pop()
        println("Final print values:${resultPoped}")
        return "${resultPoped}"
    }

    /*"CONCATENATE([FName],LEFT([LName],2))",
    "SUM(LIST(SQRT(45),AVERAGE(LIST(78,4,86))))",
    "CONCATENATE(UPPER([FName]),[LName])",*/
    fun manageDoubleStack(args: String) {
        var ops = Stack<String>()
        var vals = Stack<Double>()
        if (args.equals(VARIABLE_TYPE.IGNORE))
        else if (args.equals(VARIABLE_TYPE.POP_TO_EVALUATE)) {
            var op = ops.pop()
            var value = vals.pop()
            if (operatorArr.any { it == op }) {
                when (op) {
                    "/" -> {
                        value = vals.pop() / value
                    }
                    "*" -> {
                        value = vals.pop() / value
                    }
                    "+" -> {
                        value = vals.pop() + value
                    }
                    "-" -> {
                        value -= vals.pop()
                    }
                    "%" -> {
                        value = vals.pop() / value
                    }
                }
            } else if (functionArr.any { it == op }) {
                when (op) {
                    "SQRT" -> {
                        value = Math.sqrt(value)
                    }
                    "AVERAGE" -> {

                    }
                    "DISTANCE" -> {

                    }
                    "POWER" -> {

                    }
                    "SUM" -> {

                    }
                    "ABS" -> {

                    }
                    "MAX" -> {

                    }
                    "MIN" -> {

                    }
                    "ABS" -> {

                    }
                    "COUNT" -> {

                    }
                    "ROUND" -> {

                    }
                    "STDEVP" -> {

                    }
                    "FLOOR" -> {

                    }
                    "CEILING" -> {

                    }
                    "NUMBER" -> {

                    }
                    "DECIMAL" -> {

                    }

                }
            }
            vals.push(value)
        } else if (args.equals(VARIABLE_TYPE.POP_TO_EVALUATE)) {


        }
    }

}