extends EntityData
class_name PlantData

signal updated(p: PlantData)
signal disappeared(p: PlantData)
signal nearby_plant_updated()

enum State {PLANTED, GROWING, MATURE, DEAD}

@export var plant_name: String
@export var mutations: Array[PlantMutation]
@export var day: int:
    set(v):
        day = v
        updated.emit(self )
@export var random_seed: int

var decontamination_area_factor = 0.
var nearby_plants : Array[PlantData]

func _init(
    _position: Vector2 = Vector2.ZERO,
    _plant_name: String = Random.generate_random_word(),
    _mutations: Array[PlantMutation] = [],
    _day: int = 0,
    _random_seed = randi()
):
    position = _position
    plant_name = _plant_name
    mutations = _mutations
    day = _day
    random_seed = _random_seed

    for m in mutations:
        m.mutate_plant_data(self )

static func generate_from_seed(plant_seed: Seed, plant_position: Vector2) -> PlantData:
    return PlantData.new(
        plant_position,
        plant_seed.plant_name,
        plant_seed.plant_mutations
    )

func get_plant_info() -> RunDataPlantInfo:
    return GameInfo.game_data.current_run.plant_info

func load_entity() -> Entity:
    var plant = Plant.new(
        self
    )
    return plant

func get_lifetime() -> int:
    var lifetime = get_plant_info().get_lifetime()

    for m in mutations:
        lifetime = m.mutate_lifetime(self , lifetime)

    for pd in nearby_plants:
        lifetime += pd.get_lifetime_buff()

    return lifetime

func get_growing_time() -> int:
    var growing_time = get_plant_info().get_growing_time()

    for m in mutations:
        growing_time = m.mutate_growing_time(self , growing_time)
    
    return max(1,growing_time)

func get_score(state: State = get_state()) -> int:
    for m in mutations:
        if m.nullify_score(self):
            return 0
    
    var score = get_plant_info().get_base_score() if state == State.MATURE else 0

    var mult := 1.
    
    for m in mutations:
        score = m.mutate_score(self , score)
        mult = m.mutate_score_multiplier(self , mult)

    for pd in nearby_plants:
        score += pd.get_score_buff()

    return ceili(max(0,score) * max(0,mult))

func get_state() -> State:
    if day >= get_lifetime():
        return State.DEAD
    elif day == 0:
        return State.PLANTED
    elif day < get_growing_time():
        return State.GROWING
    return State.MATURE

func is_mature() -> bool:
    return get_state() == State.MATURE

func get_seed_number(state = get_state()):
    var seed_number = get_plant_info().get_seed_number() if (state == State.MATURE or state == State.DEAD) else 1

    for m in mutations:
        seed_number = m.mutate_seed_number(self , seed_number)

    for pd in nearby_plants:
        seed_number += pd.get_seed_buff()

    return seed_number

func get_seed_random_loose():
    var seed_random_loose = get_plant_info().get_seed_random_loose()
    for m in mutations:
        seed_random_loose = m.mutate_seed_random_loose(self , seed_random_loose)

    return seed_random_loose

func get_influence_radius():
    return get_plant_info().get_influence_radius()

# func get_random_seed_income():
#     return max(
#         get_seed_number() - randi_range(0, get_seed_random_loose()),
#         0
#     )

func get_lifetime_buff() -> int:
    var buff = 0

    for m in mutations:
        buff = m.mutate_lifetime_buff(self, buff)
    
    return buff

func get_seed_buff() -> int:
    var buff = 0

    for m in mutations:
        buff = m.mutate_seed_buff(self, buff)
    
    return buff

func get_score_buff() -> int:
    var buff = 0

    for m in mutations:
        buff = m.mutate_score_buff(self, buff)
    
    return buff
    

func disappear():
    disappeared.emit(self )