package rasel.lunar.launcher.utils


object EnToKo {
    var ignoreChars: String = "`1234567890-=[]\\;',./~!@#$%^&*()_+{}|:\"<>? "

    /** * 영어를 한글로...  */
    fun engToKor(eng: String): String {
        val sb = StringBuffer()
        var initialCode = 0
        var medialCode = 0
        var finalCode = 0
        var tempMedialCode: Int
        var tempFinalCode: Int
        var i = 0
        while (i < eng.length) {
            // 숫자특수문자 처리
            if (ignoreChars.indexOf(eng.substring(i, i + 1)) > -1) {
                sb.append(eng.substring(i, i + 1))
                i++
                continue
            }

            // 초성코드 추출
            initialCode = getCode(CodeType.chosung, eng.substring(i, i + 1))
            i++

            // 다음문자로
            // 중성코드 추출
            tempMedialCode = getDoubleMedial(i, eng)

            // 두 자로 이루어진 중성코드 추출
            if (tempMedialCode != -1) {
                medialCode = tempMedialCode
                i += 2
            } else {
                // 없다면,
                medialCode = getSingleMedial(i, eng)

                // 한 자로 이루어진 중성코드 추출
                i++
            }

            // 종성코드 추출
            tempFinalCode = getDoubleFinal(i, eng)

            // 두 자로 이루어진 종성코드 추출
            if (tempFinalCode != -1) {
                finalCode = tempFinalCode

                // 그 다음의 중성 문자에 대한 코드를 추출한다.
                tempMedialCode = getSingleMedial(i + 2, eng)
                if (tempMedialCode != -1) {
                    // 코드 값이 있을 경우
                    finalCode = getSingleFinal(i, eng)

                    // 종성 코드 값을 저장한다.
                } else {
                    i++
                }
            } else {
                // 코드 값이 없을 경우 ,
                tempMedialCode = getSingleMedial(i + 1, eng)

                // 그 다음의 중성 문자에 대한 코드 추출.
                if (tempMedialCode != -1) {
                    // 그 다음에 중성 문자가 존재할 경우,
                    finalCode = 0 // 종성 문자는 없음.
                    i--
                } else {
                    finalCode = getSingleFinal(i, eng)

                    // 종성 문자 추출
                    if (finalCode == -1) {
                        finalCode = 0
                        i--

                        // 초성,중성 + 숫자,특수문자,
                        //기호가 나오는 경우 index를 줄임.
                    }
                }
            }

            // 추출한 초성 문자 코드,
            //중성 문자 코드, 종성 문자 코드를 합한 후 변환하여 스트링버퍼에 넘김
            sb.append((0xAC00 + initialCode + medialCode + finalCode).toChar())
            i++
        }
        return sb.toString()
    }

    /** * 해당 문자에 따른 코드를 추출한다. * * @param type * 초성 : chosung, 중성 : jungsung, 종성 : jongsung 구분 * @param char 해당 문자  */
    private fun getCode(type: CodeType, c: String): Int {
        // 초성
        val init = "rRseEfaqQtTdwWczxvg"

        // 중성
        val mid = arrayOf(
            "k",
            "o",
            "i",
            "O",
            "j",
            "p",
            "u",
            "P",
            "h",
            "hk",
            "ho",
            "hl",
            "y",
            "n",
            "nj",
            "np",
            "nl",
            "b",
            "m",
            "ml",
            "l"
        )

        // 종성
        val fin = arrayOf(
            "r",
            "R",
            "rt",
            "s",
            "sw",
            "sg",
            "e",
            "f",
            "fr",
            "fa",
            "fq",
            "ft",
            "fx",
            "fv",
            "fg",
            "a",
            "q",
            "qt",
            "t",
            "T",
            "d",
            "w",
            "c",
            "z",
            "x",
            "v",
            "g"
        )
        when (type) {
            CodeType.chosung -> {
                val index = init.indexOf(c)
                if (index != -1) {
                    return index * 21 * 28
                }
            }

            CodeType.jungsung -> {
                var i = 0
                while (i < mid.size) {
                    if (mid[i] == c) {
                        return i * 28
                    }
                    i++
                }
            }

            CodeType.jongsung -> {
                var i = 0
                while (i < fin.size) {
                    if (fin[i] == c) {
                        return i + 1
                    }
                    i++
                }
            }

            else -> println("잘못된 타입 입니다")
        }
        return -1
    }

    // 한 자로 된 중성값을 리턴한다
    // 인덱스를 벗어낫다면 -1을 리턴
    private fun getSingleMedial(i: Int, eng: String): Int {
        return if ((i + 1) <= eng.length) {
            getCode(CodeType.jungsung, eng.substring(i, i + 1))
        } else {
            -1
        }
    }

    // 두 자로 된 중성을 체크하고, 있다면 값을 리턴한다.
    // 없으면 리턴값은 -1
    private fun getDoubleMedial(i: Int, eng: String): Int {
        val result: Int
        if ((i + 2) > eng.length) {
            return -1
        } else {
            result = getCode(CodeType.jungsung, eng.substring(i, i + 2))
            return if (result != -1) {
                result
            } else {
                -1
            }
        }
    }

    // 한 자로된 종성값을 리턴한다
    // 인덱스를 벗어낫다면 -1을 리턴
    private fun getSingleFinal(i: Int, eng: String): Int {
        return if ((i + 1) <= eng.length) {
            getCode(CodeType.jongsung, eng.substring(i, i + 1))
        } else {
            -1
        }
    }

    // 두 자로된 종성을 체크하고, 있다면 값을 리턴한다.
    // 없으면 리턴값은 -1
    private fun getDoubleFinal(i: Int, eng: String): Int {
        return if ((i + 2) > eng.length) {
            -1
        } else {
            getCode(CodeType.jongsung, eng.substring(i, i + 2))
        }
    }

    // 코드타입 - 초성, 중성, 종성
    internal enum class CodeType {
        chosung, jungsung, jongsung
    }
}
