package com.uadaf.astral.apiimpl;

import cofh.api.energy.EnergyStorage;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import com.uadaf.astral.AstralMod;
import com.uadaf.astral.api.energy.IAstralBindableTile;
import com.uadaf.astral.api.energy.IAstralEnergyStorer;
import com.uadaf.astral.api.energy.IAstralNetwork;
import com.uadaf.astral.api.event.network.AstralNetworkAccessBlockedEvent;
import com.uadaf.astral.api.event.network.AstralNetworkAccessGrantedEvent;
import com.uadaf.astral.utils.SideCheck;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.world.World;
import net.minecraftforge.common.MinecraftForge;

import javax.annotation.Nullable;
import java.util.*;

class AstralNetworkImpl implements IAstralNetwork {

	private final int color;
	private final UUID owner;
	private final Set<IAstralBindableTile> bound = Sets.newHashSet(), immutableBoundView = Collections.unmodifiableSet(bound);
	private final Set<UUID> accessedPlayers = Sets.newHashSet(), immutableAccessedPlayersView = Collections.unmodifiableSet(accessedPlayers);
	private final List<PlayerDiff> playerDiff = Lists.newArrayList(), immutablePlayerDiffView = Collections.unmodifiableList(playerDiff);
	private final List<BoundDiff> boundDiff = Lists.newArrayList(), immutableBoundDiffView = Collections.unmodifiableList(boundDiff);
	private final EnergyStorage energyStorage = new EnergyStorage(0);
	private final HashMap<Integer, List<BoundDiff>> queuedBindings = Maps.newHashMap();
	private int energyDiff = 0;
	AstralNetworkImpl(int color, UUID owner) {
		this.color = color;
		this.owner = owner;
		accessedPlayers.add(owner);
	}

	@Override
	public int getNetworkColor() {
		return color;
	}

	@Override
	public void destroy() {
		bound.forEach(b -> b.onUnbound(this));
		bound.clear();
	}

	@Override
	public Set<IAstralBindableTile> getBound() {
		return immutableBoundView; //Unmodifiable set reflects all changes int base set
	}

	@Override
	public void bind(IAstralBindableTile bindable) {
		if(SideCheck.isServer() && bound.add(bindable)) {
			bindable.onBound(this);
			boundDiff.add(new BoundDiff(bindable.getPos(), true, bindable.getWorld().provider.getDimension()));
			if(bindable instanceof IAstralEnergyStorer) {
				recalculateStorage();
			}
		}
	}

	@Override
	public void unbind(IAstralBindableTile bindable) {
		if(SideCheck.isServer() && bound.remove(bindable)) {
			bindable.onUnbound(this);
			boundDiff.add(new BoundDiff(bindable.getPos(), false, bindable.getWorld().provider.getDimension()));
			if(bindable instanceof IAstralEnergyStorer) {
				recalculateStorage();
			}
		}
	}

	@Override
	public void queueBinding(BoundDiff binding) {
		queuedBindings.compute(binding.dimension, (dim, queue) -> {
			if(queue == null) {
				queue = Lists.newArrayList();
			}
			queue.add(binding);
			return queue;
		});
	}

	@Override
	public void performQueue(World world) {
		List<BoundDiff> queue = queuedBindings.get(world.provider.getDimension());
		if(queue != null) {
			queue.forEach(diff -> {
				TileEntity t = world.getTileEntity(diff.pos);
				if(!(t instanceof IAstralBindableTile)) {
					AstralMod.log.warn("TileEntity " + t + "---" + diff.pos + " doesn't implement " + IAstralBindableTile.class + ", but was received from sync packet");
					return;
				}
				bind((IAstralBindableTile) t);
			});
		}
	}

	@Override
	public List<BoundDiff> getBoundDiff() {
		return immutableBoundDiffView;
	}

	@Override
	public void resetBoundDiff() {
		boundDiff.clear();
	}

	private void recalculateStorage() {
		int newCapacity = getBound().stream()
			.filter(b -> b instanceof IAstralEnergyStorer)
			.map(b -> (IAstralEnergyStorer) b)
			.map(s -> {
				AstralMod.log.info("Storer: " + s + ", en: " + s.getMaxStoredEnergy() + ", pos: " + s.getPos());
				return s.getMaxStoredEnergy();
			})
			.reduce((i, j) -> i + j)
			.orElse(0);
		energyStorage.setCapacity(newCapacity);
		energyStorage.setMaxTransfer(newCapacity);
	}

	@Override
	public void modifyEnergy(int mod) {
		energyDiff += mod;
		energyStorage.modifyEnergyStored(mod);
	}

	@Override
	public int getEnergyDiff() {
		return energyDiff;
	}

	@Override
	public void resetEnergyDiff() {
		energyDiff = 0;
	}

	@Nullable
	@Override
	public UUID getOwner() {
		return owner;
	}

	@Override
	public List<PlayerDiff> getPlayerDiff() {
		return immutablePlayerDiffView; //Unmodifiable set reflects all changes int base set
	}

	@Override
	public Set<UUID> getAccessedPlayers() {
		return immutableAccessedPlayersView; //Unmodifiable set reflects all changes int base set
	}

	@Override
	public boolean allowAccess(UUID player) {
		playerDiff.add(new PlayerDiff(player, true));
		boolean ret = accessedPlayers.add(player);
		if(ret) {
			MinecraftForge.EVENT_BUS.post(new AstralNetworkAccessGrantedEvent(this, player));
		}
		return ret;
	}

	@Override
	public boolean blockAccess(UUID player) {
		playerDiff.add(new PlayerDiff(player, false));
		boolean ret = accessedPlayers.remove(player);
		if(ret) {
			MinecraftForge.EVENT_BUS.post(new AstralNetworkAccessBlockedEvent(this, player));
		}
		return ret;
	}

	@Override
	public boolean hasAccess(EntityPlayer player) {
		return hasAccess(player.getGameProfile().getId());
	}

	@Override
	public boolean hasAccess(UUID player) {
		return accessedPlayers.contains(player);
	}

	@Override
	public void resetPlayerDiff() {
		playerDiff.clear();
	}

	@Override
	public int receiveEnergy(int maxReceive, boolean simulate) {
		int e = energyStorage.receiveEnergy(maxReceive, simulate);
		if(!simulate) {
			energyDiff += e;
		}
		return e;
	}

	@Override
	public int extractEnergy(int maxExtract, boolean simulate) {
		int e = energyStorage.extractEnergy(maxExtract, simulate);
		if(!simulate) {
			energyDiff -= maxExtract;
		}
		return e;
	}

	@Override
	public int getEnergyStored() {
		return energyStorage.getEnergyStored();
	}

	@Override
	public int getMaxEnergyStored() {
		return energyStorage.getMaxEnergyStored();
	}

	@Override
	public boolean canExtract() {
		return energyStorage.extractEnergy(1, true) == 1;
	}

	@Override
	public boolean canReceive() {
		return energyStorage.receiveEnergy(1, true) == 1;
	}
}