import random as rd

class Particle():
    def __init__(self, times:list, nb_vehicles:int=10, delta_t:int=60, nb_of_ticks:int=72, x_min=-100, x_max=100, alpha=0.1):
        # Problem specific attributes
        self.nb_vehicles = nb_vehicles # Number of vehicles handles for the generations of position x
        self.delta_t = delta_t # delta_t for update purposes
        self.nb_of_ticks = nb_of_ticks # Accounting for time evolution of the solution (multiplied by delta_t)

        self.socs= self.generate_state_of_charges() # States of charge (initial, requested)

        self.times = times # (arrived, leaving)

        # Minima and maxima of a position value
        self.x_min = x_min
        self.x_max = x_max

        # Limitation of the velocity
        self.alpha = alpha
        self.r1 = [rd.randrange(0,101,1)/100 for _ in range(self.nb_vehicles)] # Variable trust of oneself
        self.r2 = [rd.randrange(0,101,1)/100 for _ in range(self.nb_vehicles)] # Variable trust of other particles

        # Particle attributes
        self.x = self.generate_position() # Position Vector (correspond to one solution for the problem)
        self.v = self.generate_velocity() # Velocity
        self.p_best = self.x # Best known position (starting with initial position x)
        self.eval = 0 #TODO: self.evaluate()

    def update_position(self):
        for i in range(self.nb_vehicles):
            new_pos_i = self.x[i] + self.v[i]
            self.x[i] = new_pos_i

    def update_velocity(self, leader, c1, c2, w=0.4):
        for i in range(self.nb_vehicles):
            new_vel_i = w * self.v[i] + (self.p_best - self.x[i]) * c1 * self.r1[i] + (leader - self.x[i]) * c2 * self.r2[i]
            self.v[i] = new_vel_i
    
    #TODO: Modify for uses of ticks
    def generate_position(self):
        pos = []
        for _ in range(self.nb_of_ticks):
            x_tick = []
            for _ in range(self.nb_vehicles):
                x_tick.append(rd.randrange(self.x_min, self.x_max +1, 1))
            pos.append(x_tick)
        return pos
    
    # Randomize a velocity vector for each tick
    def generate_velocity(self):
        vel = []
        vel_coeff = abs(self.x_max - self.x_min) 
        for _ in range(self.nb_of_ticks):
            v_tick = []
            for _ in range(self.nb_vehicles):
                v_tick.append(rd.randrange(-vel_coeff, vel_coeff +1, 1) * self.alpha)
            vel.append(v_tick)
        return vel
    
    # Function objective
    def evaluate(self, elec_prices, max_power):
        pass

    # Calculate the price of the electricity consumption in the grid SUM(1_to_T)(Epsilon_t * A_t * delta_t)
    def f1(self, elec_prices):
        result = 0
        for tick in range(self.nb_of_ticks):
            grid_stress_tick = self.get_current_grid_stress(tick)
            result += elec_prices[tick] * grid_stress_tick * self.delta_t
        return result
    
    #TODO: Modify for uses of ticks
    # User's insatisfaction
    def f2(self):
        result = 0
        for i in range(self.nb_vehicles):
            soc_req_i = self.socs[i][1]
            result += max(0, )

    # Network Stress
    def f3(self):
        current_max = 0
        for tick in range(self.nb_of_ticks):
            current_max = max(current_max, self.get_current_grid_stress(tick))
        return current_max
    
    #TODO: Modify for uses of ticks
    def get_current_grid_stress(self, tick:int):
        assert tick < self.nb_of_ticks # Make sure the tick exist in the position x
        current_grid_stress = 0
        for i in range(self.nb_vehicles):
            current_grid_stress += self.x[tick][i]
        return current_grid_stress