import arcade
import json
import math
import random
from fill_level import filler

SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600

class food():
    def __init__(self, x, y, healf = 1):
        self.x = x
        self.y = y
        self.healf = healf
    
class body():
    def __init__(self, x, y, rotate, type):
        self.x = x
        self.y = y
        self.rotate = rotate
        self.type = type
    
class SNAKE():
    def __init__(self, star_point_x, star_point_y, start_rotate = 90):
        self.body = [
            body(star_point_x, star_point_y, start_rotate, "head"),
            body(star_point_x - 1, star_point_y, start_rotate, "tail")
        ]
    def check_contact(self,x,y):
        cont = 0
        for body in self.body:
            if body.x == x and body.y == y:
                cont = 1
        return cont
    def add_dody(self):
        self.body[len(self.body)-1].type = "body"
        last_body = self.body[len(self.body)-1]
        new_body = body(0,0, last_body.rotate, "tail")
        v_x = int(-math.sin(-last_body.rotate * math.pi / 180))
        new_body.x = -v_x + last_body.x
        v_y = int(math.cos(-last_body.rotate * math.pi / 180))
        new_body.y = -v_y + last_body.y
        self.body.append(new_body)

    def move(self, vector):
        self.body[0].rotate = vector * 90
        i = len(self.body)-1
        while i > 0:
            if self.body[i].type == "body" or self.body[i].type == "tail":
                self.body[i].x = self.body[i-1].x
                self.body[i].y = self.body[i-1].y
                self.body[i].rotate = self.body[i-1].rotate 
            i = i - 1
            
        self.body[0].x = int(-math.sin(-self.body[0].rotate * math.pi / 180)) + self.body[0].x
        self.body[0].y = int(math.cos(-self.body[0].rotate * math.pi / 180)) + self.body[0].y

        # print(f"Move {vector}")

class Level_data():
    def __init__(self, level_data_json = []):
        if level_data_json:
            self.fill_grid(level_data_json)

    def fill_grid(self, level_data_json):
        self.name = level_data_json["name"]
        self.floor = level_data_json["floor"]
        self.size = level_data_json["size"]
        self.enemy_types = level_data_json["enemy_types"]
        self.enemy_spawns  = level_data_json["enemy_spawns"]
        self.start_point = level_data_json["start_point"]

class MYGAME(arcade.Window):
    Sprites = []

    def __init__(self, width, height):
        super().__init__(width, height)
        arcade.set_background_color(arcade.color.AMAZON)
    
    def setup(self, level_name):
       
        print(f"Upload level: {level_name}")
        
        with open(f'./DATA/Levels/{level_name}/data.json', 'r') as file:
            self.Lvl_data = Level_data(json.load(file))

        if self.Lvl_data.name : 
            print(f"{self.Lvl_data.name} loaded")
        else:
            print("Error to load level")
        
        self.player_list = arcade.SpriteList()
        self.floor_list = arcade.SpriteList()
        
        self.enemies_list = arcade.SpriteList()
        self.enemy_spawn = arcade.SpriteList()

        grid = fill_empty_grid()
        self.floor_grid = self.arr2grid(self.Lvl_data.floor, grid)
        self.print_grid(self.floor_grid)
        self.snake = SNAKE(self.Lvl_data.start_point["x"], self.Lvl_data.start_point["y"])

        # food
        self.food_list = arcade.SpriteList()
        self.food_sleep = 300
        self.delay = 400
        self.food = []
        # Счет
        self.score = 0
        self.scale_ = 1.3

        screen_center = [SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2]
        self.level_start = [screen_center[0] - self.Lvl_data.size[0] * 16 * self.scale_, screen_center[1] - self.Lvl_data.size[1] * 16 * self.scale_]
        
        # Загрузка змеи
        for body in self.snake.body:
            snake_sprite = arcade.Sprite(f"./DATA/Sprites/Snake/{body.type}.png", self.scale_)
            snake_sprite.angle = 90
            snake_sprite.center_x = self.level_start[0] - 16 + ( body.x + 1 ) * 32 * self.scale_
            snake_sprite.center_y = self.level_start[1] - 16 + ( body.y + 1 ) * 32 * self.scale_
            self.player_list.append(snake_sprite)

        # Загрузка пола
        for floor in self.Lvl_data.floor:
            floor_sprite = arcade.Sprite(floor["sprite"], self.scale_)
            floor_sprite.center_x = self.level_start[0] - 16 + ( floor["x"] + 1 ) * 32 * self.scale_
            floor_sprite.center_y = self.level_start[1] - 16 + ( floor["y"] + 1 ) * 32 * self.scale_
            self.floor_list.append(floor_sprite)
        
        # Загрузка врагов
        # if "enemies" in self.level_data:
        #     for enemy in self.level_data["enemies"]:
        #         enemy_sprite = arcade.Sprite(enemy["sprite"], 1)
        #         enemy_sprite.center_x = self.level_start[0] - 16 + ( enemy["x"] + 1 ) * 32 * self.scale_
        #         enemy_sprite.center_y = self.level_start[0] - 16 + ( enemy["y"] + 1 ) * 32 * self.scale_
        #         self.enemies_list.append(enemy_sprite)
    def spawn_food(self):
        spawn = False
        while spawn == False:
            x = random.randint(0, 14)
            y = random.randint(0, 14)
            if self.floor_grid[y][x] == 1 and not(self.snake.check_contact(x,y)):
                self.food.append(food(x,y))
                food_sprite = arcade.Sprite(f"./DATA/Sprites/Enemies/Tier 0/healthy_food.png", self.scale_)
                food_sprite.angle = 0
                food_sprite.center_x = self.level_start[0] - 16 + ( x + 1 ) * 32 * self.scale_
                food_sprite.center_y = self.level_start[1] - 16 + ( y + 1 ) * 32 * self.scale_
                self.food_list.append(food_sprite)
                spawn = True

    def update(self):
        if len(self.snake.body) > 0:
            i = 0
            while i < len(self.snake.body):
                self.player_list[i] = arcade.Sprite(f"./DATA/Sprites/Snake/{self.snake.body[i].type}.png", self.scale_)
                self.player_list[i].angle = self.snake.body[i].rotate
                self.player_list[i].center_x = self.level_start[0] - 16 + ( self.snake.body[i].x + 1 ) * 32 * self.scale_
                self.player_list[i].center_y = self.level_start[1] - 16 + ( self.snake.body[i].y + 1 ) * 32 * self.scale_
                i = i + 1
        # Food
        self.food_sleep -= 1
        if self.food_sleep <= 0:
            self.spawn_food()
            self.food_sleep = self.delay
        i = 0
        while i < len(self.food_list):
            if self.snake.check_contact(self.food[i].x, self.food[i].y):
                self.food_list[i].kill()
                self.food.pop(i)
                self.score += 1
                self.snake.add_dody()
                self.player_list.append(arcade.Sprite())
            i += 1
        # Enemy_spawn
        for spawn in self.Lvl_data.enemy_spawns[0]:
            spawn["sleep"] -= 1
            if spawn["sleep"] <= 0:
                spawn["sleep"] = spawn["delay"]
                self.spawn_enemy(spawn["y"], spawn["x"], spawn["tier"])

    def spawn_enemy(self, y, x, tier):
        type = random.randint(0, len(self.Lvl_data.enemy_types[tier-1]))
        print_spawn("tier: " + str(type), x, y)


    def print_grid(self, grid):
        x = 0 
        y = 14
        print_ = ''
        while y >= 0:
            while x < 15:
                print_ += "  " if grid[y][x] == 0 else "1 "
                x += 1 
            print(print_)
            print_ = ''
            y -= 1
            x = 0


    def arr2grid(self, arr, grid):
        for point in arr:
            grid[point["y"]][point["x"]] = 1
        return grid
    
    # Обработка нажатий
    MOVEMENT_SPEED = 1

    def on_key_press(self, key, modifiers):
        """Вызывается при нажатии пользователем клавиши"""

        # Get the first sprite (head) from the player list
        if len(self.player_list) > 0:
            
            if key in (arcade.key.UP, arcade.key.W):
                if self.floor_grid[self.snake.body[0].y + 1][self.snake.body[0].x] == 1 and self.snake.body[0].rotate != 180 and not(self.snake.check_contact(self.snake.body[0].x ,self.snake.body[0].y+1)):   
                    self.snake.move(0)
                
            elif key in (arcade.key.DOWN, arcade.key.S):
                if self.floor_grid[self.snake.body[0].y - 1][self.snake.body[0].x] == 1 and self.snake.body[0].rotate != 0 and not(self.snake.check_contact(self.snake.body[0].x ,self.snake.body[0].y-1)):   
                    self.snake.move(2)

            elif key in (arcade.key.LEFT, arcade.key.A):
                if self.floor_grid[self.snake.body[0].y][self.snake.body[0].x - 1] == 1 and self.snake.body[0].rotate != 90 and not(self.snake.check_contact(self.snake.body[0].x - 1,self.snake.body[0].y)):   
                    self.snake.move(3)

            elif key in (arcade.key.RIGHT, arcade.key.D):
                if self.floor_grid[self.snake.body[0].y][self.snake.body[0].x + 1] == 1 and self.snake.body[0].rotate != 270 and not(self.snake.check_contact(self.snake.body[0].x + 1,self.snake.body[0].y)):   
                    self.snake.move(1)

    def on_key_release(self, key, modifiers):
        """Вызывается, когда пользователь отпускает клавишу"""
        if len(self.player_list) > 0:
            self.player_sprite = self.player_list[0]
            
            if key in (arcade.key.UP, arcade.key.DOWN, arcade.key.W, arcade.key.S):
                self.player_sprite.change_y = 0
            elif key in (arcade.key.LEFT, arcade.key.RIGHT, arcade.key.A, arcade.key.D):
                self.player_sprite.change_x = 0
    def on_draw(self):
        self.update()
        # Очищаем экран перед каждой отрисовкой
        self.clear()
        # Отрисовываем все спрайты
        self.floor_list.draw()
        self.enemies_list.draw()
        self.food_list.draw()
        self.player_list.draw()

def print_spawn(who, x, y):
    print(f"Spawn: {who}\nx: {x}\ny: {y}")

def fill_empty_grid():
    grid = []
    y = 0
    x = 0
    while y < 15:
        grid.append([])
        while x < 15:
            grid[y].append([x])
            grid[y][x] = 0
            x = x + 1
        y = y + 1
        x = 0
    return grid

def main():
    filler_ = filler("Default")
    filler_.fill_level(filler_.floor_code)
    filler_.export2json()

    game = MYGAME(SCREEN_WIDTH, SCREEN_HEIGHT)
    game.setup( "Default" )
    arcade.run()

if __name__ == "__main__":
    main()