import time
from Empty import Empty
from Finding_fields import Finding_fields
from Moving_truck import Moving_truck
from Package_types import Package_types
from Packages_spawner import Packages_spawner
from Shelf import Shelf
import pygame
import random
from Grid import Grid
from Truck import Truck
from Global_variables import Global_variables as G_var
from Sectors_types import Sectors_types
from decision_tree.Decision_tree import DecisionTree

from Astar import Pathfinding, State


class Environment:
    def __init__(self, window):
        self.window = window
        self.grid = Grid(window)
        self.initialize_eviroment_2d()
        self.add_shelfs_to_enviroment_2d()
        # TEST CREATE PACKAGE
        self.package_spawner = Packages_spawner(window, self.enviroment_2d)
        self.package_spawner.spawn_package()
        new_truck = Truck(window, 14, 7)
        self.enviroment_2d[14][7] = new_truck
        self.truck = new_truck
        self.moving_truck = Moving_truck(
            self.window, self.enviroment_2d, self.truck, self.package_spawner)
        self.astar = Pathfinding(self.enviroment_2d)
        self.finding_fields = Finding_fields(self.enviroment_2d)
        self.weekend = random.randint(0, 1)

    def draw_all_elements(self):
        for row in self.enviroment_2d:
            for field in row:
                field.draw()
        self.grid.draw_grid()
        # self.astar.draw_path(self.window)
        pygame.display.flip()
        
    def update_all_elements(self):
        self.use_astar()    # wywyoływanie za każdym razem astar jest bardzo zasobożerne. Lepiej raz na przejście
        self.update_truck()
        # time.sleep(0.5)

    # def use_decision_tree(self):
    #     marking = self.package.type
    #     if marking == Package_types.fragile:
    #         marking = 0
    #     elif marking == Package_types.priority:
    #         marking = 1
    #     tree = DecisionTree(marking, self.weekend, self.package.company.popularity,
    #                         self.package.company.payment_delay, self.package.payed_upfront,
    #                         self.package.company.shipping_type)
    #     decision = tree.decision
    #     return decision

    def use_astar(self):
        start_state = State(1,self.truck.x,self.truck.y) # sprawić aby paczka i shelf były wyszukiwane raz
        if self.truck.has_package:
            end_position = self.finding_fields.find_closest_shelf(self.truck, self.truck.package_type,
                                                                  self.truck.sector)
        else:
            end_position = self.finding_fields.find_package()
        end_state = State(1,end_position.x, end_position.y)
        self.astar.find_path(start_state,end_state)
    
    def update_truck(self):
        next_field_to_move = self.astar.path[0].state
        next_field_x = next_field_to_move.x - self.truck.x
        next_field_y = next_field_to_move.y - self.truck.y
        self.moving_truck.move(next_field_x,next_field_y)

    # def gen_shelf_type(self):
    #     shelve_types = list(Package_types)
    #     while True:
    #         yield random.choice(shelve_types)
    def gen__sectors(self):
        sectors = [Sectors_types.normal, Sectors_types.shipping_tomorrow, Sectors_types.shipping_today]
        while True:
            yield random.choice(sectors)

    def initialize_eviroment_2d(self):
        self.enviroment_2d = [[
            Empty(self.window, j, i)
            for i in range(G_var().DIMENSION_Y)]
            for j in range(G_var().DIMENSION_X)
        ]

    def add_shelfs_to_enviroment_2d(self):
        shelf_2_offset = 9
        avaiable_sectors = self.gen__sectors()
        for x in range(8, 22, 3):
            type_of_new_shelf = Package_types.priority
            sector_of_new_shelf1 = next(avaiable_sectors)
            # print(sector_of_new_shelf1)
            sector_of_new_shelf2 = next(avaiable_sectors)
            # print(sector_of_new_shelf2)
            for y in range(0, 6):
                self.enviroment_2d[x][y] = Shelf(
                    self.window, x, y, type_of_new_shelf, sector_of_new_shelf1
                )
                self.enviroment_2d[x][y + shelf_2_offset] = Shelf(
                    self.window, x, (y + shelf_2_offset), type_of_new_shelf, sector_of_new_shelf2
                )

        for x in range(2, 7, 3):
            type_of_new_shelf = Package_types.fragile
            sector_of_new_shelf = Sectors_types.fragile
            for y in range(0, 6):
                self.enviroment_2d[x][y] = Shelf(
                    self.window, x, y, type_of_new_shelf, sector_of_new_shelf
                )
                self.enviroment_2d[x][y + shelf_2_offset] = Shelf(
                    self.window, x, (y + shelf_2_offset), type_of_new_shelf, sector_of_new_shelf
                )