import gctmFormatter from '../../../utils/gctm-formatter';
import botmFormatter from '../../../utils/botm-formatter';
import abdgFormatter from '../../../utils/abdg-formatter';
import aotm_aFormatter from '../../../utils/aotm_a-formatter';
import aotm_dFormatter from '../../../utils/aotm_d-formatter';
import beltFormatter from '../../../utils/belt-formatter';
import chkcFormatter from '../../../utils/chkc-formatter';
import cctmFormatter from '../../../utils/cctm-formatter';
import cotmFormatter from '../../../utils/cotm-formatter';
import chtmOnFormatter from '../../../utils/chtm_on-formatter';
import chtmOffFormatter from '../../../utils/chtm_off-formatter';
import laclFormatter from '../../../utils/lacl-formatter';
import chutFormatter from '../../../utils/chut-formatter';
import acttFormatter from '../../../utils/actt-formatter';
import psstFormatter from '../../../utils/psst-formatter';
import esttFormatter from '../../../utils/estt-formatter';
import mvinFormatter from '../../../utils/mvin-formatter';
import erutFormatter from '../../../utils/erut-formatter';
import flinFormatter from '../../../utils/flin-formatter';
import sodtFormatter from '../../../utils/sodt-formatter';
import gateFormatter from '../../../utils/gate-formatter';
import padtFormatter from '../../../utils/padt-formatter';

import { DynamicFlightOrder } from './dynamic-flight-order';

export class FlightsDataHandle {
    public formatter = {
        'GCTM': gctmFormatter,
        'BOTM': botmFormatter,
        'ABDG': abdgFormatter,
        'AOTM_A': aotm_aFormatter,
        'AOTM_D': aotm_dFormatter,
        'BELT': beltFormatter,
        'CHKC': chkcFormatter,
        'CCTM': cctmFormatter,
        'COTM': cotmFormatter,
        'CHTM_ON': chtmOnFormatter,
        'CHTM_OFF': chtmOffFormatter,
        'LACL': laclFormatter,
        'CHUT': chutFormatter,
        'ACTT': acttFormatter,
        'PSST': psstFormatter,
        'ESTT': esttFormatter,
        'MVIN': mvinFormatter,
        'ERUT': erutFormatter,
        'FLIN': flinFormatter,
        'SODT': sodtFormatter,
        'GATE': gateFormatter,
        'PADT': padtFormatter
    }

    public orderHandle = new DynamicFlightOrder();


    public findLinkFlights(raw_flights) {
        let combined_raw_flights: Array<any> = [];
        let copy_raw_flights = [];
        raw_flights.forEach(element => {
            copy_raw_flights.push(Object.assign({}, element))
        })
        for (let i = 0; i < copy_raw_flights.length; i++) {
            if (copy_raw_flights[i]['MVIN'] === 'A') {
                if (copy_raw_flights[i]['TAID']) {
                    let index = copy_raw_flights.findIndex(val => { return val['FLID'] === copy_raw_flights[i]['TAID'] });
                    if (index > -1) {
                        copy_raw_flights[i]['isLinked'] = true;
                        copy_raw_flights[i]['linkFlight'] = copy_raw_flights[index];
                        if (!copy_raw_flights[i]['linkFlight']['TAID']) {
                            copy_raw_flights[i]['linkFlight']['TAID'] = copy_raw_flights[i]['FLID'];
                        }
                        copy_raw_flights.splice(index, 1);
                        i--;
                    }
                }
            }
        }

        copy_raw_flights.forEach(element => {
            let flights_item = {};
            if (element['MVIN'] === 'A' && !element['isLinked']) {
                flights_item['preFlight'] = element;
            } else if (element['MVIN'] === 'D' && !element['isLinked']) {
                flights_item['reaFlight'] = element;
            } else {
                flights_item['reaFlight'] = element['linkFlight'];
                delete element['linkFlight'];
                delete element['isLinked'];
                flights_item['preFlight'] = element;
            }

            combined_raw_flights.push(flights_item);
        });

        return combined_raw_flights;
    }

    public flightsRenderTransfer(item, col_lists) {
        let render_flight = {},
            render_pre_flight = {},
            render_rea_flight = {},
            flights_item = Object.assign({}, item)

        if (flights_item['preFlight'] && !flights_item['reaFlight']) {
            for (let i = 0; i < col_lists.length; i++) {
                let key = col_lists[i]['COL_CODE'];
                render_flight[key] = this.formatter.hasOwnProperty(key) ? this.formatter[key](flights_item['preFlight']) : flights_item['preFlight'][key];
            }
            flights_item['renderFlight'] = render_flight;
        } else if (!flights_item['preFlight'] && flights_item['reaFlight']) {
            for (let i = 0; i < col_lists.length; i++) {
                let key = col_lists[i]['COL_CODE']
                render_flight[key] = this.formatter.hasOwnProperty(key) ? this.formatter[key](flights_item['reaFlight']) : flights_item['reaFlight'][key];
            }
            flights_item['renderFlight'] = render_flight;
        } else {
            for (let i = 0; i < col_lists.length; i++) {
                let preHasValue, reaHasValue;
                let key = col_lists[i]['COL_CODE'];
                if (this.formatter.hasOwnProperty(key)) {
                    preHasValue = this.formatter[key](flights_item['preFlight']);
                    reaHasValue = this.formatter[key](flights_item['reaFlight']);
                } else {
                    preHasValue = flights_item['preFlight'][key];
                    reaHasValue = flights_item['reaFlight'][key];
                }

                if (preHasValue && !reaHasValue) {
                    if (key === 'SODT' || key === 'ESTT' || key === 'ACTT') {
                        render_flight[key] = preHasValue + ' / ';
                    } else {
                        render_flight[key] = preHasValue;
                    }
                } else if (!preHasValue && reaHasValue) {
                    if (key === 'SODT' || key === 'ESTT' || key === 'ACTT') {
                        render_flight[key] = ' / ' + reaHasValue;
                    } else {
                        render_flight[key] = reaHasValue;
                    }
                } else if (preHasValue && reaHasValue) {
                    if (preHasValue === reaHasValue) {
                        render_flight[key] = preHasValue;
                    } else {
                        if (key === 'ERUT') {
                            render_flight[key] = preHasValue.split(' - ').slice(0, -1).join(' - ') + ' - ' + reaHasValue;
                        } else {
                            render_flight[key] = preHasValue + ' / ' + reaHasValue;
                        }
                    }
                } else {
                    render_flight[key] = '';
                }
                render_pre_flight[key] = preHasValue;
                render_rea_flight[key] = reaHasValue;
            }
            flights_item['renderPreFlight'] = render_pre_flight;
            flights_item['renderReaFlight'] = render_rea_flight;
            flights_item['renderFlight'] = Object.assign({}, render_flight);
        }

        return flights_item;
    }

    public basicDataTransHandle(item, airports, citys, airlines, flightStatus, flightTypes) {
        if (this.orderHandle.isArriFlight(item) || this.orderHandle.isDeptFlight(item)) {
            //航线处理
            let erutCodeArray = item['renderFlight']['ERUT'].split(' - ');
            let erutChnArray = []
            for (let i = 0; i < erutCodeArray.length; i++) {
                try {
                    let airportIndex = airports.findIndex(val => val.airportCodeIata === erutCodeArray[i]);
                    let cityIndex = citys.findIndex(val => airports[airportIndex].cityId === val.cityId);
                    erutChnArray.push(citys[cityIndex].cityNameChn);
                } catch (error) {
                    erutChnArray.push(erutCodeArray[i]);
                }
            }
            item['renderFlight']['ERUT'] = erutChnArray.join(' - ');
            //航空公司处理
            let airlineIndex = airlines.findIndex(val => val.airlineCode === item['renderFlight']['ALCD']);
            item['renderFlight']['ALCD'] = airlines[airlineIndex].airlineName;
            //运营状态处理
            item['renderFlight']['FTSS'] = flightStatus.find(val => val.sttc === item['renderFlight']['FTSS']).stdc;
            //航班类型处理
            item['renderFlight']['FLTY'] = flightTypes.find(val => val.flightTypeCode === item['renderFlight']['FLTY']).flightTypeNameCn;
        } else {
            //航线处理
            let erutLinkCodeArray = item['renderFlight']['ERUT'].split(' - ');
            let erutLinkChnArray = []
            for (let i = 0; i < erutLinkCodeArray.length; i++) {
                try {
                    let airportIndex = airports.findIndex(val => val.airportCodeIata === erutLinkCodeArray[i]);
                    let cityIndex = citys.findIndex(val => airports[airportIndex].cityId === val.cityId);
                    erutLinkChnArray.push(citys[cityIndex].cityNameChn);
                } catch (error) {
                    erutLinkChnArray.push(erutLinkCodeArray[i]);
                }
            }
            item['renderFlight']['ERUT'] = erutLinkChnArray.join(' - ');
            //航空公司处理
            let airlineLinkIndex = airlines.findIndex(val => val.airlineCode === item['renderFlight']['ALCD']);
            item['renderFlight']['ALCD'] = airlines[airlineLinkIndex].airlineName;
            //运营状态处理
            let ftssLinkCodeArray = item['renderFlight']['FTSS'].split(' / ');
            let ftssLinkChnArray = [];
            for (let i = 0; i < ftssLinkCodeArray.length; i++) {
                ftssLinkChnArray.push(flightStatus.find(val => val.sttc === ftssLinkCodeArray[i]).stdc)
            }
            item['renderFlight']['FTSS'] = ftssLinkChnArray.join(' / ');

            //航班类型处理
            let fltyLinkCodeArray = item['renderFlight']['FLTY'].split(' / ');
            let fltyLinkChnArray = [];
            for (let i = 0; i < fltyLinkCodeArray.length; i++) {
                fltyLinkChnArray.push(flightTypes.find(val => val.flightTypeCode === fltyLinkCodeArray[i]).flightTypeNameCn)
            }
            item['renderFlight']['FLTY'] = fltyLinkChnArray.join(' / ');

            //航线处理
            let erutPreCodeArray = item['renderPreFlight']['ERUT'].split(' - ');
            let erutPreChnArray = []
            for (let i = 0; i < erutPreCodeArray.length; i++) {
                try {
                    let airportIndex = airports.findIndex(val => val.airportCodeIata === erutPreCodeArray[i]);
                    let cityIndex = citys.findIndex(val => airports[airportIndex].cityId === val.cityId);
                    erutPreChnArray.push(citys[cityIndex].cityNameChn);
                } catch (error) {
                    erutPreChnArray.push(erutPreCodeArray[i]);
                }
            }
            item['renderPreFlight']['ERUT'] = erutPreChnArray.join(' - ');
            //航空公司处理
            let airlinePreIndex = airlines.findIndex(val => val.airlineCode === item['renderPreFlight']['ALCD']);
            item['renderPreFlight']['ALCD'] = airlines[airlinePreIndex].airlineName;
            //运营状态处理
            item['renderPreFlight']['FTSS'] = flightStatus.find(val => val.sttc === item['renderPreFlight']['FTSS']).stdc
            //航班类型处理
            item['renderPreFlight']['FLTY'] = flightTypes.find(val => val.flightTypeCode === item['renderPreFlight']['FLTY']).flightTypeNameCn;


            //航线处理
            let erutReaCodeArray = item['renderReaFlight']['ERUT'].split(' - ');
            let erutReaChnArray = []
            for (let i = 0; i < erutReaCodeArray.length; i++) {
                try {
                    let airportIndex = airports.findIndex(val => val.airportCodeIata === erutReaCodeArray[i]);
                    let cityIndex = citys.findIndex(val => airports[airportIndex].cityId === val.cityId);
                    erutReaChnArray.push(citys[cityIndex].cityNameChn);
                } catch (error) {
                    erutReaChnArray.push(erutReaCodeArray[i]);
                }
            }
            item['renderReaFlight']['ERUT'] = erutReaChnArray.join(' - ');
            //航空公司处理
            let airlineReaIndex = airlines.findIndex(val => val.airlineCode === item['renderReaFlight']['ALCD']);
            item['renderReaFlight']['ALCD'] = airlines[airlineReaIndex].airlineName;
            //运营状态处理
            item['renderReaFlight']['FTSS'] = flightStatus.find(val => val.sttc === item['renderReaFlight']['FTSS']).stdc
            //航班类型处理
            item['renderReaFlight']['FLTY'] = flightTypes.find(val => val.flightTypeCode === item['renderReaFlight']['FLTY']).flightTypeNameCn;
        }

        return item;
    }

    public dynamicMessageHandle(message, combined_data, render_data, col_lists, filterItems, LASTSEARCH, LAST_SEL_COL, airports, citys, airlines, flightStatus, flightTypes) {
        if (message.MVIN === 'A') {
            //针对combined_data的处理
            let index = combined_data.findIndex(element => {
                if (this.orderHandle.isArriFlight(element) || this.orderHandle.isLinked(element)) {
                    if (element['preFlight']['FLID'] === message.FLID) {
                        return true;
                    } else {
                        return false;
                    }
                } else {
                    return false;
                }
            });
            if (index > -1) {
                combined_data[index]['preFlight'] = message;
                combined_data[index] = this.flightsRenderTransfer(combined_data[index], col_lists);
                combined_data[index] = this.basicDataTransHandle(combined_data[index], airports, citys, airlines, flightStatus, flightTypes);

                if (message.UPTP === 'FLOP-AOTP') {
                    if (this.orderHandle.isArriFlight(combined_data[index])) {
                        if (message.TAID) {
                            combined_data.splice(index, 1);

                            let i = combined_data.findIndex(element => {
                                if (this.orderHandle.isDeptFlight(element)) {
                                    if (message.TAID === element['reaFlight']['FLID']) {
                                        return true;
                                    } else {
                                        return false;
                                    }
                                } else {
                                    return false;
                                }
                            })
                            combined_data[i]['reaFlight']['TAID'] = message.FLID;
                            let newFlight = {};
                            newFlight['preFlight'] = message;
                            newFlight['reaFlight'] = combined_data[i]['reaFlight'];

                            combined_data.splice(i, 1);

                            newFlight = this.flightsRenderTransfer(newFlight, col_lists);
                            newFlight = this.basicDataTransHandle(newFlight, airports, citys, airlines, flightStatus, flightTypes);
                            combined_data.push(newFlight)
                        }
                    } else if (this.orderHandle.isLinked(combined_data[index])) {
                        if (!message.TAID) {
                            let newPreFlight = {},
                                newReaFlight = {};

                            newPreFlight['preFlight'] = combined_data[index]['preFlight'];
                            newPreFlight['renderFlight'] = combined_data[index]['renderPreFlight'];
                            combined_data.push(newPreFlight);

                            delete combined_data[index]['reaFlight']['TAID'];
                            newPreFlight['reaFlight'] = combined_data[index]['reaFlight'];
                            newPreFlight['renderFlight'] = combined_data[index]['renderReaFlight'];
                            combined_data.push(newReaFlight);

                            combined_data.splice(index, 1);
                        }
                    }
                }
            } else {
                let newFlight = {};
                newFlight['preFlight'] = message;
                newFlight = this.flightsRenderTransfer(newFlight, col_lists);
                newFlight = this.basicDataTransHandle(newFlight, airports, citys, airlines, flightStatus, flightTypes);
                combined_data.push(newFlight);
            }

            //针对render_data的处理
            let index1 = render_data.findIndex(element => {
                if (this.orderHandle.isArriFlight(element) || this.orderHandle.isLinked(element)) {
                    if (element['preFlight']['FLID'] === message.FLID) {
                        return true;
                    } else {
                        return false;
                    }
                } else {
                    return false;
                }
            })
            if (index1 > -1) {
                render_data[index1]['preFlight'] = message;
                render_data[index1] = this.flightsRenderTransfer(render_data[index1], col_lists);
                render_data[index1] = this.basicDataTransHandle(render_data[index1], airports, citys, airlines, flightStatus, flightTypes);

                let is_satis = true;
                for (const key in filterItems) {
                    if (filterItems.hasOwnProperty(key) && filterItems[key]) {
                        if (key === 'Abnormal_state') {
                            if (render_data[index1]['preFlight'][filterItems[key]]) {
                                is_satis = true;
                                continue;
                            } else {
                                is_satis = false;
                                break;
                            }
                        } else {
                            if (render_data[index1]['preFlight'][key] === filterItems[key]) {
                                is_satis = true;
                                continue;
                            } else {
                                is_satis = false;
                                break;
                            }
                        }
                    }
                }
                let search_satis = true;
                if (LASTSEARCH) {
                    if (LAST_SEL_COL) {
                        if (render_data[index1]['preFlight'][LAST_SEL_COL]) {
                            if (render_data[index1]['preFlight'][LAST_SEL_COL].toString().match(new RegExp(LASTSEARCH, 'i'))) {
                                search_satis = true;
                            } else {
                                search_satis = false;
                            }
                        } else {
                            search_satis = false;
                        }
                    } else {
                        let cols = col_lists;
                        for (let i = 0; i < cols.length; i++) {
                            if (render_data[index1]['renderFlight'][cols[i]['COL_CODE']]) {
                                if (render_data[index1]['renderFlight'][cols[i]['COL_CODE']].toString().match(new RegExp(LASTSEARCH, 'i'))) {
                                    search_satis = true;
                                    break;
                                } else {
                                    search_satis = false;
                                    continue;
                                }
                            } else {
                                search_satis = false;
                                continue;
                            }
                        }
                    }
                }

                if (is_satis && search_satis) {
                    if (message.UPTP === 'FLOP-TAOP') {
                        if (this.orderHandle.isArriFlight(render_data[index1])) {
                            if (message.TAID) {
                                let i = render_data.findIndex(element => {
                                    if (this.orderHandle.isDeptFlight(element)) {
                                        if (message.TAID === element['reaFlight']['FLID']) {
                                            return true;
                                        } else {
                                            return false;
                                        }
                                    } else {
                                        return false;
                                    }
                                })

                                if (i > -1) {
                                    render_data.splice(index1, 1);
                                    render_data[i]['reaFlight']['TAID'] = message.FLID;
                                    let newFlight = {};
                                    newFlight['preFlight'] = message;
                                    newFlight['reaFlight'] = render_data[i]['reaFlight'];
                                    render_data.splice(i, 1);
                                    newFlight = this.flightsRenderTransfer(newFlight, col_lists);
                                    newFlight = this.basicDataTransHandle(newFlight, airports, citys, airlines, flightStatus, flightTypes);
                                    render_data.push(newFlight)
                                }
                            }
                        } else if (this.orderHandle.isLinked(render_data[index1])) {
                            if (!message.TAID) {
                                let newPreFlight = {},
                                    newReaFlight = {};
                                delete render_data[index1]['preFlight']['TAID'];
                                newPreFlight['preFlight'] = render_data[index1]['preFlight'];
                                newPreFlight['renderFlight'] = render_data[index1]['renderPreFlight'];
                                delete render_data[index1]['reaFlight']['TAID'];
                                newPreFlight['reaFlight'] = render_data[index1]['reaFlight'];
                                newPreFlight['renderFlight'] = render_data[index1]['renderReaFlight'];
                                render_data.splice(index1, 1);
                                render_data.push(newPreFlight);
                                render_data.push(newReaFlight);
                            }
                        }
                    }
                } else {
                    if (this.orderHandle.isArriFlight(render_data[index1])) {
                        render_data.splice(index1, 1);
                    } else if (this.orderHandle.isLinked(render_data[index1])) {
                        delete render_data[index1]['preFlight'];
                        delete render_data[index1]['renderPreFlight'];
                        render_data[index1] = this.flightsRenderTransfer(render_data[index1], col_lists);
                        render_data[index1] = this.basicDataTransHandle(render_data[index1], airports, citys, airlines, flightStatus, flightTypes);
                    }
                }
            } else {
                let newFlight = {};
                newFlight['preFlight'] = message;
                newFlight = this.flightsRenderTransfer(newFlight, col_lists);
                newFlight = this.basicDataTransHandle(newFlight, airports, citys, airlines, flightStatus, flightTypes);

                let is_satis = true;
                for (const key in filterItems) {
                    if (filterItems.hasOwnProperty(key) && filterItems[key]) {
                        if (key === 'Abnormal_state') {
                            if (newFlight['preFlight'][filterItems[key]]) {
                                is_satis = true;
                                continue;
                            } else {
                                is_satis = false;
                                break;
                            }
                        } else {
                            if (newFlight['preFlight'][key] === filterItems[key]) {
                                is_satis = true;
                                continue;
                            } else {
                                is_satis = false;
                                break;
                            }
                        }
                    }
                }

                let search_satis = true;
                if (LASTSEARCH) {
                    if (LAST_SEL_COL) {
                        if (newFlight['preFlight'][LAST_SEL_COL]) {
                            if (newFlight['preFlight'][LAST_SEL_COL].toString().match(new RegExp(LASTSEARCH, 'i'))) {
                                search_satis = true;
                            } else {
                                search_satis = false;
                            }
                        } else {
                            search_satis = false;
                        }
                    } else {
                        let cols = col_lists;
                        for (let i = 0; i < cols.length; i++) {
                            if (newFlight['renderFlight'][cols[i]['COL_CODE']]) {
                                if (newFlight['renderFlight'][cols[i]['COL_CODE']].toString().match(new RegExp(LASTSEARCH, 'i'))) {
                                    search_satis = true;
                                    break;
                                } else {
                                    search_satis = false;
                                    continue;
                                }
                            } else {
                                search_satis = false;
                                continue;
                            }
                        }
                    }
                }
                if (is_satis && search_satis) {
                    let i = render_data.findIndex(element => {
                        if (this.orderHandle.isDeptFlight(element)) {
                            if (message.TAID === element['reaFlight']['FLID']) {
                                return true;
                            } else {
                                return false;
                            }
                        } else {
                            return false;
                        }
                    })

                    if (i > -1) {
                        let newFlight = {};
                        newFlight['preFlight'] = message;
                        newFlight['reaFlight'] = Object.assign({}, render_data[i]['reaFlight']);
                        render_data.splice(i, 1);
                        newFlight = this.flightsRenderTransfer(newFlight, col_lists);
                        newFlight = this.basicDataTransHandle(newFlight, airports, citys, airlines, flightStatus, flightTypes);
                        render_data.push(newFlight);
                    } else {
                        render_data.push(newFlight);
                    }
                }
            }
        } else {
            //针对combined_data的处理
            let index = combined_data.findIndex(element => {
                if (this.orderHandle.isDeptFlight(element) || this.orderHandle.isLinked(element)) {
                    if (element['reaFlight']['FLID'] === message.FLID) {
                        return true;
                    } else {
                        return false;
                    }
                } else {
                    return false;
                }
            });
            if (index > -1) {
                combined_data[index]['reaFlight'] = message;
                combined_data[index] = this.flightsRenderTransfer(combined_data[index], col_lists);
                combined_data[index] = this.basicDataTransHandle(combined_data[index], airports, citys, airlines, flightStatus, flightTypes);
            } else {
                let newFlight = {};
                newFlight['reaFlight'] = message;
                newFlight = this.flightsRenderTransfer(newFlight, col_lists);
                newFlight = this.basicDataTransHandle(newFlight, airports, citys, airlines, flightStatus, flightTypes);
                combined_data.push(newFlight);
            }

            //针对render_data的处理
            let index1 = render_data.findIndex(element => {
                if (this.orderHandle.isDeptFlight(element) || this.orderHandle.isLinked(element)) {
                    if (element['reaFlight']['FLID'] === message.FLID) {
                        return true;
                    } else {
                        return false;
                    }
                } else {
                    return false;
                }
            });
            if (index1 > -1) {
                render_data[index1]['reaFlight'] = message;
                render_data[index1] = this.flightsRenderTransfer(render_data[index1], col_lists);
                render_data[index1] = this.basicDataTransHandle(render_data[index1], airports, citys, airlines, flightStatus, flightTypes);

                let is_satis = true;
                for (const key in filterItems) {
                    if (filterItems.hasOwnProperty(key) && filterItems[key]) {
                        if (key === 'Abnormal_state') {
                            if (render_data[index1]['reaFlight'][filterItems[key]]) {
                                is_satis = true;
                                continue;
                            } else {
                                is_satis = false;
                                break;
                            }
                        } else {
                            if (render_data[index1]['reaFlight'][key] === filterItems[key]) {
                                is_satis = true;
                                continue;
                            } else {
                                is_satis = false;
                                break;
                            }
                        }
                    }
                }
                let search_satis = true;
                if (LASTSEARCH) {
                    if (LAST_SEL_COL) {
                        if (render_data[index1]['reaFlight'][LAST_SEL_COL]) {
                            if (render_data[index1]['reaFlight'][LAST_SEL_COL].toString().match(new RegExp(LASTSEARCH, 'i'))) {
                                search_satis = true;
                            } else {
                                search_satis = false;
                            }
                        } else {
                            search_satis = false;
                        }
                    } else {
                        let cols = col_lists;
                        for (let i = 0; i < cols.length; i++) {
                            if (render_data[index1]['renderFlight'][cols[i]['COL_CODE']]) {
                                if (render_data[index1]['renderFlight'][cols[i]['COL_CODE']].toString().match(new RegExp(LASTSEARCH, 'i'))) {
                                    search_satis = true;
                                    break;
                                } else {
                                    search_satis = false;
                                    continue;
                                }
                            } else {
                                search_satis = false;
                                continue;
                            }
                        }
                    }
                }
                if (!is_satis || !search_satis) {
                    if (this.orderHandle.isDeptFlight(render_data[index1])) {
                        render_data.splice(index1, 1);
                    } else if (this.orderHandle.isLinked(render_data[index1])) {
                        delete render_data[index1]['reaFlight'];
                        delete render_data[index1]['renderReaFlight'];

                        render_data[index1] = this.flightsRenderTransfer(render_data[index1], col_lists);
                        render_data[index1] = this.basicDataTransHandle(render_data[index1], airports, citys, airlines, flightStatus, flightTypes);
                    }
                }
            } else {
                let newFlight = {};
                newFlight['reaFlight'] = message;
                newFlight = this.flightsRenderTransfer(newFlight, col_lists);
                newFlight = this.basicDataTransHandle(newFlight, airports, citys, airlines, flightStatus, flightTypes);

                let is_satis = true;
                for (const key in filterItems) {
                    if (filterItems.hasOwnProperty(key) && filterItems[key]) {
                        if (key === 'Abnormal_state') {
                            if (newFlight['reaFlight'][filterItems[key]]) {
                                is_satis = true;
                                continue;
                            } else {
                                is_satis = false;
                                break;
                            }
                        } else {
                            if (newFlight['reaFlight'][key] === filterItems[key]) {
                                is_satis = true;
                                continue;
                            } else {
                                is_satis = false;
                                break;
                            }
                        }
                    }
                }
                let search_satis = true;
                if (LASTSEARCH) {
                    if (LAST_SEL_COL) {
                        if (newFlight['reaFlight'][LAST_SEL_COL]) {
                            if (newFlight['reaFlight'][LAST_SEL_COL].toString().match(new RegExp(LASTSEARCH, 'i'))) {
                                search_satis = true;
                            } else {
                                search_satis = false;
                            }
                        } else {
                            search_satis = false;
                        }
                    } else {
                        let cols = col_lists;
                        for (let i = 0; i < cols.length; i++) {
                            if (newFlight['renderFlight'][cols[i]['COL_CODE']]) {
                                if (newFlight['renderFlight'][cols[i]['COL_CODE']].toString().match(new RegExp(LASTSEARCH, 'i'))) {
                                    search_satis = true;
                                    break;
                                } else {
                                    search_satis = false;
                                    continue;
                                }
                            } else {
                                search_satis = false;
                                continue;
                            }
                        }
                    }
                }
                if (is_satis && search_satis) {
                    let i = render_data.findIndex(element => {
                        if (this.orderHandle.isArriFlight(element)) {
                            if (message.TAID === element['preFlight']['FLID']) {
                                return true;
                            } else {
                                return false;
                            }
                        } else {
                            return false;
                        }
                    })

                    if (i > -1) {
                        let newFlight = {};
                        newFlight['reaFlight'] = message;
                        newFlight['preFlight'] = Object.assign({}, render_data[i]['preFlight']);
                        render_data.splice(i, 1);
                        newFlight = this.flightsRenderTransfer(newFlight, col_lists);
                        newFlight = this.basicDataTransHandle(newFlight, airports, citys, airlines, flightStatus, flightTypes);
                        render_data.push(newFlight);
                    } else {
                        render_data.push(newFlight);
                    }
                }
            }
        }

        return {
            'combined_data': combined_data,
            'render_data': render_data
        }
    }
}