VoidPlugin/VoidBank/src/main/kotlin/nl/voidcorp/bankplugin/VoidBank.kt

package nl.voidcorp.bankplugin

import nl.voidcorp.bankplugin.commands.*
import nl.voidcorp.bankplugin.costcalc.Collector
import nl.voidcorp.bankplugin.models.Bank
import nl.voidcorp.bankplugin.models.Banks
import nl.voidcorp.mainplugin.CommandHandler
import nl.voidcorp.mainplugin.VoidPluginBase
import nl.voidcorp.mainplugin.adapter
import nl.voidcorp.mainplugin.messaging.Message
import nl.voidcorp.mainplugin.messaging.MessageType
import nl.voidcorp.mainplugin.moshi
import org.bukkit.Bukkit
import org.bukkit.Material
import org.bukkit.NamespacedKey
import org.bukkit.attribute.Attribute
import org.bukkit.attribute.AttributeModifier
import org.bukkit.enchantments.Enchantment
import org.bukkit.entity.HumanEntity
import org.bukkit.entity.Player
import org.bukkit.event.EventHandler
import org.bukkit.event.Listener
import org.bukkit.event.block.BlockPlaceEvent
import org.bukkit.event.inventory.ClickType
import org.bukkit.event.inventory.CraftItemEvent
import org.bukkit.event.inventory.InventoryClickEvent
import org.bukkit.event.player.PlayerAttemptPickupItemEvent
import org.bukkit.inventory.*
import org.jetbrains.exposed.sql.SchemaUtils
import org.jetbrains.exposed.sql.transactions.transaction
import java.util.logging.Logger
import kotlin.math.min

class VoidBank(override val comment: String = "Sell all the diamonds!") : VoidPluginBase() {
    private val title = "Exchange"


    override fun enable() {

        VoidBank.logger = logger
        send("VoidPlugin", MessageType.GET_CONFIG)
        send("VoidPlugin", MessageType.POST_CONFIG, moshi.adapter<BankConfig>().toJson(VoidBank.config))
        Collector.rangeTo(0)
        send("VoidPlugin", MessageType.POST_CONFIG, moshi.adapter<BankConfig>().toJson(VoidBank.config))

        transaction {
            SchemaUtils.createMissingTablesAndColumns(Banks)
        }

        val buy = BuyCommand(this)
        CommandHandler(this).registerCommand("woodstrip", WoodStripCommand())
            .registerCommand("buymenu", buy)
            .registerCommand("checkcash", CheckCashCommand())
            .registerCommand("transfer", TransferCashCommand())
            .registerCommand("reload", ReloadCommand(this))


        iconMenu()
        for (iconMenu in iconMenus) {
            server.pluginManager.registerEvents(iconMenu, this)
        }

    }



    override fun recieve(message: Message) {
        when (message.messageType) {
            MessageType.GET_CONFIG -> {
                VoidBank.config = moshi.adapter<BankConfig>().fromJson(message.content)!!
            }
            else -> Unit
        }
    }


    val iconfun =
        { clicker: Player, menu: IconMenu, rowNum: Int, slot: Int, item: ItemStack?, event: InventoryClickEvent ->
            if (item != null) {
                if (rowNum == 5) {
                    if (slot == 0 || slot == 8) {
                        val s = item.itemMeta.lore?.get(0)?.toInt() ?: 0

                        val next = iconMenus[s]
                        if (next != menu) {
                            Bukkit.getScheduler().runTask(this) { _ ->
                                next.open(clicker)
                                menu.close(clicker)
                            }
                        }
                    }
                } else {
                    transaction {
                        val bank = Bank.find { Banks.player eq clicker.uniqueId }.firstOrNull() ?: Bank.new {
                            player = clicker.uniqueId
                        }
                        val price = item.itemMeta.lore?.get(0)?.toInt() ?: 0
                        val cash = bank.money
                        when (event.click) {
                            ClickType.LEFT -> {
                                if (cash >= price) {
                                    clicker.inventory.addItem(ItemStack(item.type))
                                    bank.money = cash - price
                                }
                            }
                            ClickType.RIGHT -> {

                                if (clicker.inventory.contains(item.type)) {
                                    val cl = clicker.inventory.removeItem(ItemStack(item.type))
                                    if (cl.isEmpty())
                                        bank.money = cash + price

                                }

                            }
                            ClickType.SHIFT_LEFT -> {
                                // max (0/1536, 64
                                val amt = min((cash / price).toInt(), item.type.maxStackSize)
                                clicker.inventory.addItem(ItemStack(item.type, amt))
                                bank.money = cash - amt * price

                            }
                            ClickType.SHIFT_RIGHT -> {
                                if (clicker.inventory.contains(item.type)) {
                                    val amt =
                                        min(clicker.inventory.contents.filterNotNull().filter { it.type == item.type }.map { it.amount }.sum(),
                                            item.type.maxStackSize
                                        )
                                    val rm = ItemStack(item.type, amt)
                                    clicker.inventory.removeItem(rm)
                                    bank.money = cash + price * amt
                                }
                            }
                            else -> {
                                Unit
                            }
                        }
                        clicker.sendMessage("You have ${bank.money} ECs left!")
                    }
                }
            }
            true
        }

    val iconMenus = mutableListOf<IconMenu>()

    fun iconMenu() {
        val mats = Material.values()
            .filter { !it.name.startsWith("LEGACY") and !it.isEmpty and it.isItem and !it.name.contains("SPAWN") }
            .filter { Collector[it] > 0 }
            .chunked(45)
        val needed = mats.size
        repeat(needed) {
            iconMenus += IconMenu(title, 6, iconfun)
        }
        logger.info("There are $needed pages needed to show all sales")
        for ((key, v) in mats.withIndex()) {
            for ((index, material) in v.withIndex()) {
                val x = index % 9
                val y = index / 9
                val cost = Collector[material]
                iconMenus[key].addButton(y, x, ItemStack(material), "", cost.toString())
            }
            val prev = key - 1
            val next = key + 1
            for (z in 0..8) {
                iconMenus[key].addButton(5, z, ItemStack(Material.BARRIER), "Bad, don't click here!")
            }
            if (prev >= 0)
                iconMenus[key].addButton(
                    5,
                    0,
                    ItemStack(Material.FILLED_MAP),
                    "Page $prev",
                    prev.toString()
                )
            if (next < mats.size)
                iconMenus[key].addButton(
                    5,
                    8,
                    ItemStack(Material.FILLED_MAP),
                    "Page $next",
                    next.toString()
                )
            iconMenus[key].addButton(
                5,
                4,
                ItemStack(Material.MAP),
                "Page $key"
            )

        }

    }

    companion object {
        lateinit var logger: Logger
        lateinit var config: BankConfig
    }
}