"""

RenderPipeline

Copyright (c) 2014-2016 tobspr <tobias.springer1@gmail.com>

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.

"""
from __future__ import print_function
from rplibs.six.moves import range  # pylint: disable=import-error

from panda3d.core import Vec3

from rpcore.pynative.pointer_slot_storage import PointerSlotStorage
from rpcore.pynative.gpu_command import GPUCommand

MAX_LIGHT_COUNT = 65535
MAX_SHADOW_SOURCES = 2048


class InternalLightManager(object):

    """ Please refer to the native C++ implementation for docstrings and comments.
    This is just the python implementation, which does not contain documentation! """

    def __init__(self):
        self._lights = PointerSlotStorage(MAX_LIGHT_COUNT)
        self._shadow_sources = PointerSlotStorage(MAX_SHADOW_SOURCES)
        self._cmd_list = None
        self._shadow_manager = None
        self._camera_pos = Vec3(0)
        self._shadow_update_distance = 100.0

    def get_max_light_index(self):
        return self._lights.get_max_index()

    max_light_index = property(get_max_light_index)

    def get_num_lights(self):
        return self._lights.get_num_entries()

    num_lights = property(get_num_lights)

    def get_num_shadow_sources(self):
        return self._shadow_sources.get_num_entries()

    num_shadow_sources = property(get_num_shadow_sources)

    def set_shadow_manager(self, shadow_manager):
        self._shadow_manager = shadow_manager

    def get_shadow_manager(self):
        return self._shadow_manager

    shadow_manager = property(get_shadow_manager, set_shadow_manager)

    def set_command_list(self, cmd_list):
        self._cmd_list = cmd_list

    def set_camera_pos(self, pos):
        self._camera_pos = pos

    def set_shadow_update_distance(self, dist):
        self._shadow_update_distance = dist

    def add_light(self, light):
        if light.has_slot():
            print("ERROR: Cannot add light since it already has a slot!")
            return

        slot = self._lights.find_slot()
        if slot < 0:
            print("ERROR: Could not find a free slot for a new light!")
            return

        light.assign_slot(slot)
        self._lights.reserve_slot(slot, light)

        if light.get_casts_shadows():
            self.setup_shadows(light)

        self.gpu_update_light(light)

    def setup_shadows(self, light):
        light.init_shadow_sources()
        light.update_shadow_sources()

        num_sources = light.get_num_shadow_sources()
        base_slot = self._shadow_sources.find_consecutive_slots(num_sources)
        if base_slot < 0:
            print("ERROR: Failed to find slot for shadow sources!")
            return

        for i in range(num_sources):
            source = light.get_shadow_source(i)
            source.set_needs_update(True)
            slot = base_slot + i
            self._shadow_sources.reserve_slot(slot, source)
            source.set_slot(slot)

    def remove_light(self, light):
        print(f'44444444444444444444444444')
        print("\n" + "=" * 50)
        print(f"DEBUG: Entering remove_light for light object: {light.casts_shadows}")
        if light:
            print(f"  - Light's Slot: {light.get_slot() if light.has_slot() else 'No Slot'}")
            print(f"  - Does it cast shadows? light.get_casts_shadows() -> {light.get_casts_shadows()}")
        else:
            print("  - Light object is None!")

        print("\n  --- State of Light System BEFORE removal ---")
        if hasattr(self, '_lights') and hasattr(self._lights, '_data'):
            # 打印出当前所有灯光对象，看看有没有异常
            print(f"  - Light Data Array (_data):")
            for i, l_obj in enumerate(self._lights._data):
                print(f"    [{i}]: {l_obj}")

            print(f"\n  - Max Index (_max_index): {self._lights._max_index}")
            print(f"  - Num Entries (_num_entries): {self._lights._num_entries}")
        print("=" * 50 + "\n")
        assert light is not None
        if not light.has_slot():
            print("ERROR: Could not detach light, light was not attached!")
            return

        # 保存必要信息，避免过早清理
        light_slot = light.get_slot()
        has_shadows = light.get_casts_shadows()
        
        # 处理shadow sources（如果有的话）
        if has_shadows:
            num_sources = light.get_num_shadow_sources()
            if num_sources > 0:
                # 关键修复：先保存第一个source的slot，再清理
                first_source = light.get_shadow_source(0)
                first_source_slot = first_source.get_slot()  # 保存slot值

                # --- 在这里加上打印语句 ---
                print(f"DEBUG: Removing shadow sources. Start Slot: {first_source_slot}, Count: {num_sources}")

                # 先发送GPU移除命令（在清理之前）
                cmd_remove = GPUCommand(GPUCommand.CMD_remove_sources)
                cmd_remove.push_int(first_source_slot)  # 使用保存的slot值
                cmd_remove.push_int(num_sources)
                self._cmd_list.add_command(cmd_remove)
                
                # 然后清理所有shadow sources
                for i in range(num_sources):
                    source = light.get_shadow_source(i)
                    if source.has_slot():
                        self._shadow_sources.free_slot(source.get_slot())
                    if source.has_region():
                        self._shadow_manager.get_atlas().free_region(source.get_region())
                        source.clear_region()
                
                # 清理light的shadow sources
                light.clear_shadow_sources()
        
        # 发送GPU移除light命令
        self.gpu_remove_light(light)
        
        # 最后释放light slot和清理light信息
        self._lights.free_slot(light_slot)
        light.remove_slot()

    def gpu_remove_consecutive_sources(self, first_source, num_sources):
        cmd_remove = GPUCommand(GPUCommand.CMD_remove_sources)
        cmd_remove.push_int(first_source.get_slot())
        cmd_remove.push_int(num_sources)
        self._cmd_list.add_command(cmd_remove)

    def gpu_remove_light(self, light):
        cmd_remove = GPUCommand(GPUCommand.CMD_remove_light)
        cmd_remove.push_int(light.get_slot())
        self._cmd_list.add_command(cmd_remove)

    def gpu_update_light(self, light):
        cmd_update = GPUCommand(GPUCommand.CMD_store_light)
        cmd_update.push_int(light.get_slot())
        light.write_to_command(cmd_update)
        light.set_needs_update(False)
        self._cmd_list.add_command(cmd_update)

    def gpu_update_source(self, source):
        cmd_update = GPUCommand(GPUCommand.CMD_store_source)
        cmd_update.push_int(source.get_slot())
        source.write_to_command(cmd_update)
        self._cmd_list.add_command(cmd_update)

    def update_lights(self):
        for light in self._lights.begin():
            if light.get_needs_update():
                if light.casts_shadows:
                    light.update_shadow_sources()
            self.gpu_update_light(light)

    def update_shadow_sources(self):
        sources_to_update = []

        for source in self._shadow_sources.begin():
            # if source and source.get_needs_update():
                # sources_to_update.append(source)
            if source:
                bounds = source.get_bounds()
                distance_to_camera = (self._camera_pos - bounds.get_center()) - bounds.get_radius()
                if distance_to_camera < self._shadow_update_distance:
                    sources_to_update.append(source)
                else:
                    if source.has_region():
                        self._shadow_manager.get_atlas().free_region(source.get_region())
                        source.clear_region()

        def get_source_score(source):
            dist = (source.get_bounds().get_center() - self._camera_pos).length()
            return -dist + (10**10 if source.has_region() else 0)

        sorted_sources = list(sorted(sources_to_update, key=get_source_score))

        atlas = self._shadow_manager.get_atlas()
        update_slots = min(
            len(sorted_sources),
            self._shadow_manager.get_num_update_slots_left())

        for i in range(update_slots):
            if sorted_sources[i].has_region():
                atlas.free_region(sorted_sources[i].get_region())

        for i in range(update_slots):
            source = sorted_sources[i]

            if not self._shadow_manager.add_update(source):
                print("ERROR: Shadow manager ensured update slot, but slot is taken!")
                break

            region_size = atlas.get_required_tiles(source.get_resolution())
            new_region = atlas.find_and_reserve_region(region_size, region_size)
            new_uv_region = atlas.region_to_uv(new_region)
            source.set_region(new_region, new_uv_region)
            source.set_needs_update(False)
            self.gpu_update_source(source)

    def update(self):
        self.update_lights()
        self.update_shadow_sources()
