import pygame
import json


class SpriteSheet:
    """
    Imports a sprite sheet as separate pygame images given an image file and a json file.
    """

    def __init__(self, sprite_sheet, texture_json):
        # Load in whole sprite sheet as one image.
        self.sprite_sheet = pygame.image.load(sprite_sheet).convert_alpha()
        self.images = []

        # Get the sprite sheet json file.
        with open(texture_json, 'r') as json_file:
            self.img_attrib = json.load(json_file)
            json_file.close()

        # Count for how many images have been added in the image list
        image_count = 0

        # Get the sprite size as a tuple
        sprite_size = self.img_attrib['width'], self.img_attrib['height']

        # Iterate through every image location on the sprite sheet given the sprite size
        for i in range(self.sprite_sheet.get_size()[1] // sprite_size[1]):
            i *= sprite_size[1]
            for j in range(self.sprite_sheet.get_size()[0] // sprite_size[0]):
                j *= sprite_size[0]

                # Create a new transparent surface
                sprite = pygame.Surface(sprite_size, pygame.SRCALPHA)
                # Blit the sprite onto the image
                sprite.blit(self.sprite_sheet, (0, 0), (j, i, sprite_size[0], sprite_size[1]))
                # Add the image to the list of images
                self.images.append(sprite)

                image_count += 1

                # Break the loop if the specified number of frames has been reached.
                if image_count >= self.img_attrib['frames']:
                    break
            if image_count >= self.img_attrib['frames']:
                break


class SelectionEgg(pygame.sprite.Sprite):
    """
    Class for the eggs on the egg selection screen.
    """

    def __init__(self, egg_color, resources_dir):
        pygame.sprite.Sprite.__init__(self)

        self.egg_color = egg_color

        # Loads the JSON file of the egg to read in data.
        with open(resources_dir + '/data/bloop_info/{0}.json'.format(egg_color), 'r') as save_file:
            json_file = json.load(save_file)
            save_file.close()

        # Gets the description off the egg from the JSON file.
        self.description = json_file.get('description')
        self.contentedness = json_file.get('contentedness')
        self.metabolism = json_file.get('metabolism')

        # Load the egg from the given color and get the bounding rectangle for the image.
        sprite_sheet = SpriteSheet(resources_dir + '/images/bloops/{0}/egg.png'.format(self.egg_color),
                                   resources_dir + '/images/bloops/{0}/egg.json'.format(self.egg_color))
        self.images = sprite_sheet.images

        # Get the rectangle from the first image in the list
        self.rect = self.images[0].get_rect()
        self.index = 0
        self.image = self.images[self.index]

    def update(self):
        """
        Updates the sprite object.
        """
        # Animate the sprite
        self.index = (self.index + 1) % len(self.images)
        self.image = self.images[self.index]


class InfoText:
    """
    Class for drawing large amounts of text on the screen at a time
    """

    def __init__(self, resources_dir, game_res, text='Lorem ipsum dolor sit amet, consectetur adipiscing elit. '
                                                     'Nam commodo tempor aliquet. Suspendisse placerat accumsan'
                                                     ' neque, nec volutpat nunc porta ut.'):

        self.font = pygame.font.Font(resources_dir + '/fonts/5Pts5.ttf', 10)
        self.text = []  # Text broken up into a list according to how it will fit on screen.
        self.max_lines = 6  # Max number of lines to be shown on screen at a time.
        self.offset = 0
        self.game_res = game_res

        # Arrow icons to indicate scrolling
        self.up_arrow = pygame.image.load(resources_dir + '/images/gui/up_arrow.png').convert_alpha()
        self.down_arrow = pygame.image.load(resources_dir + '/images/gui/down_arrow.png').convert_alpha()

        raw_text = text  # Copy the text to a different variable to be cut up.

        margins = 4.5
        max_line_width = self.game_res - (margins * 2)  # The maximum pixel width that drawn text can be.
        cut_chars = '.,! '  # Characters that will be considered "cuts" aka when a line break can occur.

        # Prevents freezing if the end of the string does not end in a cut character
        # Will fix eventually more elegantly
        if raw_text[-1:] not in cut_chars:
            raw_text += ' '

        # Calculating line breaks.
        while len(raw_text) > 0:
            index = 0
            test_text = ''  # Chunk of text to pseudo-render and test the width of.

            # Loops until the testing text has reached the size limit.
            while True:

                # Break if the current index is larger than the remaining text.
                if index + 1 > len(raw_text):
                    index -= 1
                    break

                # Add one character to the testing text from the raw text.
                test_text += raw_text[index]
                # Get the width of the pseudo-rendered text.
                text_width = self.font.size(test_text)[0]

                # Break if the text is larger than the defined max width.
                if text_width > max_line_width:
                    break
                index += 1
                pass

            # Gets the chunk of text to be added to the list.
            text_chunk = raw_text[0:index + 1]
            # Determines if the chunk of text has any break characters.
            has_breaks = any(cut_chars in text_chunk for cut_chars in cut_chars)

            # If the text has break characters, start with the last character and go backwards until
            # one has been found, decreasing the index each time.
            if has_breaks:
                while raw_text[index] not in cut_chars:
                    index -= 1
                text_chunk = raw_text[0:index + 1]
            # If there are no break characters in the chunk, simply decrease the index by one and insert
            # a dash at the end of the line to indicate the word continues.
            else:
                index -= 1
                text_chunk = raw_text[0:index + 1]
                text_chunk += '-'

            # Append the text chunk to the list of text to draw.
            self.text.append(text_chunk)

            # Cut the text to repeat the process with the new cut string.
            raw_text = raw_text[index + 1:]

    def draw(self, surface):
        """
        Draws the text on a given surface.
        :param surface: The surface for the text to be drawn on.
        """
        # Constants to help draw the text
        line_separation = 7
        left_margin = 3
        top_margin = 25
        bottom_margin = 10

        # Draw the lines on the screen
        for i in range(min(len(self.text), self.max_lines)):
            text = self.font.render(self.text[i + self.offset], False, (64, 64, 64))
            surface.blit(text, (left_margin, top_margin + (i * line_separation)))

        # Draw the arrows if there is more text than is on screen.
        if self.offset != 0:
            surface.blit(self.up_arrow, ((self.game_res / 2) - (self.up_arrow.get_rect().width / 2), top_margin - 3))
        if len(self.text) - (self.offset + 1) >= self.max_lines:
            surface.blit(self.down_arrow,
                         ((self.game_res / 2) - (self.down_arrow.get_rect().width / 2), self.game_res - bottom_margin))

    def scroll_down(self):
        """
        Scrolls the text on the screen down.
        """
        # Ensures that the offset cannot be too big as to try to render non-existent lines.
        if len(self.text) - (self.offset + 1) >= self.max_lines:
            self.offset += 1

    def scroll_up(self):
        """
        Scrolls the text on the screen up.
        """
        if self.offset > 0:  # Ensures a non-zero offset is not possible.
            self.offset -= 1


class EggInfo:
    """
    Class to draw the contentedness and metabolism value off the egg on the info screen.
    """

    def __init__(self, resources_dir, contentedness, metabolism, location):
        self.contentedness = contentedness
        self.metabolism = metabolism
        self.x = location[0]
        self.y = location[1]

        # Create a new surface to blit onto the other surface
        self.surface = pygame.Surface((44, 15), pygame.SRCALPHA)

        # Blit the two indicator icons on screen
        smiley = pygame.image.load(resources_dir + '/images/gui/smiley.png').convert_alpha()
        self.surface.blit(smiley, (0, 0))
        apple = pygame.image.load(resources_dir + '/images/gui/apple.png').convert_alpha()
        self.surface.blit(apple, (1, 9))

        # Draw 5 stars. If the value of the contentedness is less than the current star, make it a blank star.
        for i in range(5):
            if i < self.contentedness:
                star = pygame.image.load(resources_dir + '/images/gui/star.png').convert_alpha()
            else:
                star = pygame.image.load(resources_dir + '/images/gui/blank_star.png').convert_alpha()
            self.surface.blit(star, (11 + (i * 6), 1))

        # Draw 5 stars. If the value of the metabolism is less than the current star, make it a blank star.
        for i in range(5):
            if i < self.metabolism:
                star = pygame.image.load(resources_dir + '/images/gui/star.png').convert_alpha()
            else:
                star = pygame.image.load(resources_dir + '/images/gui/blank_star.png').convert_alpha()
            self.surface.blit(star, (11 + (i * 6), 10))

    def draw(self, surface):
        """
        Draw the info icons on a given surface.
        :param surface: the surface to draw the icons on.
        """
        # Blit the info onto the given surface.
        surface.blit(self.surface, (self.x, self.y))