# Copyright 2024 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

from resources.types.resource_object import ResourceObject
from resources.resource_map.resource_generator import ResourceGenerator

from pebble_sdk_platform import pebble_platforms

import bitmapgen
import png2pblpng
import re

PNG_MIN_APP_MEMORY = 0x8000  # 32k, fairly arbitrarily

class BitmapResourceGenerator(ResourceGenerator):
    type = 'bitmap'

    @staticmethod
    def definitions_from_dict(bld, definition_dict, resource_source_path):
        definitions = ResourceGenerator.definitions_from_dict(bld, definition_dict,
                                                              resource_source_path)
        for d in definitions:
            d.memory_format = definition_dict.get('memoryFormat', 'smallest')
            d.space_optimization = definition_dict.get('spaceOptimization', None)
            d.storage_format = definition_dict.get('storageFormat', None)
        return definitions

    @classmethod
    def generate_object(cls, task, definition):
        env = task.generator.env

        memory_format = definition.memory_format.lower()
        # Some options are mutually exclusive.
        if definition.space_optimization == 'memory' and definition.storage_format == 'png':
            task.generator.bld.fatal("{}: spaceOptimization: memory and storageFormat: "
                                     "png are mutually exclusive.".format(definition.name))
        if definition.space_optimization == 'storage' and definition.storage_format == 'pbi':
            task.generator.bld.fatal("{}: spaceOptimization: storage and storageFormat: "
                                     "pbi are mutually exclusive.".format(definition.name))
        if definition.storage_format == 'png' and memory_format == '1bit':
            task.generator.bld.fatal("{}: PNG storage does not support non-palettised 1-bit images."
                                     .format(definition.name))

        # If storage_format is not specified, it is completely determined by space_optimization.
        if definition.storage_format is None and definition.space_optimization is not None:
            format_mapping = {
                'storage': 'png',
                'memory': 'pbi',
            }
            try:
                definition.storage_format = format_mapping[definition.space_optimization]
            except KeyError:
                task.generator.bld.fatal("{}: Invalid spaceOptimization '{}'. Use one of {}."
                                         .format(definition.name, definition.space_optimization,
                                                 ', '.join(format_mapping.keys())))

        if definition.storage_format is None:
            if pebble_platforms[env.PLATFORM_NAME]['MAX_APP_MEMORY_SIZE'] < PNG_MIN_APP_MEMORY:
                definition.storage_format = 'pbi'
            else:
                definition.storage_format = 'png'

        # At this point, what we want to do should be completely determined (though, depending on
        # image content, not necessarily actually possible); begin figuring out what to actually do.

        is_color = 'color' in pebble_platforms[env.PLATFORM_NAME]['TAGS']
        palette_name = png2pblpng.get_ideal_palette(is_color)
        _, _, bitdepth, _ = png2pblpng.get_palette_for_png(task.inputs[0].abspath(), palette_name,
                                                           png2pblpng.DEFAULT_COLOR_REDUCTION)

        formats = {
            '1bit',
            '8bit',
            'smallest',
            'smallestpalette',
            '1bitpalette',
            '2bitpalette',
            '4bitpalette',
        }
        if memory_format not in formats:
            task.generator.bld.fatal("{}: Invalid memoryFormat {} (pick one of {})."
                                     .format(definition.name, definition.memory_format,
                                             ', '.join(formats)))

        # "smallest" is always palettised, unless the image has too many colours, in which case it
        # cannot be.
        if memory_format == 'smallest':
            if bitdepth <= 4:
                memory_format = 'smallestpalette'
            else:
                memory_format = '8bit'

        if 'palette' in memory_format:
            if memory_format == 'smallestpalette':
                # If they asked for "smallestpalette", replace that with its actual value.
                if bitdepth > 4:
                    task.generator.bld.fatal("{} has too many colours for a palettised image"
                                             "(max 16), but 'SmallestPalette' specified."
                                             .format(definition.name))
                else:
                    memory_format = '{}bitpalette'.format(bitdepth)

            # Pull out however many bits we're supposed to use (which is exact, not a min or max)
            bits = int(re.match(r'^(\d+)bitpalette$', memory_format).group(1))
            if bits < bitdepth:
                task.generator.bld.fatal("{}: requires at least {} bits.".format(definition.name,
                                                                                 bitdepth))
            if bits > 2 and not is_color:
                task.generator.bld.fatal("{}: can't use more than two bits on a black-and-white"
                                         "platform." .format(definition.name))

            if definition.storage_format == 'pbi':
                pb = bitmapgen.PebbleBitmap(task.inputs[0].abspath(), bitmap_format='color',
                                            bitdepth=bits, crop=False, palette_name=palette_name)
                return ResourceObject(definition, pb.convert_to_pbi())
            else:
                image_bytes = png2pblpng.convert_png_to_pebble_png_bytes(task.inputs[0].abspath(),
                                                                         palette_name,
                                                                         bitdepth=bits)
                return ResourceObject(definition, image_bytes)
        else:
            if memory_format == '1bit':
                pb = bitmapgen.PebbleBitmap(task.inputs[0].abspath(), bitmap_format='bw',
                                            crop=False)
                return ResourceObject(definition, pb.convert_to_pbi())
            elif memory_format == '8bit':
                if not is_color:
                    task.generator.bld.fatal("{}: can't use more than two bits on a black-and-white"
                                             "platform.".format(definition.name))
                # generate an 8-bit pbi or png, as appropriate.
                if definition.storage_format == 'pbi':
                    pb = bitmapgen.PebbleBitmap(task.inputs[0].abspath(), bitmap_format='color_raw',
                                                crop=False, palette_name=palette_name)
                    return ResourceObject(definition, pb.convert_to_pbi())
                else:
                    image_bytes = png2pblpng.convert_png_to_pebble_png_bytes(
                        task.inputs[0].abspath(), palette_name, bitdepth=8)
                    return ResourceObject(definition, image_bytes)

        raise Exception("Got to the end without doing anything?")
