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 CheckThreatsStates:
    def idle(self):
        return None

    def init(self):
        self.state = self.find_threats
        print('Checking for threats')

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

        threats = w.find_threats(p, 40)

        if threats:
            print('Found', len(threats), 'threats, fleeing:')
            print(threats)
            self.state = self.find_safety
        else:
            print('Aborting, no threats')
            self.state = self.cleanup

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

        safety = w.find_blocks_indexed(p, [blocks.EMERALD_BLOCK])

        if not safety:
            print('No emerald blocks found, aborting')
            self.state = self.cleanup
            return

        safety.sort(key=lambda s: utils.phyp(p, s))
        print('Found emerald blocks:', safety)

        for s in safety:
            s = utils.padd(s, path.BLOCK_ABOVE)
            navpath = w.path_to_place(p, s)

            if navpath:
                self.g.path = navpath
                self.state = self.going_to_safety
                self.safety = s
                print('Going to safety', self.safety)
                return
            else:
                print('Cant get to safety', self.safety)

        print('Cant get to safety, aborting')
        self.state = self.cleanup

    def going_to_safety(self):
        if utils.pint(self.g.pos) == self.safety:
            print('At safety spot, waiting to be moved')
            self.state = self.wait_for_move

    def wait_for_move(self):
        # wait for the server to move the bot when it's safe
        # ie. a piston + daylight sensor
        if utils.pint(self.g.pos) != self.safety:
            print('Moved, resuming job')
            self.state = self.wait
            self.wait_time = 3

    def wait(self):
        # wait to land, etc
        if self.wait_time > 0:
            self.wait_time -= utils.TICK
        else:
            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.safety = None
        self.wait_time = 0

    def run(self):
        self.state()