import numpy as np
import pandas as pd
from bus_line_match import pipei
import multiprocessing

def process_individual(x):
    stationid = np.load('stationid.npy')
    stationidlst = np.load('stationidlst.npy')
    stationidtrip = np.load('stationidtrip.npy')
    yanlinks = np.load('yanLinks.npy')
    luwang = np.load('luwang.npy')
    adregion = np.load('adregion.npy')
    stroad = np.load('stroad.npy')
    road_velocity = pd.read_csv('road_velocity.csv', header=None, encoding='gbk').values
    road_velocity[:, 0] = road_velocity[:, 0].astype(int)
    dadr = np.load('dadr.npy')

    def process_links(x):
        yanlinks_copy = yanlinks.copy()
        for i in range(len(yanlinks_copy[:, 0])):
            yanlinks_copy[i, 11] = x[yanlinks_copy[i, 10].astype(int) - 1]
        df2 = pd.read_csv('links_test1.csv')
        df2['L'] = yanlinks_copy[:, 11]
        df2.to_csv('links_test1.csv', index=False)

    def process_partition(x):
        bus_line_partition = pd.read_csv('bus_line_partition.csv', header=None, encoding='gbk')
        bus_line_partition = bus_line_partition.drop(bus_line_partition.columns[0], axis=1)
        bus_line_partition = bus_line_partition.fillna(0).astype(int).values
        bus_line_sequence = pd.read_csv('bus_road_sequence.csv', header=None, encoding='gbk')
        bus_line_sequence = bus_line_sequence.drop(bus_line_sequence.columns[0], axis=1)
        bus_line_sequence = bus_line_sequence.fillna(0).astype(int).values

        bus_line_route_velocity = np.zeros_like(bus_line_sequence)
        for i, row in enumerate(bus_line_sequence):
            matching_row_indices = np.where(road_velocity[:, 0] == row)[0]
            if matching_row_indices.size != 0:
                bus_line_route_velocity[i] = road_velocity[matching_row_indices, 1]

        pipei()
        bus_line_partition_id = np.where(np.isin(bus_line_partition, np.unique(x)))[0]
        bus_region_direction = np.where(np.isin(bus_line_partition, np.where(x[:, None] == np.unique(x))[0]))[1]
        max_length = np.max(np.sum(bus_region_direction != 0, axis=1))
        bus_region_direction_padded = np.pad(bus_region_direction, ((0, 0), (0, max_length - bus_region_direction.shape[1])), mode='constant')
        sorted_bus_region_direction = np.sort(bus_region_direction_padded, axis=1)
        unique_sorted_bus_region_direction = np.unique(sorted_bus_region_direction, axis=0)
        same_direction_fitness = {}
        for i, row in enumerate(unique_sorted_bus_region_direction):
            matching_row_indices = np.where(np.all(sorted_bus_region_direction == row, axis=1))[0]
            same_direction_bus_line_route_velocity = bus_line_route_velocity[matching_row_indices]
            same_direction_bus_line_partition_id = bus_line_partition[matching_row_indices]
            line_proportion = same_direction_bus_line_route_velocity.shape[0] / bus_line_route_velocity.shape[0]
            matching_indices = np.where(same_direction_bus_line_partition_id == i)
            matching_values = same_direction_bus_line_route_velocity[matching_indices]
            variance = np.var(matching_values)
            route_quantity = np.count_nonzero(yanlinks[:, 11] == i)
            same_direction_fitness[i] = line_proportion * variance * route_quantity
        return sum(same_direction_fitness.values())

    process_links(x)
    fitness = process_partition(x)

    return fitness

if __name__ == '__main__':
    x = np.array([8, 3, 6, 1, 3, 7, 2, 2, 2, 4, 6, 5, 8, 5, 5, 3, 1, 3, 2, 2, 7, 7, 4, 8, 1, 7, 1, 1, 3, 7, 4, 7, 2, 6, 2, 8, 1, 3, 1, 6])

    pool = multiprocessing.Pool(processes=multiprocessing.cpu_count())
    fitness = pool.map(process_individual, [x])
    pool.close()
    pool.join()

    print(fitness)