from common import deepcopy, dataclass, field

@dataclass
class Object:    
    id:                str
    name:              str 
    sprite_name:       str
    sprite_state:      int = 0
    # current_map
    # pos
    # weight
    # effects = {}

    def draw(self, draw_data):
        if draw_data["spr_up"] == 0:
            if self.sprite_state == len(draw_data["sprites"][self.sprite_name]) - 1:
                self.sprite_state = 0
            else:
                self.sprite_state += 1  

        sp = draw_data["sprites"][self.sprite_name][self.sprite_state]
        rect = sp.get_rect(center = (draw_data["x"] + draw_data["w"] /2, draw_data["y"] + draw_data["h"]/ 2))
        draw_data["screen"].blit(sp, rect)

    def update(self):
        pass

@dataclass
class Terrain(Object):
    pass

@dataclass
class Creature(Object):
    waypoints:        list   =   field(default_factory = list)
    quick_actions:    list   =   field(default_factory = list)
    tasks:            list   =   field(default_factory = list) 
    inventory:        dict   =   field(default_factory = dict)

    move_progress: float = 0.0  # 0.0 = старт клетки, 1.0 = конец клетки
    current_target: tuple = None  # (row, col) следующая клетка
    final_goal: tuple = None
    move_speed: float = 0.02     # пикселей/кадр (настройте)
    render_offset: tuple = (0.0, 0.0)
    start_pos: tuple = None  # (row, col) начальная позиция сегмента пути

    replan_counter: int = 0
    REPLAN_INTERVAL: int = 300


    def replan(self, cells, pos):
        from common import find_way
        path = find_way(cells, pos, self.final_goal)
        if path and len(path) > 1:
            self.waypoints = path[1:]
            self.current_target = self.waypoints[0]
        else:
            self.waypoints.clear()
            self.current_target = None

    def move(self, cells, start, goal):
        from common import find_way
        self.final_goal = goal
        self.start_pos = start
        path = find_way(cells, start, goal)
        if path and len(path) > 1:
            self.waypoints = path[1:]  # Убираем текущую позицию
            self.current_target = self.waypoints[0]
            self.move_progress = 0.0
            self.start_pos = start  # ★ ТУТ - текущая позиция как стартовая для первого шага ★
            self.render_offset = (0.0, 0.0)


    def update(self, time_delta, cell_size, map_obj):
        if self.current_target is None or not self.waypoints:
            self.render_offset = (0.0, 0.0)
            return
        
        self.replan_counter += 1
        if self.replan_counter >= self.REPLAN_INTERVAL:
            self.replan_counter = 0
            self.replan(map_obj.cells, self.start_pos)


        if self.current_target is None: return
        target_row, target_col = self.current_target
        if (target_row in map_obj.cells and 
            target_col < len(map_obj.cells[target_row])):
            target_cell = map_obj.cells[target_row][target_col]
            if target_cell.creature_obj is not None:
                self.current_target = None
                self.waypoints.clear()
                self.render_offset = (0.0, 0.0)
                self.replan(map_obj.cells, self.start_pos)
                return

        self.move_progress += self.move_speed * time_delta * 60
        self.move_progress = min(self.move_progress, 1.0)

        if self.move_progress >= 1.0:
            map_obj.move_obj('creature_obj', self.start_pos, self.current_target)

            if self.waypoints: self.waypoints.pop(0)
            if self.waypoints:
                self.start_pos = self.current_target  # Новая клетка как старт
                self.current_target = self.waypoints[0]
                self.move_progress = 0.0
                self.render_offset = (0.0, 0.0)  # ← ДОБАВИТЬ!
            else:
                self.current_target = None
                self.render_offset = (0.0, 0.0)
            return

        # ★ ТОЛЬКО интерполяция offset ★
        start_row, start_col = self.start_pos #or (0, 0)
        if self.current_target is None:
            self.render_offset = (0.0, 0.0)
            return
        target_row, target_col = self.current_target        
        offset_x = (target_col - start_col) * cell_size * self.move_progress
        offset_y = (target_row - start_row) * cell_size * self.move_progress
        self.render_offset = (offset_x, offset_y)


@dataclass
class Item(Object):
    # passive_abilities = {}
    # active_abilities = {}
    pass

@dataclass
class Container(Item):
    # content = {}
    pass


@dataclass
class Building(Object):
    pass