from os import defpath
import pandas as pd
import numpy as np
import pdb
from numba import jit
from LIB.BACKEND import Tools

class DataPreProcess:
    def __init__(self):
        self.tools = Tools.Tools()
        pass

    # def data_split(self, dfin, drive_interval_threshold=120, charge_interval_threshold=300, 
    #                            drive_stand_threshold=120, charge_stand_threshold=300,
    #                            default_time_threshold = 300, drive_time_threshold=300, charge_time_threshold=300, 
    #                            stand_time_threshold = 1800):
    #     '''
    #     数据分段函数，会调用_data_split_by_status和_data_split_by_time函数。
    #     其中_data_split_by_status 将数据分为charge、drive、stand、和none段；
    #     _data_split_by_time 将每个段内的数据，根据时间跳变继续分段。

    #     '''
    def time_filter(self, df_bms, df_gps):
        df_bms.drop_duplicates(subset=['时间戳'], keep='first', inplace=True)
        df_gps.drop_duplicates(subset=['时间戳'], keep='first', inplace=True)
        df_bms = df_bms.reset_index(drop=True)
        df_gps = df_gps.reset_index(drop=True)
        return df_bms, df_gps

    def data_split_by_status(self, dfin, drive_interval_threshold=120, charge_interval_threshold=300, 
                                    drive_stand_threshold=120, charge_stand_threshold=300):
        '''
        # 数据预处理分段, 将原始数据段分为 charge、drive、stand、none段
        # 状态判断
        # 1、drive：(状态为2或3 且 存在电流>0 ) 或 (电流持续为0 且 持续时间<阈值 且 上一段数据为行车)
        # 2、charge：(状态为2或3 且 不存在电流>0 ) 或 (电流持续为0 且 持续时间<阈值 且 上一段数据为充电)
        # 3、stand：(电流持续为0 且 是数据段的第一段) 或 (电流持续为0 且 持续时间>阈值)
        # 4、none： 其他

        --------------输入参数-------------：
        drive_interval_threshold: 行车段拼接阈值，如果两段行车的间隔时间小于该值，则两段行车合并。
        charge_interval_threshold: 充电段拼接阈值，如果两段充电的间隔时间小于该值，则两段充电合并。
        drive_stand_threshold: 静置段合并至行车段阈值，如果静置时间小于该值，则合并到上一段的行车中。
        charge_stand_threshold: 静置段合并至充电段阈值，如果静置时间小于该值，则合并到上一段的充电中。

        --------------输出-----------------:
        在原始数据后面，增加data_split_by_crnt， data_split_by_status, data_status 三列
        data_split_by_crnt: 按电流分段的序号
        data_split_by_status：按电流和状态分段的序号
        data_status： 状态标识
        '''
        # 首先根据电流是否为0 ，将数据分段
        df = dfin.copy()
        df['时间戳'] = pd.to_datetime(df['时间戳'])
        
        crnt_zero_or_not = df['总电流[A]']==0
        last_crnt_flag = crnt_zero_or_not[0]
        temp = 1
        group_id = [temp]
        for cur_crnt_flag in crnt_zero_or_not[1:]:
            if last_crnt_flag ^ cur_crnt_flag:
                temp = temp + 1
            last_crnt_flag = cur_crnt_flag
            group_id.append(temp)
        df['data_split_by_crnt'] = group_id

        # 然后判断每个段内的 充电状态及电流=0持续时长，决定当前状态
        temp = 1
        last_status = ""
        status_id = []
        status_list = []
        data_number_list = sorted(list(set(df['data_split_by_crnt'])))

        for data_number in data_number_list:
            df_sel = df[df['data_split_by_crnt'] == data_number]
            origin_index = list(df_sel.index)
            df_sel = df_sel.reset_index(drop=True)
            temp_2 = 0
            # 如果当前数据段的电流非0，则可能分为charge、drive或none段
            if df_sel.loc[0,'总电流[A]'] != 0:
                # 电流 分段中可能存在状态变化的时刻， 内部根据状态进行分段.
                # 该数据段内部，根据bms状态信号进行二次分段
                status_drive_or_not = df_sel['充电状态']==3
                last_status_flag = status_drive_or_not[0]
                temp_2 = 0
                group_id_2 = [temp_2]
                for cur_status_flag in status_drive_or_not[1:]:
                    if last_status_flag ^ cur_status_flag:
                        temp_2 = temp_2 + 1
                    last_status_flag = cur_status_flag
                    group_id_2.append(temp_2)
                
                # 遍历二次状态分段
                temp_2 = 0
                last_status_2 = last_status
                df_sel['index'] = group_id_2
                data_number_list_2 = sorted(list(set(group_id_2)))
                for data_number_2 in data_number_list_2:
                    
                    df_sel_2 = df_sel[df_sel['index'] == data_number_2]
                    df_sel_2 = df_sel_2.reset_index(drop=True)
                    
                    # 根据bms状态 及 电流符号决定是charge还是drive
                    # 如果状态为2或3， 且电流均>=0 则记为充电
                    if df_sel_2.loc[0, '充电状态'] in [2, 3] and len(df_sel_2[df_sel_2['总电流[A]'] < 0]) == 0: 
                        cur_status = 'charge'
                    # 如果状态为2或3，且存在电流<0 则记为行车
                    elif df_sel_2.loc[0, '充电状态'] in [2, 3] and len(df_sel_2[df_sel_2['总电流[A]'] < 0]) > 0: 
                        cur_status = 'drive'
                    # 否则 记为none
                    else:
                        cur_status = 'none'
                    status_list.extend([cur_status] * len(df_sel_2))
                    
                    # 状态id号与前面电流为0的相同状态进行合并, 均判断应不应该与上一段合并    
                    if origin_index[0] == 0: # 如果是所有数据的起始段数据，则直接赋值id号
                        status_id.extend([temp + temp_2]*len(df_sel_2))
                    
                    else: # 判断是否与上一段数据合并
                        deltaT = (df.loc[origin_index[0], '时间戳'] - df.loc[origin_index[0]-1, '时间戳']).total_seconds()
                        # 如果 状态一致， 且 间隔时间小于阈值，则合并
                        if last_status_2 == 'drive' and cur_status == last_status_2 and deltaT < drive_interval_threshold: 
                            temp_2 = temp_2 - 1  
                            status_id.extend([temp + temp_2]*len(df_sel_2)) 
                        # 如果状态一致， 且 间隔时间小于阈值，则合并
                        elif last_status_2 == 'charge' and cur_status == last_status_2 and deltaT < charge_interval_threshold: 
                            temp_2 = temp_2 - 1  
                            status_id.extend([temp + temp_2]*len(df_sel_2)) 
                        else:
                            status_id.extend([temp + temp_2]*len(df_sel_2))
                    temp_2 = temp_2 + 1
                    last_status_2 = status_list[-1]
                temp_2 = temp_2 - 1
            else:
                # 如果当前数据段的电流为0，则可能分为stand，charge、drive或none段
                if origin_index[0] == 0: # 如果是数据的起始，则无论长短，都认为是stand
                    status_id.extend([temp]*len(df_sel))
                    status_list.extend(['stand'] * len(df_sel))
                else: # 不是数据的起始
                    cur_deltaT = (df.loc[origin_index[-1], '时间戳'] - df.loc[origin_index[0], '时间戳']).total_seconds()
                    if last_status == 'charge': # 如果上一个状态为充电
                        if cur_deltaT < charge_stand_threshold: # 如果本次电流为0的持续时间小于 阈值，则合并
                            status_list.extend(['charge'] * len(df_sel))
                            temp = temp - 1  
                            status_id.extend([temp]*len(df_sel))
                        else: # 否则超过了阈值，记为stand
                            status_id.extend([temp]*len(df_sel))
                            status_list.extend(['stand'] * len(df_sel))
                    elif last_status == 'drive': # 如果上一个状态为行车
                        if cur_deltaT < drive_stand_threshold: # 如果本次电流为0的持续时间小于 阈值，则合并
                            status_list.extend(['drive'] * len(df_sel))
                            temp = temp - 1  
                            status_id.extend([temp]*len(df_sel))
                        else: # 否则超过了阈值，记为stand
                            status_id.extend([temp]*len(df_sel))
                            status_list.extend(['stand'] * len(df_sel))
                    elif last_status == 'none': # 如果上一个状态未知
                        status_id.extend([temp] * len(df_sel))
                        status_list.extend(['stand'] * len(df_sel))
            temp = temp + temp_2 + 1
            last_status = status_list[-1] # 上一组状态
        df['data_split_by_status'] = status_id
        df['data_status'] = status_list
        return df
    def data_split_by_time(self, dfin, default_time_threshold = 300, drive_time_threshold=300, charge_time_threshold=300, 
                                        stand_time_threshold = 1800):
        '''
        # 该函数用来解决数据丢失问题导致的分段序号异常，
        # 将经过data_split_by_status分段后的数据，每个段内两行数据的时间跳变如果超过阈值，则继续分为两段

        --------------输入参数-------------：
        dfin:  调用data_split_by_status之后的函数
        default_time_threshold: 默认时间阈值，如果状态内部时间跳变大于该值，则划分为两段
        drive_time_threshold: 行车时间阈值，如果行车状态内部时间跳变大于该值，则划分为两段
        charge_time_threshold: 充电时间阈值，如果充电状态内部时间跳变大于该值，则划分为两段
        stand_time_threshold：静置时间阈值，如果静置状态内部时间跳变大于该值，则划分为两段

        --------------输出-----------------:
        在输入数据后面，增加data_split_by_status_time 一列
        data_split_by_status_time: 按照状态和时间分段后的序号
        '''  
        data_id = []
        temp = 1
        data_number_list = sorted(list(set(dfin['data_split_by_status'])))
        for data_number in data_number_list:
            # if data_number == 1203:
            #     pdb.set_trace()
            status = list(dfin[dfin['data_split_by_status']==data_number]['data_status'])[0]
            cur_indexes = dfin[dfin['data_split_by_status']==data_number].index
            
            time_array = np.array(dfin[dfin['data_split_by_status']==data_number]['时间戳'])
            time_diff = np.diff(time_array)
            time_diff = time_diff.astype(np.int64)
            time_interval = default_time_threshold
            if status == 'drive':
                time_interval = drive_time_threshold
            elif status == 'charge':
                time_interval = charge_time_threshold
            elif status == 'stand':
                time_interval = stand_time_threshold
            time_diff_index = (np.argwhere(((time_diff/1e9) > time_interval)==True))[:,0]
            time_diff_origin_index = cur_indexes[time_diff_index]+1
            if len(time_diff_index) == 0:
                data_id.extend([temp] * len(cur_indexes))
                temp += 1
            else:
                last_index = cur_indexes[0]
                for index, cur_index in enumerate(time_diff_origin_index):
                    if index == len(time_diff_origin_index)-1: # 如果是最后一个index，则
                        data_id.extend([temp]* (cur_index-last_index))
                        last_index = cur_index
                        temp += 1
                        data_id.extend([temp]* (cur_indexes[-1]-last_index+1))
                    else:
                        data_id.extend([temp]* (cur_index-last_index))
                    last_index = cur_index
                    temp += 1
        dfin['data_split_by_status_time'] = data_id
        return dfin
    def combine_drive_stand(self, dfin):
        '''
        合并放电和静置段：将两次充电之间的所有数据段合并为一段， 状态分为 charge 和not charge
        ---------------输入----------
        dfin： 调用data_split_by_status()后输出的bms数据

        ---------------输出----------
        在输入数据后面，增加data_split_by_status_after_combine， data_status_after_combine 两列
        data_split_by_status_after_combine： 将两次充电间的数据合并后的段序号
        data_status_after_combine： 每段数据的状态标识
        '''
        df = dfin.copy()
        data_split_by_status_1 = []
        data_status_1 = []
        number = 1
        first_flag = True
        data_number_list = sorted(list(set(df['data_split_by_status_time'])))
        for data_number in data_number_list:
            status = list(df[df['data_split_by_status_time']==data_number]['data_status'])
            cur_status = status[0]
            if first_flag:
                first_flag = False
            elif (last_status not in ['charge'] and cur_status in ['charge']) or (last_status in ['charge'] and cur_status not in ['charge']):
                number += 1

            data_split_by_status_1.extend([number]*len(status))
            if cur_status in ['charge']:
                data_status_1.extend(['charge']*len(status))
            else:
                data_status_1.extend(['not charge']*len(status))

            last_status = cur_status
        df['data_split_by_status_after_combine'] = data_split_by_status_1
        df['data_status_after_combine'] = data_status_1

        return df

    def cal_stand_time(self, dfin):
        '''
        # 计算静置时间
        # 将每次行车或充电的前后静置时间，赋值给stand_time 列， 单位为分钟

        ----------------输入参数---------
        dfin: 调用data_split_by_status()后输出的bms数据

        ----------------输出参数----------
        在输入数据后面，增加stand_time列
        stand_time : 在行车段或充电段的起止两个位置处，表明开始前和结束后的静置时长，单位为分钟

        '''
        df = dfin.copy()
        stand_time = []
        first_flag = True
        data_number_list = sorted(list(set(df['data_split_by_status_time'])))
        for index, data_number in enumerate(data_number_list):
            status = list(df[df['data_split_by_status_time']==data_number]['data_status'])
            time =  list(df[df['data_split_by_status_time']==data_number]['时间戳'])
            cur_status = status[0]
            cur_delta_time = (time[-1]-time[0]).total_seconds() / 60.0 # 分钟
            if len(status) >= 2:
                if first_flag:
                    first_flag = False
                    if index < len(data_number_list)-1:
                        if cur_status in ['charge', 'drive']:
                            next_status = list(df[df['data_split_by_status_time']==data_number_list[index+1]]['data_status'])[0]
                            stand_time.extend([None]*(len(status)-1))
                            if next_status == 'stand':
                                next_time =  list(df[df['data_split_by_status_time']==data_number_list[index+1]]['时间戳'])
                                stand_time.extend([(next_time[-1]-next_time[0]).total_seconds() / 60.0])
                            else:
                                stand_time.extend([0])
                        else:
                            stand_time.extend([None]*len(status))
                    else:
                        stand_time.extend([None]*len(status))      
                else:
                    if cur_status in ['charge', 'drive']:
                        if last_status == 'stand':
                            stand_time.extend([last_delta_time])
                        else:
                            stand_time.extend([0])
                        stand_time.extend([None]*(len(status)-2))
                        if index < len(data_number_list)-1:
                            next_status = list(df[df['data_split_by_status_time']==data_number_list[index+1]]['data_status'])[0]
                            if next_status == 'stand':
                                next_time =  list(df[df['data_split_by_status_time']==data_number_list[index+1]]['时间戳'])
                                stand_time.extend([(next_time[-1]-next_time[0]).total_seconds() / 60.0])
                            else:
                                stand_time.extend([0])
                        else:
                            stand_time.extend([None])
                    else:
                        stand_time.extend([None]*len(status))
                        
            else:
                stand_time.extend([None])
            last_status = cur_status
            last_delta_time = cur_delta_time
        df['stand_time'] = stand_time
        return df

    # 输入GPS数据，返回本段数据的累积里程，及平均时速(如果两点之间)
    @jit
    def _cal_odo_speed(self, lat_list, long_list, time_list):
        '''
        输入：经度列表， 纬度列表， 时间列表；
        输出：每两个经纬度坐标之间的距离，以及速度 的数组
        '''
        dis_array = []
        speed_array = []
 
        for i in range(len(lat_list)-1):
            dis = self.tools.cal_distance(lat_list[i],long_list[i], lat_list[i+1],long_list[i+1])
            dis_array.append(dis)
            deltaT = abs(time_list[i] - time_list[i+1]).total_seconds()
            speed_array.append(dis * 3600.0/deltaT)
        return np.array(dis_array), np.array(speed_array)

    def gps_data_judge(self, df_bms, df_gps, time_diff_thre=300, odo_sum_thre=200, drive_spd_thre=80, parking_spd_thre=2):
        '''
        GPS数据可靠性判断函数(基于combine前的分段)

        GPS数据出现以下情况时，判定为不可靠：
        1）如果该段对应的地理位置数据 少于2 个，则认为不可靠
        2）如果截取的GPS数据的起止时间，与BMS数据段的起止时间相差超过阈值，则认为不可靠
        3）如果行车段 累积里程超过阈值，车速超过阈值
        4) 如果非行车段 车速超过阈值

        --------------输入参数--------------：
        time_diff_thre： 时间差阈值
        odo_sum_thre: 累积里程阈值
        drive_spd_thre: 行车车速阈值
        parking_spd_thre： 非行车状态车速阈值

        --------------输出参数--------------:
        df_bms 增加一列gps_rely， 表明对应的GPS数据是否可靠。
                1：可靠
                <0: 表示不可靠的原因
        df_gps 增加两列odo， speed， 分别表示前后两点间的距离和速度
        '''
        df_gps['时间戳'] = pd.to_datetime(df_gps['时间戳'])
        res_record = {'drive':0, 'charge':0, 'stand':0, 'none':0, 'total':0}
        rely_list = []
        df_gps['odo'] = [None] * len(df_gps)
        df_gps['speed'] = [None] * len(df_gps)
        data_number_list = sorted(list(set(df_bms['data_split_by_status_time'])))
        for data_number in data_number_list[:]:
            df_sel = df_bms[df_bms['data_split_by_status_time'] == data_number]
            df_sel = df_sel.reset_index(drop=True)
            df_sel_gps = df_gps[(df_gps['时间戳']>=df_sel.loc[0,'时间戳']) & (df_gps['时间戳']<=df_sel.loc[len(df_sel)-1,'时间戳'])]
            origin_index = list(df_sel_gps.index)
            df_sel_gps = df_sel_gps.reset_index(drop=True)
            # 如果当前段数据对应的地理位置数据少于2个
            if len(df_sel_gps) <= 1:
                rely_list.extend([-1]*len(df_sel))
                res_record[str(df_sel.loc[0, 'data_status'])] = res_record[str(df_sel.loc[0, 'data_status'])] + 1
                continue
            # 如果GPS 起止时间段和BMS数据相差超过阈值
            if abs(df_sel_gps.loc[0, '时间戳'] - df_sel.loc[0,'时间戳']).total_seconds() > time_diff_thre or \
               abs(df_sel_gps.loc[len(df_sel_gps)-1, '时间戳'] - df_sel.loc[len(df_sel)-1,'时间戳']).total_seconds() > time_diff_thre:
                rely_list.extend([-2]*len(df_sel))
                res_record[str(df_sel.loc[0, 'data_status'])] = res_record[str(df_sel.loc[0, 'data_status'])] + 1
                continue

            # 计算该段数据每两点之间的里程以及速度
            dis_array, speed_array = self._cal_odo_speed(df_sel_gps['纬度'], df_sel_gps['经度'], df_sel_gps['时间戳'])
            # 如果 累积里程异常 或 平均车速异常 或两点间车速异常
            avg_speed = np.sum(dis_array) *3600.0 / abs(df_sel_gps.loc[0, '时间戳'] - df_sel_gps.loc[len(df_sel_gps)-1, '时间戳']).total_seconds()
            if np.sum(dis_array) > odo_sum_thre or avg_speed > drive_spd_thre or (speed_array > drive_spd_thre).any():
                rely_list.extend([-3]*len(df_sel))
                res_record[str(df_sel.loc[0, 'data_status'])] = res_record[str(df_sel.loc[0, 'data_status'])] + 1
                continue
            
            # 如果停车，且 平均时速超过阈值，则不可靠
            if (str(df_sel.loc[0, 'data_status']) == 'charge' or str(df_sel.loc[0, 'data_status']) == 'stand') and avg_speed > parking_spd_thre :
                rely_list.extend([-4]*len(df_sel))
                res_record[str(df_sel.loc[0, 'data_status'])] = res_record[str(df_sel.loc[0, 'data_status'])] + 1
                continue
            # 剩下的记录为可靠
            rely_list.extend([1]*len(df_sel))
            df_gps.loc[origin_index[1:], 'odo'] = dis_array
            df_gps.loc[origin_index[1:], 'speed'] = speed_array
        df_bms['gps_rely'] = rely_list
        res_record['total'] = (res_record['drive'] + res_record['charge'] + res_record['stand'] + res_record['none'] )/df_bms['data_split_by_status_time'].max()
        if len(set(df_bms[df_bms['data_status']=='drive']['data_split_by_status_time'])) > 0:
            res_record['drive'] = (res_record['drive'])/len(set(df_bms[df_bms['data_status']=='drive']['data_split_by_status_time']))
        if len(set(df_bms[df_bms['data_status']=='charge']['data_split_by_status_time'])) > 0:
            res_record['charge'] = (res_record['charge'])/len(set(df_bms[df_bms['data_status']=='charge']['data_split_by_status_time']))
        if len(set(df_bms[df_bms['data_status']=='stand']['data_split_by_status_time'])) > 0:
            res_record['stand'] = (res_record['stand'])/len(set(df_bms[df_bms['data_status']=='stand']['data_split_by_status_time']))
        if len(set(df_bms[df_bms['data_status']=='none']['data_split_by_status_time'])) > 0:
            res_record['none'] = (res_record['none'])/len(set(df_bms[df_bms['data_status']=='none']['data_split_by_status_time']))
        return df_bms, df_gps, res_record


    def data_gps_judge_after_combine(self, df_bms, df_gps, time_diff_thre=600, odo_sum_thre=200, drive_spd_thre=80, parking_spd_thre=2):
        '''
        GPS数据可靠性判断函数2 (基于combine后的分段) 判别方式同data_gps_judge
        '''
        df_gps['时间戳'] = pd.to_datetime(df_gps['时间戳'])
        res_record = {'not charge':0, 'charge':0, 'total':0} # 不可靠的比例

        rely_list = []
        df_gps['odo_after_combine'] = [None] * len(df_gps)
        df_gps['speed_after_combine'] = [None] * len(df_gps)
 
        data_number_list = sorted(list(set(df_bms['data_split_by_status_after_combine'])))
        for data_number in data_number_list[:]:
            df_sel = df_bms[df_bms['data_split_by_status_after_combine'] == data_number]
            df_sel = df_sel.reset_index(drop=True)

            # 尝试采用drive段的开始和结束时间选择GPS数据，因为stand时GPS数据可能存在丢失，影响里程的计算
            df_sel_drive = df_sel[df_sel['data_status']=='drive'] # 
            df_sel_drive = df_sel_drive.reset_index(drop=True)
            if df_sel_drive.empty:
                df_sel_1 = df_sel
            else:
                df_sel_1 = df_sel_drive
            df_sel_gps = df_gps[(df_gps['时间戳']>=df_sel_1.loc[0,'时间戳']) & (df_gps['时间戳']<=df_sel_1.loc[len(df_sel_1)-1,'时间戳'])]
            origin_index = list(df_sel_gps.index)
            df_sel_gps = df_sel_gps.reset_index(drop=True)
            # 如果当前段数据对应的地理位置数据少于2个
            if len(df_sel_gps) <= 1:
                rely_list.extend([-1]*len(df_sel))
                res_record[str(df_sel.loc[0, 'data_status_after_combine'])] = res_record[str(df_sel.loc[0, 'data_status_after_combine'])] + 1
                continue
            # 如果GPS 起止时间段和BMS数据相差超过阈值
            if abs(df_sel_gps.loc[0, '时间戳'] - df_sel_1.loc[0,'时间戳']).total_seconds() > time_diff_thre or \
                abs(df_sel_gps.loc[len(df_sel_gps)-1, '时间戳'] - df_sel_1.loc[len(df_sel_1)-1,'时间戳']).total_seconds() > time_diff_thre:
                rely_list.extend([-2]*len(df_sel))
                res_record[str(df_sel.loc[0, 'data_status_after_combine'])] = res_record[str(df_sel.loc[0, 'data_status_after_combine'])] + 1
                continue

            # 计算该段数据每两点之间的里程以及速度
            dis_array, speed_array = self._cal_odo_speed(df_sel_gps['纬度'], df_sel_gps['经度'], df_sel_gps['时间戳'])
            # 如果 累积里程异常 或 平均车速异常 或两点间车速异常
            avg_speed = np.sum(dis_array) *3600.0 / abs(df_sel_gps.loc[0, '时间戳'] - df_sel_gps.loc[len(df_sel_gps)-1, '时间戳']).total_seconds()
            if np.sum(dis_array) > odo_sum_thre or avg_speed > drive_spd_thre or (speed_array > drive_spd_thre).any():
                rely_list.extend([-3]*len(df_sel))
                res_record[str(df_sel.loc[0, 'data_status_after_combine'])] = res_record[str(df_sel.loc[0, 'data_status_after_combine'])] + 1
                continue
            
            # 如果充电，且 平均时速超过阈值，则不可靠
            if str(df_sel.loc[0, 'data_status_after_combine']) == 'charge' and avg_speed > parking_spd_thre:
                rely_list.extend([-4]*len(df_sel))
                res_record[str(df_sel.loc[0, 'data_status_after_combine'])] = res_record[str(df_sel.loc[0, 'data_status_after_combine'])] + 1
                continue
            # 剩下的记录为可靠
            rely_list.extend([1]*len(df_sel))
            df_gps.loc[origin_index[1:], 'odo_after_combine'] = dis_array
            df_gps.loc[origin_index[1:], 'speed_after_combine'] = speed_array
        df_bms['gps_rely_after_combine'] = rely_list
        res_record['total'] = (res_record['not charge'] + res_record['charge'])/df_bms['data_split_by_status_after_combine'].max()
        if len(set(df_bms[df_bms['data_status_after_combine']=='not charge']['data_split_by_status_after_combine'])) > 0:
            res_record['not charge'] = (res_record['not charge'])/len(set(df_bms[df_bms['data_status_after_combine']=='not charge']['data_split_by_status_after_combine']))
        if len(set(df_bms[df_bms['data_status_after_combine']=='charge']['data_split_by_status_after_combine'])) > 0 :
            res_record['charge'] = (res_record['charge'])/len(set(df_bms[df_bms['data_status_after_combine']=='charge']['data_split_by_status_after_combine']))
        return df_bms, df_gps, res_record
        