import random
import time
from fluepdot import Fluepdot, Mode
from dotenv import dotenv_values

from logging import getLogger, basicConfig

#from keys import KeyPoller
# replacement for own keypoller using pynput
from pynput import keyboard


def get_on_press(tetris):
    def on_press(key):
        if key == keyboard.Key.esc:
            tetris.running = False
            return False  # stop listener
        try:
            k = key.char
        except:
            k = key.name
        match k:
            case "q":
                tetris.rotate(True)
            case "e":
                tetris.rotate()
            case "a":
                tetris.shift(-1)
            case "d":
                tetris.shift(+1)
            case "space":
                tetris.drop()
            case _:
                print(f'Key pressed: {k}')

    return on_press


config = {
    "LOGLEVEL": 'INFO',
    "TERMINAL_OUT": "False",
    "DISPLAY": "True",
    **dotenv_values()
}

tout = config["TERMINAL_OUT"].lower() not in ['false', '0']
display_out = config["DISPLAY"].lower() not in ['false', '0']

log = getLogger("Fluedot-Tetris")
basicConfig(level=config["LOGLEVEL"].upper())
log.info(f'Fluepdot-Tetris loading with log level {config["LOGLEVEL"]}')
log.info(f'Terminal output is {"enabled" if tout else "disabled"}')

NUMS = [[[1, 1, 1], [1], [1, 1, 1], [1, 1, 1], [1, 0, 1], [1, 1, 1], [1, 1, 1], [1, 1, 1], [1, 1, 1], [1, 1, 1]],
        [[1, 0, 1], [1], [0, 0, 1], [0, 0, 1], [1, 0, 1], [1, 0, 0], [1, 0, 0], [0, 0, 1], [1, 0, 1], [1, 0, 1]],
        [[1, 0, 1], [1], [1, 1, 1], [1, 1, 1], [1, 1, 1], [1, 1, 1], [1, 1, 1], [0, 0, 1], [1, 1, 1], [1, 1, 1]],
        [[1, 0, 1], [1], [1, 0, 0], [0, 0, 1], [0, 0, 1], [0, 0, 1], [1, 0, 1], [0, 0, 1], [1, 0, 1], [0, 0, 1]],
        [[1, 1, 1], [1], [1, 1, 1], [1, 1, 1], [0, 0, 1], [1, 1, 1], [1, 1, 1], [0, 0, 1], [1, 1, 1], [1, 1, 1]]]

# Game settings
WIDTH = 16
HEIGHT = 45

# Define Tetris shapes
# TODO: Implement rotation like TETЯIS
SHAPES = [
    [[1, 1, 1, 1]],  # I Shape
    [[1, 1], [1, 1]],  # O Shape
    [[0, 1, 0], [1, 1, 1]],  # T Shape
    [[1, 1, 0], [0, 1, 1]],  # S Shape
    [[0, 1, 1], [1, 1, 0]],  # Z Shape
    [[1, 0, 0], [1, 1, 1]],  # L Shape
    [[0, 0, 1], [1, 1, 1]]  # J Shape
]


def _or(a, b):
    return a | b


def _and(a, b):
    return a & b


def _2d_boards_apply(board1, board2, func=_or):
    rows1, cols1 = len(board1), len(board1[0]) if board1 else 0
    rows2, cols2 = len(board2), len(board2[0]) if board2 else 0
    rows = max(rows1, rows2)
    cols = max(cols1, cols2)
    result = [[0] * cols for _ in range(rows)]
    for i in range(rows):
        for j in range(cols):
            value1 = board1[i][j] if i < rows1 and j < cols1 else 0
            value2 = board2[i][j] if i < rows2 and j < cols2 else 0
            result[i][j] = func(value1, value2)
    return result


class Tetris:
    def __init__(self, address):
        self.running = False
        self.fd = Fluepdot(address)
        if display_out:
            self.fd_size = self.fd.get_size()
        else:
            self.fd_size = [100, 16]
        log.debug(f"fluepdot size is {self.fd_size}")
        if display_out:
            self.fd.set_mode(Mode.DIFFERENTIAL)

        self.level = 0
        self.board = [[0] * WIDTH for _ in range(HEIGHT)]
        self.current_piece = None
        self.current_position = (0, 0)
        self.next_piece = random.choice(SHAPES)
        self.padding = None
        self.score = 0

    def get_score_board(self):
        sb = [[]] * 5
        num = self.score
        while num > 0:
            d = num % 10
            num //= 10
            for i in range(len(NUMS)):
                sb[i] = NUMS[i][d] + [0] + sb[i]
        return sb

    def get_padding(self):
        if HEIGHT < self.fd_size[0]:
            pad = self.fd_size[0] - HEIGHT - 1
            padding = [[0] * WIDTH] * pad + [[1] * WIDTH]
            if pad > 4:
                padding = _2d_boards_apply(padding, self.offset_piece(1, 1, self.next_piece))
            if pad > 10:
                sb = self.get_score_board()
                if len(sb[0]) <= 16:
                    padding = _2d_boards_apply(padding, self.offset_piece(WIDTH - len(sb[0]) - 1, 4, sb))
            self.padding = list(reversed(list(map(list, zip(*padding)))))
        else:
            self.padding = [[0] * WIDTH]

    def new_piece(self):
        self.current_piece = self.next_piece
        # NES Tetris randomizer
        #  (8 options, if equal to prev or reroll -> 7 options, final)
        self.next_piece = random.choice(SHAPES + [[]])
        if not self.next_piece or self.next_piece == self.current_piece:
            self.next_piece = random.choice(SHAPES)
        self.get_padding()
        self.current_position = (WIDTH // 2 - len(self.current_piece[0]) // 2, 0)

    def offset_piece(self, x, y, piece=None):
        if not piece:
            piece = self.current_piece
        piece = [[0] * x + l for l in piece]
        return [[0] * len(piece[0])] * y + piece

    def draw_board(self):
        piece = self.offset_piece(*self.current_position)
        board = _2d_boards_apply(piece, self.board)
        board = list(reversed(list(map(list, zip(*board)))))
        board = [p + f for p, f in zip(self.padding, board)]
        if display_out:
            self.fd.post_frame([[v == 1 for v in l] for l in board])
        if tout:
            for l in board:
                print("." + "".join(['X' if x else ' ' for x in l]) + ".")
            print('')

    def rotate(self, reversed_=False):
        for l in self.current_piece:
            log.debug(l)
        if reversed_:
            direction = "counter clockwise"
            self.current_piece = list(reversed(list(map(list, zip(*self.current_piece)))))
        else:
            direction = "clockwise"
            self.current_piece = list(map(list, map(reversed, list(map(list, zip(*self.current_piece))))))
        log.debug(f"Rotate piece {direction}.")

    def shift(self, direction: int = 0) -> bool:
        x, y = self.current_position
        max_x = WIDTH - len(self.current_piece[0])
        x = max(0, min(max_x, x + direction))
        log.debug(f"Shifting the piece {'left' if direction == -1 else 'right'}. {direction}")
        if not self.collide((x, y)):
            self.current_position = (x, y)
            return True
        return False

    def drop(self):
        log.debug(f"Dropping the piece.")
        x, y = self.current_position
        oy = y
        y_offset = HEIGHT - y + 1
        while not (self.collide(pos=(x, y + y_offset)) and not self.collide(pos=(x, y + y_offset - 1))):
            log.debug(f"{y_offset=}, {y + y_offset}")
            if self.collide(pos=(x, y + y_offset)):
                y_offset //= 2
            else:
                y += y_offset // 2
        log.debug(f"Found the drop offset.")
        self.current_position = (x, y + y_offset)
        self.score += y + y_offset - oy  # TODO: softdrop 1 point for each cell, harddrop 2
        self.step()

    def step(self):
        log.debug(f"Runing a step.")
        if self.collide():
            if self.current_position[1] == 0:
                return False
            self.board = _2d_boards_apply(self.board, self.offset_piece(*self.current_position))
            self.clears()
            self.new_piece()
        else:
            self.current_position = (self.current_position[0], self.current_position[1] + 1)
        return True

    def collide(self, pos=None):
        if not pos:
            x, y = self.current_position
        else:
            x, y = pos
        y += 1
        piece = self.offset_piece(x, y)
        if y + len(self.current_piece) > HEIGHT:
            return True
        board = _2d_boards_apply(piece, self.board, _and)
        return any(map(any, board))

    def clears(self):
        rows = sum(all(l) for l in self.board)
        if rows > 0:
            self.score += [40, 100, 300, 1200][rows - 1] * (self.level + 1)
            self.board = [[0] * WIDTH] * rows + [l for l in self.board if not all(l)]

    def end_game(self):
        log.info(f"Game ended. Score: {self.score}")
        if display_out:
            self.fd.set_mode(Mode.FULL)
            self.fd.post_text(f"Score: {self.score}")

    def run(self):
        self.new_piece()
        #log.debug(self.current_piece)
        self.running = True
        listener = keyboard.Listener(on_press=get_on_press(self))
        listener.start()
        while self.running:
            self.running = self.step()
            self.draw_board()
            time.sleep(.5)  # Game loop delay
        self.end_game()


if __name__ == "__main__":
    log.info(f'Connecting to fluepdot at {config["DOTS_HOST"]}')
    game = Tetris(config["DOTS_HOST"])
    game.run()