package net.shadowfacts.phycon.block.cable

import net.minecraft.block.*
import net.minecraft.block.piston.PistonBehavior
import net.minecraft.entity.player.PlayerEntity
import net.minecraft.item.ItemPlacementContext
import net.minecraft.state.StateManager
import net.minecraft.state.property.EnumProperty
import net.minecraft.util.ActionResult
import net.minecraft.util.Hand
import net.minecraft.util.Identifier
import net.minecraft.util.hit.BlockHitResult
import net.minecraft.util.math.BlockPos
import net.minecraft.util.math.Direction
import net.minecraft.util.math.Vec3d
import net.minecraft.util.shape.VoxelShape
import net.minecraft.util.shape.VoxelShapes
import net.minecraft.world.BlockView
import net.minecraft.world.World
import net.minecraft.world.WorldAccess
import net.shadowfacts.phycon.PhysicalConnectivity
import net.shadowfacts.phycon.api.Interface
import net.shadowfacts.phycon.api.NetworkCableBlock
import net.shadowfacts.phycon.api.NetworkComponentBlock
import net.shadowfacts.phycon.init.PhyItems
import net.shadowfacts.phycon.util.CableConnection
import java.util.*

/**
 * @author shadowfacts
 */
class CableBlock: Block(
	Settings.of(CABLE_MATERIAL)
		.strength(1f)
		.nonOpaque()
), NetworkCableBlock {
	companion object {
		val ID = Identifier(PhysicalConnectivity.MODID, "cable")
		val CABLE_MATERIAL = Material(MaterialColor.IRON, false, false, true, false, true, false, PistonBehavior.NORMAL)
		val CENTER_SHAPE = createCuboidShape(6.0, 6.0, 6.0, 10.0, 10.0, 10.0)
		val SIDE_SHAPES = mapOf<Direction, VoxelShape>(
				Direction.DOWN to createCuboidShape(6.0, 0.0, 6.0, 10.0, 6.0, 10.0),
				Direction.UP to createCuboidShape(6.0, 10.0, 6.0, 10.0, 16.0, 10.0),
				Direction.NORTH to createCuboidShape(6.0, 6.0, 0.0, 10.0, 10.0, 6.0),
				Direction.SOUTH to createCuboidShape(6.0, 6.0, 10.0, 10.0, 10.0, 16.0),
				Direction.WEST to createCuboidShape(0.0, 6.0, 6.0, 6.0, 10.0, 10.0),
				Direction.EAST to createCuboidShape(10.0, 6.0, 6.0, 16.0, 10.0, 10.0)
		)
		private val SHAPE_CACHE = mutableMapOf<BlockState, VoxelShape>()
		val CONNECTIONS: Map<Direction, EnumProperty<CableConnection>> = Direction.values().associate { it to EnumProperty.of(it.name.toLowerCase(), CableConnection::class.java) }

		fun getShape(state: BlockState): VoxelShape {
			return SHAPE_CACHE.getOrPut(state) {
				var shape = CENTER_SHAPE
				for ((side, prop) in CONNECTIONS) {
					if (state[prop] == CableConnection.ON) {
						shape = VoxelShapes.union(shape, SIDE_SHAPES[side])
					}
				}
				return shape
			}
		}
	}

	init {
		defaultState = CONNECTIONS.values.fold(stateManager.defaultState) { acc, prop ->
			acc.with(prop, CableConnection.OFF)
		}
	}

	override fun getNetworkConnectedSides(state: BlockState, world: WorldAccess, pos: BlockPos): Collection<Direction> {
		val set = EnumSet.noneOf(Direction::class.java)
		for ((side, prop) in CONNECTIONS) {
			if (state[prop] == CableConnection.ON) {
				set.add(side)
			}
		}
		return set
	}

	override fun appendProperties(builder: StateManager.Builder<Block, BlockState>) {
		super.appendProperties(builder)
		CONNECTIONS.values.forEach {
			builder.add(it)
		}
	}

	override fun getPlacementState(context: ItemPlacementContext): BlockState {
		return CONNECTIONS.entries.fold(defaultState, { acc, (dir, prop) ->
			acc.with(prop, getConnectionStateInDirection(context.world, context.blockPos, dir))
		})
	}

	override fun getStateForNeighborUpdate(state: BlockState, side: Direction, neighborState: BlockState, world: WorldAccess, blockPos_1: BlockPos, blockPos_2: BlockPos): BlockState {
		val prop = CONNECTIONS[side]
		val current = state[prop]
		return when (current) {
			CableConnection.DISABLED -> state
			else -> state.with(prop, getConnectionStateInDirection(world, blockPos_1, side))
		}
	}

	private fun getConnectionStateInDirection(world: WorldAccess, pos: BlockPos, direction: Direction): CableConnection {
		val offsetPos = pos.offset(direction)
		val state = world.getBlockState(offsetPos)
		val block = state.block
		return when (block) {
			this -> {
				val prop = CONNECTIONS[direction.opposite]
				when (state[prop]) {
					CableConnection.DISABLED -> CableConnection.DISABLED
					else -> CableConnection.ON
				}
			}
			is NetworkComponentBlock -> {
				if (block.getNetworkConnectedSides(state, world, offsetPos).contains(direction.opposite)) {
					CableConnection.ON
				} else {
					CableConnection.OFF
				}
			}
			else -> CableConnection.OFF
		}
	}

	override fun getNetworkInterfaceForSide(side: Direction, state: BlockState, world: WorldAccess, pos: BlockPos): Interface? {
		// cables don't have network interfaces
		return null
	}

	override fun onUse(
		state: BlockState,
		world: World,
		pos: BlockPos,
		player: PlayerEntity,
		hand: Hand,
		hitResult: BlockHitResult
	): ActionResult {
		if (player.getStackInHand(hand).item == PhyItems.SCREWDRIVER) {
			val hitPos = Vec3d(hitResult.pos.x - pos.x, hitResult.pos.y - pos.y, hitResult.pos.z - pos.z)
			val hitConnection = SIDE_SHAPES.entries.firstOrNull { (_, shape) ->
				val box = shape.boundingBox
				hitPos.x >= box.minX && hitPos.x <= box.maxX && hitPos.y >= box.minY && hitPos.y <= box.maxY && hitPos.z >= box.minZ && hitPos.z <= box.maxZ
			}
			if (hitConnection != null) {
				val side = hitConnection.key
				val prop = CONNECTIONS[side]
				val newState = when (state[prop]) {
					CableConnection.DISABLED -> {
						// if the block this cable is connecting to on the side that will be re-enabled is a cable that
						// is disabled on the side that connects it to us, we also re-enable that cable to make sure both
						// "halves" of the connection are in the same state
						val connectedToPos = pos.offset(side)
						val connectedTo = world.getBlockState(connectedToPos)
						if (connectedTo.block == this && connectedTo[CONNECTIONS[side.opposite]] == CableConnection.DISABLED) {
							world.setBlockState(connectedToPos, connectedTo.with(CONNECTIONS[side.opposite], CableConnection.ON))
						}

						state.with(prop, if (connectedTo.block is NetworkComponentBlock) CableConnection.ON else CableConnection.OFF)
					}
					else -> state.with(prop, CableConnection.DISABLED)
				}
				world.setBlockState(pos, newState)
			}
			return ActionResult.SUCCESS
		}
		return ActionResult.PASS
	}

	override fun isTranslucent(blockState_1: BlockState?, blockView_1: BlockView?, blockPos_1: BlockPos?): Boolean {
		return true
	}

//	override fun isSimpleFullBlock(blockState_1: BlockState?, blockView_1: BlockView?, blockPos_1: BlockPos?): Boolean {
//		return false
//	}

	override fun getOutlineShape(state: BlockState, world: BlockView, pos: BlockPos, context: ShapeContext): VoxelShape {
		return getShape(state)
	}

}