class Window:
    def _rendering_loop(self):
        glClearDepth(self.depth_buffer_clear_value)
        glDepthFunc(self.clear_func_value)
        if self.last_clear_color != self.clear_color:
            glClearColor(*self.clear_color)
            self.last_clear_color = self.clear_color
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
        for camera in self._other_linked_cameras:
            camera._render()
        glMemoryBarrier(GL_TEXTURE_FETCH_BARRIER_BIT | GL_FRAMEBUFFER_BARRIER_BIT)
        self.main_camera._render(False)
        swap_buffers(self.id)

class Camera:
    def _render(self,render_to_output:bool=True):
        self.output._activate_output(render_to_output)
        self._update_frustum_planes()
        static_models_in_view=self._get_all_static_models_in_view()
        active_lights_in_view=self._get_all_active_lights_in_view()
        self.uniform_helper.uniforms_available["numLights"]=LightHandler._update_gpu_data(active_lights_in_view)
        self.renderer.start_drawing(self,self._rendering_shader,static_models_in_view)
        for shader in self._postprocessing_shader_list:
            self.renderer.start_drawing(self,shader,static_models_in_view)

class Output:
    #  Afterwards,write the code to connect those to the framebuffer.
    #  Make sure that the window rendering loop plays nicely with these buffers, and make it identify what the framebuffer has , so as to clear it (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | stencil)
    def __init__(self,starting_settings:OutputStartupSettings):
        self.resolution_x=starting_settings.resolution_x
        self.resolution_y=starting_settings.resolution_y

        self.frame_buffer_object = glGenFramebuffers(1)
        glBindFramebuffer(GL_FRAMEBUFFER, self.frame_buffer_object)
        self.texture, self._texture_id = TextureHandler.get_textures(
            self.frame_buffer_object,
            minification_filter=self.resolution_x,  # Width
            magnification_filter=self.resolution_y,  # Height
            wrapping_x_axis=GL_LINEAR,  # Force min_filter to LINEAR
            wrapping_y_axis=GL_LINEAR,  # Force mag_filter to LINEAR
            generate_mipmap=False,      # Crucial: No mipmaps for RTT
            return_id_with_slot=True
        )
        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, self._texture_id, 0)

        self.render_buffer_object=glGenRenderbuffers(1)
        self.handle=TextureHandler.id_handle_dict[self._texture_id]
        if starting_settings.add_stencil_buffer and starting_settings.add_depth_buffer:
            self.buffer_clear_tags=GL_COLOR_BUFFER_BIT |GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT
            glBindRenderbuffer(GL_RENDERBUFFER, self.render_buffer_object)
            glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, self.resolution_x, self.resolution_y)
            glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER,self.render_buffer_object)
            glBindRenderbuffer(GL_RENDERBUFFER, 0)
        elif starting_settings.add_depth_buffer:
            self.buffer_clear_tags = GL_COLOR_BUFFER_BIT  | GL_DEPTH_BUFFER_BIT
            glBindRenderbuffer(GL_RENDERBUFFER, self.render_buffer_object)
            glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24 , self.resolution_x, self.resolution_y)
            glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER,self.render_buffer_object)
            glBindRenderbuffer(GL_RENDERBUFFER, 0)
        elif starting_settings.add_stencil_buffer:
            self.buffer_clear_tags = GL_COLOR_BUFFER_BIT  | GL_STENCIL_BUFFER_BIT
            glBindRenderbuffer(GL_RENDERBUFFER, self.render_buffer_object)
            glRenderbufferStorage(GL_RENDERBUFFER, GL_STENCIL_INDEX8, self.resolution_x, self.resolution_y)
            glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER,self.render_buffer_object)
            glBindRenderbuffer(GL_RENDERBUFFER, 0)
        else:
            glDeleteRenderbuffers(1, [self.render_buffer_object])
            self.render_buffer_object = None
            self.buffer_clear_tags = GL_COLOR_BUFFER_BIT
        glBindFramebuffer(GL_FRAMEBUFFER,0)
    def _calculate_perspective_matrix(self,fov_y,resolution_x,resolution_y,near_plane,far_plane,fov_x):
        resolution_aspect=resolution_x/resolution_y
        if near_plane<far_plane:
            perspective_matrix = glm.perspective(glm.radians(fov_y), resolution_aspect, near_plane, far_plane)
        else:
            perspective_matrix = glm.perspectiveLH_ZO(glm.radians(fov_y), resolution_aspect, near_plane, far_plane)
        if fov_x != RECOMPUTE and fov_x is not None:
            sx = 1.0 / glm.tan(glm.radians(fov_x) / 2.0)
            perspective_matrix[0][0] = sx
        return perspective_matrix
        #TODO
        # Finish framebuffer setup and everything
        # Finish reverse z buffer cameras
        #
        # glDeleteFramebuffers(1,self.frame_buffer_object)
    def _activate_output(self,render_to_output:bool):
        if render_to_output:
            glViewport(0, 0, self.resolution_x,self.resolution_y)
            glBindFramebuffer(GL_FRAMEBUFFER, self.frame_buffer_object)
        else:
            glViewport(0, 0, self.resolution_x, self.resolution_y)
            glBindFramebuffer(GL_FRAMEBUFFER, 0)

class TextureHandler:
    def get_textures(image_names: str | list |np.uintc , minification_filter=GL_NEAREST_MIPMAP_NEAREST,
                     magnification_filter=GL_NEAREST, wrapping_x_axis=GL_CLAMP_TO_EDGE,
                     wrapping_y_axis=GL_CLAMP_TO_EDGE, file_path: str = USE_OWN,generate_mipmap:bool=True,return_id_with_slot:bool=False):
        if file_path == USE_OWN:
            file_path = TextureHandler.default_file_path
        if isinstance(image_names, str) or isinstance(image_names,np.uintc):
            if image_names in TextureHandler.name_id_dict:
                if not return_id_with_slot:
                    return TextureHandler.name_slot_dict[image_names]
                else:
                    return TextureHandler.name_slot_dict[image_names],TextureHandler.name_id_dict[image_names]
            else:

                slot,tex_id = TextureHandler._generate_texture(image_names, minification_filter, magnification_filter,
                                                        wrapping_x_axis, wrapping_y_axis, file_path,generate_mipmap,return_id_with_slot)
                TextureHandler._update_texture_shader_storage_buffer()
                if not return_id_with_slot:
                    return slot
                else:
                    return slot,tex_id
        else:
            made_textures = False
            slots = []
            tex_ids=[]
            for name in image_names:
                if name in TextureHandler.name_id_dict:
                    slots.append(TextureHandler.id_handle_dict[TextureHandler.name_id_dict[name]])
                    if return_id_with_slot:
                        tex_ids.append(TextureHandler.name_id_dict[name])

                else:
                    made_textures = True
                    slot,tex_id=TextureHandler._generate_texture(name, minification_filter, magnification_filter,
                                                                  wrapping_x_axis, wrapping_y_axis, file_path,generate_mipmap,return_id_with_slot)
                    slots.append(slot)
                    if return_id_with_slot:
                        tex_ids.append(tex_id)

            if made_textures:
                TextureHandler._update_texture_shader_storage_buffer()
            if return_id_with_slot:
                return slots,tex_ids
            else:
                return slots
	@staticmethod
    def _update_texture_shader_storage_buffer():
        glBindBuffer(GL_SHADER_STORAGE_BUFFER, TextureHandler.texture_shader_storage_buffer)
        # Convert 64-bit handles to two 32-bit uints each
        data = np.array(TextureHandler.texture_handles, dtype=np.uint64)
        glBufferData(GL_SHADER_STORAGE_BUFFER, data.nbytes, data, GL_DYNAMIC_DRAW)
    @staticmethod
    def _generate_texture(image_name: str|int, min_filter, mag_filter, wrapping_x_axis, wrapping_y_axis, file_path: str,generate_mipmap:bool,return_id_with_slot:bool=False):
        tex_id = glGenTextures(1)
        glBindTexture(GL_TEXTURE_2D, tex_id)


        if type(image_name)==str:
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, min_filter)
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, mag_filter)
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrapping_x_axis)
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrapping_y_axis)



            # Bindless

            image = pilimage.open(f"{file_path}/{image_name}")
            image = image.transpose(pilimage.Transpose.FLIP_TOP_BOTTOM)
            image = image.convert("RGBA")

            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image.width, image.height, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                         image.tobytes())
            if generate_mipmap:
                glGenerateMipmap(GL_TEXTURE_2D)
        else:
            # Now use actual GL constants for filters
            glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, min_filter, mag_filter)
            # Hardcode or use the hijacked wrapping args for the actual filters
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)
        # Get the bindless handle
        texture_handle = glGetTextureHandleARB(tex_id)
        glMakeTextureHandleResidentARB(texture_handle)
        # Store handle in list
        slot = len(TextureHandler.texture_handles)  # the SSBO index
        TextureHandler.texture_handles.append(texture_handle)

        # Store mappings
        TextureHandler.name_id_dict[image_name] = tex_id
        TextureHandler.id_handle_dict[tex_id] = texture_handle
        TextureHandler.name_slot_dict[image_name] = slot
        if return_id_with_slot:
            return slot,tex_id
        else:
            return slot,None