extends Node
class_name TextureBuilder

const IMAGE_WIDTH := 1000
const IMAGE_HEIGHT := 2000

const PLACEHOLDER_SEED_TEXTURE: Texture = preload("res://entities/plants/assets/sprites/default/seed.png")
const PLACEHOLDER_MATURE_TEXTURE: Texture = preload("res://entities/plants/assets/sprites/default/mature.png")
const PLACEHOLDER_GROWING_TEXTURE: Texture = preload("res://entities/plants/assets/sprites/default/growing.png")

# @export var parts_archetype_associations: Dictionary[PlantArchetype, PartArchetypeAssociation] TODO:: have the archetypes
@export var bases: Array[PlantPart]
@export var branches: Array[PlantPart]
@export var n_branches: int = 2
@export var parts_mutation_associations: Dictionary[String, PartMutationAssociation]

func build_seed_texture(_random_seed: int) -> Texture:
    return PLACEHOLDER_SEED_TEXTURE

func build_plant_texture(plant_data: PlantData) -> Texture:
    match plant_data.get_state():
        PlantData.State.MATURE:
            var mature_texture: Texture = PLACEHOLDER_MATURE_TEXTURE
            var mature_image: Image

            # var plant_archetype := plant_data.archetype
            
            if bases.size() == 0:
                printerr("No base in archetype")
                return mature_texture
            # var base_part: PlantPart = parts_archetype_associations[plant_archetype].bases.pick_random()
            var base_part: PlantPart = bases.pick_random()

            var base_image = base_part.texture.get_image()
            mature_image = Image.create_empty(IMAGE_WIDTH, IMAGE_HEIGHT, false, Image.FORMAT_RGBA8)
            var base_image_center: Vector2i = 0.5 * base_image.get_size()
            var mature_image_center: Vector2i = 0.5 * mature_image.get_size()
            mature_image.blend_rect(base_image, Rect2i(Vector2i.ZERO, base_image.get_size()), mature_image_center - base_image_center - Vector2i(base_part.root))

            if branches.size() == 0:
                printerr("No branches in archetype")
            # var branch_parts: Array[PlantPart] = parts_archetype_associations[plant_archetype].branches
            var branch_parts: Array[PlantPart]
            for i in n_branches:
                branch_parts.append(branches.pick_random())

            var parts_to_place: Array[PlantPart]
            for m in plant_data.mutations:
                print("mutations: ", m.id)
                var association: PartMutationAssociation = parts_mutation_associations[m.id]
                var mutation_possible_parts := association.parts
                for p in association.part_amount:
                    parts_to_place.append(mutation_possible_parts.pick_random())

            var available_base_attaches: Array[Vector2] = base_part.attaches.duplicate()

            var available_base_bottom_attach: Array[Vector2] = base_part.bottom_attaches.duplicate()
            
            var branch_attaches: Array[Vector2]
            var branch_root: Array[Vector2]
            var branch_parent_attach: Array[Vector2]

            assert(branch_parts.size() <= base_part.attaches.size(),
                    str("More branches (", branch_parts.size(), ") than base attaches (", base_part.attaches.size(), ")"))

            for branch in branch_parts:
                if available_base_attaches.size() == 0:
                    break
                
                var ind: int = randi_range(0, available_base_attaches.size() - 1)
                var attach: Vector2 = available_base_attaches.pop_at(ind)

                var branch_image: Image = branch.texture.get_image()
                var branch_image_center: Vector2i = 0.5 * branch_image.get_size()
                mature_image.blend_rect(branch_image, Rect2i(Vector2i.ZERO, branch.texture.get_size()), mature_image_center - branch_image_center + Vector2i(attach - branch.root - base_part.root))

                for branch_attach in branch.attaches:
                    branch_attaches.append(branch_attach)
                    branch_root.append(branch.root)
                    branch_parent_attach.append(attach)

            assert(parts_to_place.size() <= branch_attaches.size() + base_part.attaches.size() - branch_parts.size(),
                    str("Parts to place : ", parts_to_place.size(),
                        "; Branch Attaches : ", branch_attaches.size(),
                        "; Base attaches : ", base_part.attaches.size(),
                        "; Branch parts : ", branch_parts.size()))

            for part: PlantPart in parts_to_place:
                print("create part")
                var attach: Vector2
                var parent_root: Vector2
                var chosen_attach_type: int = 0
                var attachables: Array[int]
                if part.base_attachable && available_base_attaches.size() > 0:
                    attachables.append(1)
                if part.bottom_attachable && available_base_bottom_attach.size() > 0:
                    attachables.append(2)
                if part.branch_attachable && branch_attaches.size() > 0:
                    attachables.append(3)
                # assert(attachables.size() > 0)
                if attachables.size() == 0:
                    print("No attach available")
                    continue
                chosen_attach_type = attachables.pick_random()

                if chosen_attach_type == 1: # base attach
                    var ind := randi_range(0, available_base_attaches.size() - 1)
                    attach = available_base_attaches.pop_at(ind)
                    parent_root = base_part.root
                elif chosen_attach_type == 2: # bottom
                    var ind := randi_range(0, available_base_bottom_attach.size() - 1)
                    attach = available_base_bottom_attach.pop_at(ind)
                    parent_root = base_part.root
                elif chosen_attach_type == 3: # branch
                    var ind := randi_range(0, branch_attaches.size() - 1)
                    attach = branch_attaches.pop_at(ind) - branch_root.pop_at(ind) + branch_parent_attach.pop_at(ind)
                    parent_root = base_part.root

                var part_image: Image = part.texture.get_image()
                var part_image_center: Vector2i = 0.5 * part_image.get_size()
                var relative_root_centered_pos: Vector2 = Vector2(mature_image_center - part_image_center) - part.root
                mature_image.blend_rect(part_image, Rect2i(Vector2i.ZERO, part.texture.get_size()), relative_root_centered_pos + attach - parent_root)

            if plant_data.random_seed % 2 == 0:
                mature_image.flip_x()
            mature_texture = ImageTexture.create_from_image(mature_image)
            return mature_texture


        PlantData.State.GROWING:
            print("Build growing texture")
            return PLACEHOLDER_GROWING_TEXTURE
        _:
            print("Not handled state")
            return null