const $ForgeEnergyRecipeCapability = Java.loadClass("com.lowdragmc.mbd2.common.capability.recipe.ForgeEnergyRecipeCapability")
const $FluidRecipeCapability = Java.loadClass("com.lowdragmc.mbd2.common.capability.recipe.FluidRecipeCapability")
const $SwitchWidget = Java.loadClass("com.lowdragmc.lowdraglib.gui.widget.SwitchWidget")



//初始化CustomData
MBDMachineEvents.onStructureFormed("createdelight:fission_reactor", e => {
    let customData = e.event.machine.customData
        let machine = e.event.machine
        let assembly_count = 0
        /** @type {Internal.MBDMultiblockMachine} */
        let multiblock = machine

        multiblock.parts.forEach(part => {
            /** @type {Internal.MBDPartMachine} */
            let machinePart = part
            if (machinePart.definition.id() == "createdelight:fission_fuel_assembly")
                assembly_count++
        })
    if(customData.getInt("assembly_count") != assembly_count) {
        customData.putInt("assembly_count", assembly_count)
    }
    if(!customData.getDouble("burning_rate")) {
        customData.putDouble("burning_rate", 0)
    }
    if(!customData.getDouble("temperature")) {
        customData.putDouble("temperature", 298.15)
    }
    if(!customData.getDouble("degree_of_damage")) {
        customData.putDouble("degree_of_damage", 0)
    }
    if(!customData.getDouble("multiplier")) {
        customData.putDouble("multiplier", 0)
    }
})
const BASE_HEAT_RATE = 0.08         // 基础发热率
const BASE_COOL_RATE = 0.08         // 基础冷却率
const TEMP_MULTIPLIER = 0.0005      // 温度对效率的影响
const CRITICAL_TEMP = 1500.0        //临界温度，超出后增加损坏率
const MELTDOWN_TEMP = 2500.0        //融毁温度，超出后直接爆炸

//升温逻辑及代码判断
MBDMachineEvents.onTick("createdelight:fission_reactor", e => {
    const { machine } = e.event
    const customData = machine.customData
    if (machine.level.time % 3 != 0) return

    let temp = customData.getDouble("temperature")
    let degree_of_damage = customData.getDouble("degree_of_damage")
    let multiplier = machine.customData.getDouble("multiplier")

    // 缓存冷却与发热，避免重复调用造成开销
    const heatProduced = ReactorUtil.heatProduced(machine)
    const cooling = ReactorUtil.cooling(machine)
    const coolingTemp = cooling[0]
    const coolingDamage = cooling[1]

    let ambientCooling = 0.05 + (temp - 298.15) * 0.0001
    let newTemp = Math.max(298.15, temp + heatProduced * 3 - coolingTemp * 3 - ambientCooling * 3)
    customData.putDouble("temperature", newTemp)

    let damageProduced = 0
    if (newTemp >= CRITICAL_TEMP) {
        damageProduced = 0.01 * customData.getInt("assembly_count") * 3
        if(degree_of_damage > 50) {
            machine.level.playSound(null, machine.pos.x, machine.pos.y, machine.pos.z, "alexscaves:nuclear_siren", "blocks", 1, 1)
        }
    }

    let newDamage = Math.max(0, degree_of_damage + damageProduced - coolingDamage * 3)
    if (newDamage != degree_of_damage) {customData.putDouble("degree_of_damage", newDamage)}
    
    if (temp < 1000) { multiplier = 0 }
    else if (temp >= 1000 && temp <= 1500) { multiplier = (1 + 2 * (temp - 1000) / 500) }
    else { multiplier = 3 }
    customData.putDouble("multiplier", multiplier)

    if (degree_of_damage >= 100) {ReactorUtil.Bombbbb(machine)}
    if (newTemp >= MELTDOWN_TEMP) {ReactorUtil.Bombbbb(machine)}
    // machine.level.tell(`damageProduced:${damageProduced}, damageReducecd:${damageReducecd}, newDamage:${newDamage}, boolean:${newTemp >= CRITICAL_TEMP}`)
})
//温度对于产电的调节
MBDMachineEvents.onBeforeRecipeModify("createdelight:fission_reactor", e => {
    const { machine, recipe } = e.event
    let burning_rate = machine.customData.getDouble("burning_rate")
    let assembly_count = machine.customData.getInt("assembly_count") * burning_rate
    e.event.setRecipe(recipe.copy(ContentModifier.multiplier(Math.pow(1.0415, assembly_count)), false, "both"))
})
MBDMachineEvents.onAfterRecipeModify("createdelight:fission_reactor", e => {
    const { machine, recipe } = e.event
    let multiplier = machine.customData.getDouble("multiplier") 

    if(multiplier != 0) {
        e.event.setRecipe(recipe.copy(ContentModifier.multiplier(multiplier), false, "both"))
    } else {
        e.event.setRecipe(recipe.copy(ContentModifier.multiplier(0), false, "out"))
    }
})

// 输入槽位有流体且输出槽位可接受配方产出时，使连续工作的空配方失效
MBDMachineEvents.onAfterRecipeWorking("createdelight:fission_reactor", e => {
    const { machine, recipe } = e.event
    
    if (recipe.id && recipe.id == "createdelight:fission_react/empty") {
        let recipeLogic = machine.recipeLogic
        let fluid = machine.getCapability(ForgeCapabilities.FLUID_HANDLER).orElse(null)
        let energy = machine.getCapability(ForgeCapabilities.ENERGY).orElse(null)
        let maxFluidInput = ReactorUtil.inputFluid(machine)
        let maxEnergyOutput = ReactorUtil.outputEnergy(machine)
        let maxFluidOutput = ReactorUtil.outputFluid(machine)
        // machine.level.recipeManager.getByType("createdelight:fission_react").forEach((id, r) => {
        //     let mbdRecipe = machine.getModifiedRecipe(r)
        //     mbdRecipe.getOutputContents($ForgeEnergyRecipeCapability.CAP).forEach(con => {
        //         if (maxEnergyOutput < con.getContent())
        //             maxEnergyOutput = con.getContent()
        //     })

        //     mbdRecipe.getOutputContents($FluidRecipeCapability.CAP).forEach(con => {
        //         if (maxFluidOutput < con.getContent().getAmount())
        //             maxFluidOutput = con.getContent().getAmount()
        //     })

        //     mbdRecipe.getInputContents($FluidRecipeCapability.CAP).forEach(con => {
        //         if(maxFluidInput < con.getContent().getAmount())
        //             maxFluidInput = con.getContent().getAmount()
        //     })
        // })
        //输入槽位有流体且输出槽位可接受配方产出时，使连续工作的空配方失效
        if (!fluid.getFluidInTank(0).empty
            && fluid.getFluidInTank(0).amount >= maxFluidInput
            && fluid.getFluidInTank(1).amount + maxFluidOutput <= fluid.getTankCapacity(1)
            && energy.getEnergyStored() + maxEnergyOutput <= energy.getMaxEnergyStored()
            ) {
                recipeLogic.markLastRecipeDirty()
            }
    }
})

//实现移除时核反应堆爆炸
MBDMachineEvents.onRemoved("createdelight:fission_reactor", e => {
    // console.log(`machineStateName: ${e.event.machine.machineStateName}`)
    if (e.event.machine.machineStateName == "working") {
        ReactorUtil.Bombbbb(e.event.machine)
    }
})
MBDMachineEvents.onStateChanged("createdelight:fission_reactor", e => {
    // console.log(`newState: ${e.event.newState}, oldState: ${e.event.oldState}`)
    if (e.event.newState == "base" && e.event.oldState == "working") {
        /** @type {Internal.MBDMultiblockMachine} */
        let multiblock = e.event.machine
        if (!multiblock.formed) {
            ReactorUtil.Bombbbb(e.event.machine)
        }
    }
})
MBDMachineEvents.onStructureInvalid("createdelight:fission_reactor", e => {
    // console.log(`machineStateName: ${e.event.machine.machineStateName}`)
    if (e.event.machine.machineStateName == "working") {
        ReactorUtil.Bombbbb(e.event.machine)
    }
})


//实现机器紧急启停效果
    //UI实现
MBDMachineEvents.onUI("createdelight:fission_reactor", e => {
    const { machine, root } = e.event
    const customData = machine.customData
    let burning_rate = customData.getDouble("burning_rate")

    let damage = root.getFirstWidgetById("degree_of_damage")
    let temperature = root.getFirstWidgetById("temperature")
    let reactor_switch = root.getFirstWidgetById("switch") 
    /**@type {SwitchWidget} */
    let reactor_on = root.getFirstWidgetById("reactor_on")
    /**@type {SwitchWidget} */
    let reactor_off = root.getFirstWidgetById("reactor_off")
    let heatProduced = root.getFirstWidgetById("heatProduced")
    let cooling = root.getFirstWidgetById("cooling")
    let ambientCooling = root.getFirstWidgetById("ambientCooling")
    let inputFluid = root.getFirstWidgetById("inputFluid")
    let outputFluid = root.getFirstWidgetById("outputFluid")
    let outputEnergy = root.getFirstWidgetById("outputEnergy")
    let burningRate = root.getFirstWidgetById("burningRate")
    /** @type {TextFieldWidget} */
    let modify_burning_rate = root.getFirstWidgetById("modify_burning_rate")
    if(burning_rate != 0) {
        reactor_on.setPressed(true)
        reactor_off.setPressed(false)
    } else {
        reactor_on.setPressed(false)
        reactor_off.setPressed(true)
    }

    reactor_off.setOnPressCallback(p => {
        if(!p.isRemote && reactor_off.pressed) {
            reactor_on.setPressed(false)
            customData.putDouble("burning_rate", 0)
        }
        if(!p.isRemote && !reactor_off.pressed) {
            reactor_off.setPressed(true)
        }
        return
    })

    reactor_on.setOnPressCallback(p => {
        if(!p.isRemote && reactor_on.pressed) {
            reactor_off.setPressed(false)
            customData.putDouble("burning_rate", 1)
        }
        if(!p.isRemote && !reactor_on.pressed) {
            reactor_on.setPressed(true)
        }
        return
    })

    damage.setTextProvider(() => 
        Component.translate("message.createdelight.fission_reactor.degree_of_damage", Math.round(customData.getDouble("degree_of_damage") * 100) / 100)
    )

    temperature.setTextProvider(() => 
        Component.translate("message.createdelight.fission_reactor.temperature", Math.round(customData.getDouble("temperature") * 100) / 100)
    )

    reactor_switch.setTextProvider(() => 
        Component.translate("message.createdelight.fission_reactor.switch").append(
            customData.getDouble("temperature") >= 1500 
                ? Component.translate(
                    customData.getDouble("temperature") >= 2000 
                        ? "message.createdelight.fission_reactor.meltdown_temp" 
                        : "message.createdelight.fission_reactor.critical_temp"
                )
                : Component.translate(
                    customData.getDouble("burning_rate") != 0
                        ? "message.createdelight.fission_reactor.switch_on" 
                        : "message.createdelight.fission_reactor.switch_off"
                )
        )
    )

    modify_burning_rate.currentString = (burning_rate * 100 || 0).toFixed()
    modify_burning_rate.setNumbersOnlyInt(0, 100)
    modify_burning_rate.setTextResponder(num => {
        if(num != 0) {
            reactor_on.setPressed(true)
            reactor_off.setPressed(false)
        } else {
            reactor_on.setPressed(false)
            reactor_off.setPressed(true)
        }
        customData.putDouble("burning_rate", num / 100)
    })

    heatProduced.setTextProvider(() =>
        Component.translate("message.createdelight.fission_reactor.heat_produced", Math.round(ReactorUtil.heatProduced(machine) * 100) / 100)
    )

    cooling.setTextProvider(() =>
        Component.translate("message.createdelight.fission_reactor.fluid_cooling", Math.round(ReactorUtil.cooling(machine)[0] * 100) / 100)
    )

    ambientCooling.setTextProvider(() =>
        Component.translate("message.createdelight.fission_reactor.ambient_cooling",
            Math.round((0.05 + (customData.getDouble("temperature") - 298.15) * 0.0001) * 100) / 100
        )
    )

    inputFluid.setTextProvider(() =>
        Component.translate("message.createdelight.fission_reactor.input_fluid", Math.round(ReactorUtil.inputFluid(machine,) * 100) / 100)
    )

    outputFluid.setTextProvider(() =>
        Component.translate("message.createdelight.fission_reactor.output_fluid", Math.round(ReactorUtil.outputFluid(machine) * 100) / 100)
    )

    outputEnergy.setTextProvider(() =>
        Component.translate("message.createdelight.fission_reactor.output_energy", Math.round(ReactorUtil.outputEnergy(machine)) / 1000)
    )

    burningRate.setTextProvider(() =>
        Component.translate("message.createdelight.fission_reactor.burning_rate", Math.round(customData.getDouble("burning_rate") * 100))
    )
})
    //配方逻辑
MBDMachineEvents.onBeforeRecipeWorking("createdelight:fission_reactor", e => {
    const { machine } = e.event
    if (machine.customData.getDouble("burning_rate") == 0) {
        e.event.setCanceled(true)
    }
})
MBDMachineEvents.onFuelRecipeModify("createdelight:fission_reactor", e => {
    const { machine } = e.event
    if (machine.customData.getDouble("burning_rate") == 0) {
        e.event.setCanceled(true)
    }
})




// /**
//  * 
//  * @param {Internal.Level} level 
//  * @param {BlockPos} pos 
//  * @param {number} age 
//  * @param {Map<string, number>} list 
//  * @param {number} degree_of_damage 
//  * @returns {Map<string, number>}
//  */
// function nuclearDiffusionByAge(level, pos, age, list, degree_of_damage) {
//     if (age == 0)
//         return -1
//     let positions = [pos.above(), pos.below(), pos.north(), pos.south(), pos.east(), pos.west()]
//     if (!level.getBlock(pos).hasTag("create_new_age:stops_radiation")
//         || degree_of_damage > 50) {
//         list.set(`${pos.x},${pos.y},${pos.z}`, age)
//         positions.forEach(position => {
//             if (list.get(`${position.x},${position.y},${position.z}`) == null) {
//                 nuclearDiffusionByAge(level, position, age - 1, list, degree_of_damage)
//             }
//         })
//     }
// }

// /**
//  * 
//  * @param {Internal.Level} level
//  * @param {BlockPos} pos
//  * @param {number} size
//  * @param {Map<string, number>} list
//  * @param {number} degree_of_damage 
//  * @returns {Map<string, number>}
//  */
// function nuclearDiffusionByCount(level, pos, size, list, degree_of_damage) {
//     if (list.size >= size)
//         return
//     let positions = [pos.above(), pos.below(), pos.north(), pos.south(), pos.east(), pos.west()]
//     if (!level.getBlock(pos).hasTag("create_new_age:stops_radiation")
//         || degree_of_damage > 50) {
//         list.set(`${pos.x},${pos.y},${pos.z}`, age)
//         positions.forEach(position => {
//             if (list.get(`${position.x},${position.y},${position.z}`) == null) {
//                 nuclearDiffusionByCount(level, position, age - 1, list, degree_of_damage)
//             }
//         })
//     }
// }
// let _reactor_map = new Map()
// MBDMachineEvents.onTick("createdelight:fission_fuel_assembly", e => {
//     const { level, pos, machineStateName } = e.event.machine
//     // console.log(machineStateName)
//     if (machineStateName == "working") {
//         let time = level.time
//         if (time % 200 == 0) {
//             /**
//              * @type {Map<string, number>}
//              */
//             let map = _reactor_map
//             map.clear()
//             //理论上只有一个控制器
//             /**
//              * @type {Internal.MBDMultiblockMachine}
//              */
//             let multiblock = e.event.machine.controllers.get(0)
//             nuclearDiffusionByAge(level, pos, 7, map, multiblock.customData.getDouble("degree_of_damage"))
//             map.forEach((age, position) => {
//                 let poslist = position.split(",")
//                 let x = parseInt(poslist[0])
//                 let y = parseInt(poslist[1])
//                 let z = parseInt(poslist[2])

//                 // let particle = Utils.particleOptions(`dust 1 0 0 1`)
//                 // level.spawnParticles(particle, false, x + 0.5, y + 0.5, z + 0.5, 0, 1, 0, 1, 0.5)
//                 level.getEntitiesWithin(AABB.of(x + 1, y + 1, z + 1, x - 1, y - 1, z - 1)).forEach(entity => {
//                     if (entity.isLiving()) {
//                         /**
//                          * @type {Internal.LivingEntity}
//                          */
//                         let livingEntity = entity
//                         livingEntity.potionEffects.add("alexscaves:irradiated", 12000, 4, true, true)
//                     }
//                 })
//             })
//         }
//     }
// })