package com.hrznstudio.gadgetry.block;

import com.hrznstudio.titanium.annotation.Save;
import com.hrznstudio.titanium.api.IFactory;
import com.hrznstudio.titanium.block.BlockTileBase;
import com.hrznstudio.titanium.block.tile.TilePowered;
import com.hrznstudio.titanium.block.tile.progress.PosProgressBar;
import com.hrznstudio.titanium.inventory.PosInvHandler;
import net.minecraft.block.material.Material;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.tileentity.TileEntityFurnace;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.EnumHand;
import net.minecraftforge.common.util.LazyOptional;
import net.minecraftforge.energy.CapabilityEnergy;
import net.minecraftforge.energy.IEnergyStorage;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;

public class BlockGenerator extends BlockTileBase<BlockGenerator.TileGenerator> {
    public static final BlockGenerator BLOCK = new BlockGenerator();

    public BlockGenerator() {
        super("generator", Properties.create(Material.IRON), TileGenerator.class);
    }

    @Override
    public IFactory<TileGenerator> getTileEntityFactory() {
        return TileGenerator::new;
    }

    public static class TileGenerator extends TilePowered {

        @Save
        private PosProgressBar progressBar;
        @Save
        private PosInvHandler inputSlot;
        @Save
        private boolean burning;
        @Save
        private int amount;

        public TileGenerator() {
            super(BLOCK);
            addProgressBar(
                    progressBar = new PosProgressBar(0, 52, 300)
                            .setOnFinishWork(() -> {
                                burning = false;
                                amount = 0;
                            }).setCanIncrease(tileEntity -> {
                                if (!burning) {
                                    ItemStack input = inputSlot.getStackInSlot(0);
                                    int burntime = getItemBurnTime(input);
                                    if (burntime > 0) {
                                        burning = true;
                                        amount = burntime / 20;
                                        input.shrink(1);
                                    }
                                }
                                return burning;
                            }).setCanReset(tileEntity -> !burning)
                            .setOnTickWork(() -> {
                                getEnergyStorage().receiveEnergy(amount, false);
                                List<IEnergyStorage> energyStorages = new ArrayList<>();
                                for (EnumFacing facing : EnumFacing.values()) {
                                    TileEntity tile = world.getTileEntity(pos.offset(facing));
                                    if (tile != null) {
                                        LazyOptional<IEnergyStorage> energy = tile.getCapability(CapabilityEnergy.ENERGY, facing.getOpposite());
                                        if (energy.isPresent())
                                            energyStorages.add(energy.orElseThrow(NullPointerException::new));
                                    }
                                }
                                if (!energyStorages.isEmpty()) {
                                    int amount = (int) Math.floor(40 / (double) energyStorages.size());
                                    energyStorages.forEach(iEnergyStorage -> iEnergyStorage.receiveEnergy(getEnergyStorage().extractEnergy(amount, false), false));
                                }
                            })
            );
            this.addInventory(
                    inputSlot = new PosInvHandler("input", 0, 0, 1)
                            .setTile(this)
                            .setInputFilter((stack, integer) -> TileEntityFurnace.isItemFuel(stack))
            );
        }

        private static int getItemBurnTime(ItemStack stack) {
            if (stack.isEmpty()) {
                return 0;
            } else {
                Item item = stack.getItem();
                int ret = stack.getBurnTime();
                return net.minecraftforge.event.ForgeEventFactory.getItemBurnTime(stack, ret == -1 ? TileEntityFurnace.getBurnTimes().getOrDefault(item, 0) : ret);
            }
        }

        @Override
        public boolean onActivated(EntityPlayer playerIn, EnumHand hand, EnumFacing facing, float hitX, float hitY, float hitZ) {
            openGui(playerIn);
            return true;
        }
    }
}