import random
import numpy as np
import pygame

from common.constants import ROWS, COLUMNS, GRID_CELL_PADDING, GRID_CELL_WIDTH, GRID_CELL_HEIGHT, BORDER_WIDTH, \
    BORDER_RADIUS, NBR_OF_TREES, NBR_OF_WATER
from .exceptions import FieldNotWalkable
from .field import Field


class Grid:
    def __init__(self, textures):
        self.textures = textures
        self.grid = []
        self.free_fields = []
        self.busy_fields = []
        podkladka = np.zeros((ROWS, COLUMNS))
        for drzewa in range(0, NBR_OF_TREES):
            rzad = random.randint(0, ROWS - 1)
            kolumna = random.randint(0, COLUMNS - 1)
            if podkladka[rzad][kolumna] == 0:
                podkladka[rzad][kolumna] = 1
            else:
                drzewa = drzewa - 1
        for i in range(0, NBR_OF_WATER):
            rzad = random.randint(0, ROWS - 1)
            kolumna = random.randint(0, COLUMNS - 1)
            if podkladka[rzad][kolumna] == 0:
                podkladka[rzad][kolumna] = 2
            else:
                drzewa = drzewa - 1

        for row in range(ROWS):
            self.grid.append([])
            for column in range(COLUMNS):
                box_rect = [(GRID_CELL_PADDING + GRID_CELL_WIDTH) * column + GRID_CELL_PADDING + 7,
                            (GRID_CELL_PADDING + GRID_CELL_HEIGHT) * row + GRID_CELL_PADDING + 7,
                            GRID_CELL_WIDTH,
                            GRID_CELL_HEIGHT]
                if podkladka[row][column] == 1:
                    texture_path, converted_texture = self.textures[-1]
                elif podkladka[row][column] == 2:
                    texture_path, converted_texture = self.textures[-2]
                else:
                    texture_path, converted_texture = self.get_random_texture()
                field = Field(
                    texture_path,
                    converted_texture,
                    pygame.transform.scale(converted_texture,
                                           (GRID_CELL_WIDTH,
                                            GRID_CELL_HEIGHT)),
                    pygame.Rect(box_rect),
                    row=row,
                    column=column
                )
                if field.busy:
                    self.busy_fields.append(field)
                else:
                    self.free_fields.append(field)

                self.grid[row].append(pygame.sprite.Group(field))

    def update(self, screen):
        self.draw(screen)

    def get_random_texture(self):
        texture_index = random.randint(0, len(self.textures) - 3)
        return self.textures[texture_index]

    def get_tile(self, row, column):
        return pygame.sprite.Group.sprites(self.grid[row][column])[0]  # iteruj kolumny i wiersze od 0

    def put_on_tile(self, row, column, obj):  # iteruj kolumny i wiersze od 0
        try:
            self.get_tile(row, column).put_on(obj)
        except FieldNotWalkable:
            print("Field busy")

    def draw(self, screen):
        bg_width = (GRID_CELL_PADDING + GRID_CELL_WIDTH) * COLUMNS + BORDER_WIDTH
        bg_height = (GRID_CELL_PADDING + GRID_CELL_HEIGHT) * ROWS + BORDER_WIDTH
        pygame.draw.rect(screen, (255, 255, 255), pygame.Rect(5, 5, bg_width, bg_height), 0, BORDER_RADIUS)

        for fields_row in self.grid:
            for fields in fields_row:
                fields.draw(screen)