import numpy as np


def PSO_multi_obj(fitness_func, n_particles, n_dims, n_objs, max_iter=100, w=0.7, c1=1.4, c2=1.4):
    global individuals  # 声明全局变量
    # 定义初始的粒子群
    swarm_position = np.empty((n_particles, n_dims))
    for i in range(n_particles):
        swarm_position[i] = individuals['chrom'][i]

    # 定义粒子群速度
    swarm_velocity = np.zeros((n_particles, n_dims))

    # 定义粒子群最优位置
    swarm_best_position = swarm_position.copy()

    # 定义一个矩阵记录下所有东西
    fitness_history = []

    # 计算初始粒子群适应度
    swarm_fitness = np.empty((n_particles, n_objs))
    for i in range(n_particles):
        swarm_fitness[i] = fitness_func(individuals['chrom'][i])

    # TOPSIS!!!!!!!!!!!!!
    colum2, colum3 = np.nanmin(swarm_fitness[:, 1]), np.nanmin(swarm_fitness[:, 2])
    zhenglixiangjie1 = np.array([colum2, colum3])
    distances1 = np.sqrt((swarm_fitness[:, 1] - colum2) ** 2 + (swarm_fitness[:, 2] - colum3) ** 2)
    fitness_array = np.concatenate((zhenglixiangjie1, distances1))

    fitness_history.append(fitness_array)

    # 定义每个粒子历史最优位置
    particle_best_position = swarm_position.copy()

    # 定义每个粒子历史最优适应度
    particle_best_fitness = swarm_fitness.copy()

    # 定义全局最优位置
    global_best_position = swarm_best_position[np.argmin(swarm_fitness[:, 0])]

    # 定义全局最优适应度
    global_best_fitness = np.min(swarm_fitness[:, 0])

    swarm_fitness1 = np.empty((n_particles, n_objs))
    fitness_history1 = []  # 记录每次适应度
    # 进行迭代
    min_values = []  # 初始化列表每一行的最小值
    for t in range(max_iter):
        # 更新粒子群速度和位置
        swarm_velocity = w * swarm_velocity + \
                         c1 * np.random.rand(n_particles, n_dims) * (particle_best_position - swarm_position) + \
                         c2 * np.random.rand(n_particles, n_dims) * (global_best_position - swarm_position)
        swarm_position += swarm_velocity

        # 将超出边界的位置调整到边界内
        for i in range(n_particles):
            for j in range(n_dims):
                if swarm_position[i][j] < unassigned_roads[j][0]:
                    swarm_position[i][j] = unassigned_roads[j][0]
                if swarm_position[i][j] > unassigned_roads[j][1]:
                    swarm_position[i][j] = unassigned_roads[j][1]

        # 计算新的适应度

        for i in range(n_particles):
            fitness = fitness_func(swarm_position[i])
            swarm_fitness1[i] = fitness

        # TOPSIS!!!!!!!!!!!!!!!!!!!
        colum22, colum33 = np.nanmin(swarm_fitness1[:, 1]), np.nanmin(swarm_fitness1[:, 2])
        if t == 0:
            if colum2 > colum22:
                colum2 = colum22
            if colum3 > colum33:
                colum3 = colum33

        else:
            if colum22 > np.min(fitness_history1[t - 1][0]):
                colum2 = np.min(fitness_history1[t - 1][0])
            else:
                colum2 = colum22
            if colum33 > np.min(fitness_history1[t - 1][1]):
                colum3 = np.min(fitness_history1[t - 1][1])
            else:
                colum3 = colum33

        zhenglixiangjie1 = np.array([colum2, colum3])

        distances1 = np.sqrt((swarm_fitness1[:, 1] - colum2) ** 2 + (swarm_fitness1[:, 2] - colum3) ** 2)
        fitness_array = np.concatenate((zhenglixiangjie1, distances1))
        fitness_history1.append(fitness_array)

        # 更新粒子历史最优位置
        for i in range(n_particles):
            if np.min(swarm_fitness[i]) < np.min(particle_best_fitness[i]):
                particle_best_fitness[i] = swarm_fitness[i]
                particle_best_position[i] = swarm_position[i]

        # 更新粒子群最优位置
        for i in range(n_particles):
            if np.min(particle_best_fitness[i]) < np.min(swarm_fitness[i]):
                swarm_best_position[i] = particle_best_position[i]

        # 更新全局最优位置
        if np.min(swarm_fitness) < global_best_fitness:
            global_best_fitness = np.min(swarm_fitness)
            global_best_position = swarm_position[np.argmin(swarm_fitness[:, 0])]

        # 记录每一次迭代的全局最优适应度
        trace.append(global_best_fitness)

    fitness_history2 = np.array(fitness_history1)
    # 返回最终的全局最优位置和适应度
    return global_best_position,global_best_fitness