import re
import time
import importlib
import random
from itertools import count
from math import hypot, floor

from minecraft.networking.types import BlockFace

from protocol.managers import ChunkNotLoadedException

import utils
importlib.reload(utils)
import path
importlib.reload(path)
import blocks
importlib.reload(blocks)
import items
importlib.reload(items)
import mcdata
importlib.reload(mcdata)
import mobs
importlib.reload(mobs)

class GrabSandStates:
    def idle(self):
        return None

    def init(self):
        self.state = self.find_sand
        print('Trying to grab sand')

    def find_sand(self):
        w = self.g.world
        p = utils.pint(self.g.pos)

        sand = w.find_objects([items.SAND_ID])

        if not sand:
            print('No sand objects found, aborting')
            self.state = self.cleanup
            return

        sand.sort(key=lambda s: utils.phyp(p, (s.x, s.y, s.z)))

        for s in sand:
            s_pos = utils.pint((s.x, s.y, s.z))
            check = utils.padd(s_pos, path.BLOCK_BELOW)

            if utils.phyp(p, s_pos) > 6:
                continue
            # skip if the sand is floating
            if self.g.chunks.get_block_at(*check) in {0}:
                continue
            if s.entity_id in self.eid_blacklist:
                continue

            self.eid_blacklist.append(s.entity_id)

            navpath = w.path_to_place(p, s_pos)

            if navpath:
                self.g.path = navpath
                self.state = self.going_to_sand
                self.sand = s_pos
                print('Going to sand', self.sand)
                return
            else:
                print('Cant get to sand', self.sand)

        print('Cant get to any more sand, aborting')
        self.state = self.cleanup

    def going_to_sand(self):
        if utils.pint(self.g.pos) == self.sand:
            self.state = self.cleanup

    def cleanup(self):
        self.g.look_at = None
        self.state = self.done

    def done(self):
        # never gets ran, placeholder
        return None

    def __init__(self, global_state):
        self.g = global_state
        self.state = self.idle

        self.sand = None
        self.eid_blacklist = []

    def run(self):
        self.state()