package db.migration

import dao.DictionaryDao
import kotlinx.serialization.decodeFromString
import tables.*
import org.flywaydb.core.api.migration.BaseJavaMigration
import org.flywaydb.core.api.migration.Context
import org.jetbrains.exposed.dao.id.EntityID
import org.jetbrains.exposed.sql.Database
import org.jetbrains.exposed.sql.SchemaUtils
import org.jetbrains.exposed.sql.insert
import org.jetbrains.exposed.sql.transactions.transaction
import org.jetbrains.exposed.sql.upsert
import kotlin.system.exitProcess

class V3__create_dictionaries: BaseJavaMigration() {
    override fun migrate(context: Context?) {
        println(SharedData.hashDict)
        //exitProcess(0)
        for ((db_id,dict) in SharedData.hashDict) {

            val db_name = "jdbc:h2:file:/Users/jaro/data/${SharedData.hashLang[dict.lang1Id]?.shortName}-${SharedData.hashLang[dict.lang2Id]?.shortName}"
            println(db_name)
            val db = Database.connect(db_name)
            transaction (db) {
                SchemaUtils.create(Dictionaries, Languages, Translations, Pronunciations, PronunciationTypes, DictTypes, Suffixes, Terms)

                for ((di, lang) in SharedData.hashLang) {
                    Languages.insert {
                        it[id] = lang.id
                        it[name] = lang.name
                        it[shortName] = lang.shortName
                    }
                }

                for ((di, d) in SharedData.hashDict) {
                    Dictionaries.insert {
                        it[id] = d.id
                        it[lang1] = d.lang1Id
                        it[lang2] = d.lang2Id
                        it[name] = d.name
                        it[fullName] = d.fullName
                    }
                }

                for ((di, trans) in SharedData.hashTransMap) {
                    Translations.insert {
                        it[id] = trans.id
                        it[lang1Id] = trans.lang1Id
                        it[lang2Id] = trans.lang2Id
                        it[dictionaryId] = trans.dictionaryId
                        it[langName1] = trans.lang1Name
                        it[langName2] = trans.lang2Name
                        it[direction] = trans.direction
                    }
                }

                PronunciationTypes.insert {
                    it[id] = 1
                    it[name] = "English"
                }

                PronunciationTypes.insert {
                    it[id] = 2
                    it[name] = "American english"
                }

                PronunciationTypes.insert {
                    it[id] = 3
                    it[name] = "Business english"
                }

                for ((di, pron) in SharedData.hashPron) {
                    Pronunciations.insert {
                        it[id] = pron.id
                        it[typeId] = pron.typeId
                        it[ipa] = pron.ipa
                        it[filename] = pron.filename
                    }
                }

                for ((di, dt) in SharedData.hashDictType) {
                    DictTypes.insert {
                        it[id] = dt.id
                        it[shortName] = dt.shortName
                        it[fullName] = dt.fullName
                    }
                }

                for ((di, ss) in SharedData.hashSuffix) {
                    Suffixes.insert {
                        it[id] = ss.id
                        it[text] = ss.text
                    }
                }

                var dictTerms = SharedData.getListofTerms(db_id)
                for (t in dictTerms) {
                    Terms.insert {
                        it[id] = t.id
                        it[string1] = t.string1
                        it[string2] = t.string2
                        it[suffix1] = t.suffix1Id
                        it[suffix2] = t.suffix2Id
                        it[type] = t.typeId
                        it[member] = t.member
                        it[order2] = t.order2
                        it[flags] = format.decodeFromString<IntArray?>(t.flags?.toString() ?:"[]")
                    }
                }
                dictTerms = listOf()

            }

        }
    }
}