import pandas as pd
import numpy as np


def data_time_align(base_time, df):
    # 特判，如果输入的dataframe无数值，那么直接返回
    if df.empty:
        return df

    # 创建一个新的递增的 simTime 序列，从 0 开始，步长为 0.01
    new_sim_time_values = np.arange(0, base_time.max() + 0.01, 0.01)

    # 创建一个映射字典，将原始 simTime 值映射到新的 simTime 值
    original_to_new_sim_time = {original: new_sim_time_values[i] for i, original in enumerate(base_time)}

    # 使用isin函数来过滤df，并筛选出simFrame大于0的数据
    filtered_df = df[(df['simTime'].isin(base_time)) & (df['simFrame'] > 0)].reset_index(drop=True)

    # 使用映射字典来替换 filtered_df 中的 simTime 列
    filtered_df['simTime'] = filtered_df['simTime'].map(original_to_new_sim_time)

    # 同步更新simFrame
    filtered_df['simFrame'] = (filtered_df['simTime'] * 100 + 1).round().astype(int)
    print("Alignment over.")

    return filtered_df


# def data_time_align(base_time, df):
#     # 特判，如果输入的dataframe无数值，那么直接返回
#     if df.empty:
#         return df
#
#     # 使用isin函数来过滤df，并筛选出simFrame大于0的数据
#     filtered_df = df[(df['simTime'].isin(base_time)) & (df['simFrame'] > 0)].reset_index(drop=True)
#
#     # 创建一个新的递增的 simTime 序列，从 0 开始，步长为 0.01
#     new_sim_time_values = np.arange(0, filtered_df['simTime'].max() + 0.01, 0.01)
#
#     # 创建一个映射字典，将原始 simTime 值映射到新的 simTime 值
#     original_sim_times = filtered_df['simTime'].unique()  # 首先获取唯一的 simTime 值和它们的索引
#     original_to_new_sim_time = {original: new_sim_time_values[i] for i, original in enumerate(original_sim_times)}
#
#     # 使用映射字典来替换 filtered_df 中的 simTime 列
#     filtered_df['simTime'] = filtered_df['simTime'].map(original_to_new_sim_time)
#
#     # 同步更新simFrame
#     filtered_df['simFrame'] = (filtered_df['simTime'] * 100 + 1).round().astype(int)
#     print("Alignment over.")
#
#     return filtered_df


if __name__ == '__main__':
    df_ego1 = pd.read_csv('EgoState.csv')
    df_ego = df_ego1[(df_ego1['simFrame'] % 10 == 0) & (df_ego1['simFrame'] > 0)].copy()

    # 从df_ego中获取simTime的唯一值列表
    base_time = df_ego['simTime'].unique()

    df_1 = pd.read_csv('DriverCtrl.csv')
    df_2 = pd.read_csv('LaneInfo.csv')
    # df_3 = pd.read_csv('VehState.csv')

    result_1 = data_time_align(base_time, df_1)
    result_2 = data_time_align(base_time, df_2)
    # result_3 = data_time_align(base_time, df_3)

    print(1)

    #
    # # 使用isin函数来过滤df_1, df_2, df_3，并筛选出simFrame大于0的数据
    # filtered_df_1 = df_1[(df_1['simTime'].isin(base_time)) & (df_1['simFrame'] > 0)]
    # filtered_df_2 = df_2[(df_2['simTime'].isin(base_time)) & (df_2['simFrame'] > 0)]
    # filtered_df_3 = df_3[(df_3['simTime'].isin(base_time)) & (df_3['simFrame'] > 0)]
    #
    # filtered_df_1 = filtered_df_1.reset_index(drop=True)
    # filtered_df_2 = filtered_df_2.reset_index(drop=True)
    # filtered_df_3 = filtered_df_3.reset_index(drop=True)
    #
    # # 假设 filtered_df_1, filtered_df_2, filtered_df_3 已经是过滤后的 DataFrame
    #
    # # 创建一个新的递增的 simTime 序列，从 0 开始，步长为 0.01
    # new_sim_time_values = np.arange(0, filtered_df_1['simTime'].max() + 0.01, 0.01)
    #
    # # 创建一个映射字典，将原始 simTime 值映射到新的 simTime 值
    # # 首先获取唯一的 simTime 值和它们的索引
    # original_sim_times = filtered_df_1['simTime'].unique()
    # original_to_new_sim_time = {original: new_sim_time_values[i] for i, original in enumerate(original_sim_times)}
    #
    # # 使用映射字典来替换 filtered_df_1 中的 simTime 列
    # filtered_df_1['simTime'] = filtered_df_1['simTime'].map(original_to_new_sim_time)
    #
    # # 对于 simFrame，如果它也需要基于新的 simTime 重新赋值（例如，基于新的索引），可以这样做：
    # # filtered_df_1['simFrame'] = filtered_df_1.simTime * 100
    # # filtered_df_1['simFrame'] = filtered_df_1.simFrame.astype()
    # filtered_df_1['simFrame'] = (filtered_df_1['simTime'] * 100 + 1).round().astype(int)
    #
    # # 对 filtered_df_2 和 filtered_df_3 做同样的处理
    # # original_sim_times = filtered_df_2['simTime'].unique()
    # # original_to_new_sim_time = {original: new_sim_time_values[i] for i, original in enumerate(original_sim_times)}
    # filtered_df_2['simTime'] = filtered_df_2['simTime'].map(original_to_new_sim_time)
    # # filtered_df_2['simFrame'] = filtered_df_2.simTime * 100
    # filtered_df_2['simFrame'] = (filtered_df_2['simTime'] * 100 + 1).round().astype(int)
    #
    # # original_sim_times = filtered_df_3['simTime'].unique()
    # # original_to_new_sim_time = {original: new_sim_time_values[i] for i, original in enumerate(original_sim_times)}
    # filtered_df_3['simTime'] = filtered_df_3['simTime'].map(original_to_new_sim_time)
    # # filtered_df_3['simFrame'] = filtered_df_3.simTime * 100
    # filtered_df_3['simFrame'] = (filtered_df_3['simTime'] * 100 + 1).round().astype(int)
    #
    # # 现在 filtered_df_1, filtered_df_2, filtered_df_3 中的 simTime 列已经被重新赋值，并且每个原始 simTime 值都映射到了新的唯一 simTime 值
    # # simFrame 列也已经被重新赋值为对应的行索引
