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 GatherSandStates:
    def bair(self, p):
        return self.g.chunks.get_block_at(*p) in blocks.NON_SOLID_IDS

    def bsand(self, p):
        return self.g.chunks.get_block_at(*p) == blocks.SAND

    def idle(self):
        return None

    def init(self):
        self.state = self.select_shovel

    def select_shovel(self):
        self.g.game.select_item(items.SHOVEL_IDS)
        self.state = self.find_new_slice

    def find_new_slice(self):
        print('Finding new slice...')
        w = self.g.world

        print('using origin', self.origin)
        start = time.time()
        self.prev_layer, s = w.find_sand_slice(self.origin, 200, 10, self.bad_slices, self.prev_layer)
        print('Found slice:', s, 'in', time.time() - start, 'seconds')

        if s:
            self.slice = s
            self.bad_slices.append(s)
            self.state = self.find_new_sand
        else:
            print('No slices remaining.')
            self.state = self.cleanup

    def find_new_sand(self):
        print('Finding new sand...')
        w = self.g.world
        p = utils.pint(self.g.pos)
        head = utils.padd(p, path.BLOCK_ABOVE)

        for sand in w.find_sand(self.slice, 2, p):
            if sand not in self.bad_sand:
                print('Found sand:', sand)
                break
        else: # for
            print('No good sands left, aborting.')
            self.state = self.cleanup
            return

        self.sand = sand

        if utils.phyp(head, self.sand) < blocks.BREAK_DISTANCE:
            self.state = self.dig_sand
        else:
            self.state = self.nav_to_sand

    def nav_to_sand(self):
        w = self.g.world
        p = utils.pint(self.g.pos)
        c = self.g.chunks

        tmp = c.get_block_at(*self.sand)
        c.set_block_at(*self.sand, blocks.AIR)
        navpath = w.path_to_place(p, self.sand)
        c.set_block_at(*self.sand, tmp)

        if navpath:
            self.g.path = navpath[:-1]
            self.state = self.going_to_sand
        else:
            print('Cant get to that sand')
            self.bad_sand.append(self.sand)
            self.state = self.find_new_sand

    def going_to_sand(self):
        if not len(self.g.path):
            self.g.look_at = self.sand
            self.state = self.dig_sand

    def dig_sand(self):
        if not self.g.breaking:
            if self.bsand(self.sand):
                self.g.look_at = self.sand
                self.g.game.break_block(self.sand)
                print('digging sand')
            else:
                self.state = self.find_new_sand

    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.origin = utils.pint(self.g.pos)
        self.origin = (2019, 64, 238)
        self.slice = None
        self.bad_slices = []
        self.prev_layer = 0
        self.sand = None
        self.bad_sand = []
        self.wait_time = 0

    def run(self):
        self.state()