# Copyright (C) 2020-2021 by ÿnérant, eichhornchen, nicomarg, charlse
# SPDX-License-Identifier: GPL-3.0-or-later

import curses

from .display import Display
from ..entities.items import Monocle
from ..entities.player import Player
from ..game import Game
from ..interfaces import FightingEntity
from ..translations import gettext as _


class StatsDisplay(Display):
    """
    A class to handle the display of the stats of the player.
    """
    game: Game
    player: Player

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.pad = self.newpad(self.rows, self.cols)

    def update(self, game: Game) -> None:
        self.game = game
        self.player = game.player

    def update_pad(self) -> None:
        string2 = f"{_(self.player.name).capitalize()} " \
                  f"-- LVL {self.player.level} -- " \
                  f"FLOOR {-self.player.map.floor}\n" \
                  f"EXP {self.player.current_xp}/{self.player.max_xp}\n" \
                  f"HP {self.player.health}/{self.player.maxhealth}"
        self.addstr(self.pad, 0, 0, string2)
        string3 = f"STR {self.player.strength}\n" \
                  f"INT {self.player.intelligence}\n" \
                  f"CHR {self.player.charisma}\n" \
                  f"DEX {self.player.dexterity}\n" \
                  f"CON {self.player.constitution}\n" \
                  f"CRI {self.player.critical}%"
        self.addstr(self.pad, 3, 0, string3)

        inventory_str = _("Inventory:") + " "
        # Stack items by type instead of displaying each item
        item_types = [item.name for item in self.player.inventory]
        item_types.sort(key=item_types.count, reverse=True)
        printed_items = []
        for item in item_types:
            if item in printed_items:
                continue
            count = item_types.count(item)
            inventory_str += self.pack[item.upper()]
            if count > 1:
                inventory_str += f"x{count} "
            printed_items.append(item)
        self.addstr(self.pad, 9, 0, inventory_str)

        if self.player.equipped_main:
            self.addstr(self.pad, 10, 0,
                        _("Equipped main:") + " "
                        f"{self.pack[self.player.equipped_main.name.upper()]}")
        if self.player.equipped_secondary:
            self.addstr(self.pad, 11, 0,
                        _("Equipped secondary:") + " "
                        + self.pack[self.player.equipped_secondary
                                    .name.upper()])
        if self.player.equipped_armor:
            self.addstr(self.pad, 12, 0,
                        _("Equipped chestplate:") + " "
                        + self.pack[self.player.equipped_armor.name.upper()])
        if self.player.equipped_helmet:
            self.addstr(self.pad, 13, 0,
                        _("Equipped helmet:") + " "
                        + self.pack[self.player.equipped_helmet.name.upper()])

        self.addstr(self.pad, 14, 0, f"{self.pack.HAZELNUT} "
                                     f"x{self.player.hazel}")

        if self.player.dead:
            self.addstr(self.pad, 15, 0, _("YOU ARE DEAD"), curses.COLOR_RED,
                        bold=True, blink=True, standout=True)

        if self.player.map.tiles[self.player.y][self.player.x].is_ladder():
            msg = _("Use {key} to use the ladder") \
                .format(key=self.game.settings.KEY_LADDER.upper())
            self.addstr(self.pad, self.height - 2, 0, msg,
                        italic=True, reverse=True)

        self.update_entities_stats()

    def update_entities_stats(self) -> None:
        """
        Display information about a near entity if we have a monocle.
        """
        for dy, dx in [(-1, 0), (0, -1), (0, 1), (1, 0)]:
            for entity in self.player.map.find_entities(FightingEntity):
                if entity == self.player:
                    continue

                if entity.y == self.player.y + dy \
                        and entity.x == self.player.x + dx:
                    if entity.is_friendly():
                        msg = _("Move to the friendly entity to talk to it") \
                            if self.game.waiting_for_friendly_key else \
                            _("Use {key} then move to talk to the entity") \
                            .format(key=self.game.settings.KEY_CHAT.upper())
                        self.addstr(self.pad, self.height - 1, 0, msg,
                                    italic=True, reverse=True)

                    if isinstance(self.player.equipped_secondary, Monocle):
                        # Truth monocle
                        message = f"{entity.translated_name.capitalize()} " \
                                  f"{self.pack[entity.name.upper()]}\n" \
                                  f"STR {entity.strength}\n" \
                                  f"INT {entity.intelligence}\n" \
                                  f"CHR {entity.charisma}\n" \
                                  f"DEX {entity.dexterity}\n" \
                                  f"CON {entity.constitution}\n" \
                                  f"CRI {entity.critical}%"
                        self.addstr(self.pad, 17, 0, message)
                    # Only display one entity
                    break

    def display(self) -> None:
        self.pad.erase()
        self.update_pad()
        self.refresh_pad(self.pad, 0, 0, self.y, self.x,
                         self.y + self.height - 1, self.width + self.x - 1)