import Group from 'zrender/src/container/Group';
import TrainHead from './TrainHead';
import TrainBody from './TrainBody';
import BoundingRect from 'zrender/src/core/BoundingRect';
import ETriangle from '../Train/ETriangle';
import store from '@/store/index_APP_TARGET';
import EDirection from './EDirection';

/** 列车 */
export default class Train extends Group {
    constructor(model, style) {
        super();
        this._code = model.code;
        this._type = model._type;
        this.zlevel = model.zlevel;
        this.model = model;
        this.style = style;
        this.size = 0;
        this.z = 40;
        this.section = null;
        this.isShowShape = true;
        this.fontSize = model.nameFontSize || style.Train.common.trainTextFontSize;
        this.newScale = this.fontSize / style.Train.common.trainTextFontSize;
        this.nameFormat = model.nameFormat || style.Train.trainBody.trainNameFormat;
        if (style.Train.trainBody.specialTrainType.length > 0) {
            style.Train.trainBody.specialTrainType.some((item) => {
                if (model.type === item.type) {
                    this.nameFormat = item.nameFormat;
                    model.specialServiceNumber = item.serviceNumber ? item.serviceNumber : model.serviceNumber;
                    return true;
                }
            });
        }
        this.create();
        this.setState(model, this);
        this.initShowStation(model);
    }

    _computed() {
        const model = this.model;
        const style = this.style;
        if (model.trainWindowModel) {
            this.point = {
                x: model.trainWindowModel.point.x,
                y: model.trainWindowModel.point.y
            };
            if (model.right) {
                this.point.x = this.point.x - style.Train.trainHead.trainConntWidth * this.newScale - style.Train.common.trainWidth / 2;
                this.point.y = this.point.y - style.Train.common.trainHeight / 2;
            } else {
                this.point.x = this.point.x + style.Train.trainHead.trainConntWidth * this.newScale - style.Train.common.trainWidth / 2;
                this.point.y = this.point.y + model.trainWindowModel.height - style.Train.common.trainHeight / 2;
            }
        } else {
            this.point = model.position;
            this.traingle = null;
        }
    }
    create() {
        this._computed();
        const model = this.model;
        const style = this.style;
        if (this.point) {
            this.trainB = new TrainBody({
                zlevel: this.zlevel,
                z: this.z,
                style: style,
                point: this.point,
                destinationStatus: model.destinationStatus,
                serviceNumber: model.serviceNumber,
                tripNumber: model.tripNumber,
                destinationCode: model.destinationCode,
                groupNumber: model.groupNumber,
                right: model.right,
                directionCode: model.directionCode,
                sectionModel: model.sectionModel,
                runStatus: model.runStatus,
                fontSize: this.fontSize,
                nameFormat: this.nameFormat,
                type: model.type,
                speed: model.speed,
                maLen: model.maLen,
                hold:model.hold,
                jump:model.jump,
                stop:model.stop,
                dt: model.dt,
                driveMode: model.driveMode,
                model: model
            });
            const rect = this.trainB.getBoundingRectOfFont().clone();
            const height = rect.height;
            this.trainL = new TrainHead({
                style: style,
                zlevel: this.zlevel,
                z: this.z,
                point: {
                    x: this.point.x - style.Train.common.trainHeadDistance,
                    y: this.point.y
                },
                drect: -1,
                height: height,
                fontSize: this.fontSize,
                scale: this.newScale
            });

            this.trainR = new TrainHead({
                style: style,
                zlevel: this.zlevel,
                z: this.z,
                point: {
                    x: this.point.x + style.Train.common.trainWidth + style.Train.common.trainHeadDistance,
                    y: this.point.y
                },
                drect: 1,
                height: height,
                fontSize: this.fontSize,
                scale: this.newScale
            });

            if (style.Section.trainPosition.display) {
                const data = this.model.physicalCode;
                const oldmodel = store.getters['map/getDeviceByCode'](data);
                const leftPoint = oldmodel.points[0];
                const rightPoint = oldmodel.points[oldmodel.points.length - 1];
                this.startX = this.model.right == 1 ? leftPoint.x : rightPoint.x;
                this.startY = this.model.right == 1 ? leftPoint.y : rightPoint.y;
                // 算出折线的长度
                this.lineLength = 0;
                let oldPoint = null;
                this.pointList = [];
                oldmodel.points.forEach((point) => {
                    if (oldPoint) {
                        const temp = Math.sqrt(
                            Math.pow(point.x - oldPoint.x, 2) +
							Math.pow(point.y - oldPoint.y, 2),
                        );
                        this.pointList.push({ length: temp, pointStart: { x: oldPoint.x, y: oldPoint.y }, pointEnd: { x: point.x, y: point.y } });
                        this.lineLength += temp;
                    }
                    oldPoint = point;
                });
                oldPoint = 0;
                this.pointList.forEach(point => {
                    point.percentStart = oldPoint / this.lineLength;
                    oldPoint += point.length;
                    point.percentEnd = oldPoint / this.lineLength;
                });

                this.triangle = new ETriangle({
                    style: this.style,
                    zlevel: this.zlevel,
                    z: 10,
                    right: this.model.right,
                    point: { x: this.startX, y: this.startY }
                });
                this.add(this.triangle);
            }

            this.add(this.trainB);
            this.add(this.trainL);
            this.add(this.trainR);
        }
        if (style.Train.directionArrow.hasArrow) { // 列车运行上下方箭头（eg:宁波yi）
            const arrowPoint = { x: 0, y: 0 };
            if (model.trainWindowModel) {
                arrowPoint.x = model.trainWindowModel.point.x;
                arrowPoint.y = model.right ? model.trainWindowModel.point.y + style.Train.directionArrow.distanceBottom : model.trainWindowModel.point.y - style.Train.directionArrow.distanceTop;
            }
            this.directionArrow = new EDirection({
                zlevel: this.zlevel,
                z: 10,
                right: model.right,
                x: arrowPoint.x,
                y: arrowPoint.y,
                style: style
            });
            this.add(this.directionArrow);
        }
    }

    // 获取设备提示坐标
    getShapeTipPoint() {
    }

    updateSection() {
        const train = this.model;
        if (train.physicalCode && train.offsetp && this.triangle) {
            this.pointList.forEach(point => {
                if (train.offsetp > point.percentStart && train.offsetp <= point.percentEnd) {
                    this.startX = point.pointStart.x + (point.pointEnd.x - point.pointStart.x) * (train.offsetp - point.percentStart);
                    this.startY = point.pointStart.y + (point.pointEnd.y - point.pointStart.y) * (train.offsetp - point.percentStart);
                }
            });
            const point = { x: this.startX, y: this.startY };
            this.triangle.point = point;
            this.triangle.updateTriangle(point, train.right);
            this.triangle.dirty();
        }
    }

    // 恢复颜色状态
    recover() {
        this.trainB && this.trainB.setHShow(false);
        this.trainB && this.trainB.setSShow(false);
        this.trainB && this.trainB.setDShow(false);
        this.trainB && this.trainB.setAShow(false);

        this.trainL && this.trainL.setLineShow(false);
        this.trainR && this.trainR.setLineShow(false);
        this.trainL && this.trainL.setArrowShow(false);
        this.trainR && this.trainR.setArrowShow(false);
    }

    // 设置运行方向状态类型
    setDirectionType(right, flag) {
        if (this.style.Train.trainStatusStyle.directionType.length > 0) {
            this.style.Train.trainStatusStyle.directionType.forEach((item) => {
                if (right == item.type) {
                    let lineLShow = item.lineLShow;
                    let arrowLShow = item.arrowLShow;
                    let lineRShow = item.lineRShow;
                    let arrowRShow = item.arrowRShow;
                    if (flag) {
                        lineLShow = !item.lineLShow;
                        arrowLShow = !item.arrowLShow;
                        lineRShow = !item.lineRShow;
                        arrowRShow = !item.arrowRShow;
                    }
                    this.trainL && this.trainL.setLineShow(lineLShow);
                    this.trainL && this.trainL.setArrowShow(arrowLShow);
                    this.trainR && this.trainR.setLineShow(lineRShow);
                    this.trainR && this.trainR.setArrowShow(arrowRShow);
                    return true;
                }
            });
        }
    }
    // 设置列车停止方向类型
    setDirectionStopType(right) {
        if (this.style.Train.trainStatusStyle.directionStopType.length > 0) {
            this.style.Train.trainStatusStyle.directionStopType.forEach((item) => {
                if (right == item.type) {
                    if (this.style.Train.trainHead.directionStopType == 'special') {
                        this.trainL && this.trainL.setArrowShow(item.lineLShow);
                        this.trainR && this.trainR.setArrowShow(item.lineRShow);
                    } else {
                        this.trainL && this.trainL.setLineShow(item.lineLShow);
                        this.trainR && this.trainR.setLineShow(item.lineRShow);
                    }
                    return true;
                }
            });
        }
    }
    // 设置运行状态
    setRunStatus(status, flag) {
        if (status) {
            this.setDirectionStopType(this.model.right); // 设置运行方向状态类型
        } else {
            this.setDirectionType(this.model.right, flag);	// 设置运行方向状态类型
        }
    }
    // 设置运行模式
    setDriveMode(status) {
        if (this.style.Train.trainStatusStyle.driveModeStatus.length > 0) {
            this.style.Train.trainStatusStyle.driveModeStatus.some((item) => {
                if (status === item.status) {
                    this.trainL && this.trainL.setColor(item.trainLColor);
                    this.trainR && this.trainR.setColor(item.trainRColor);
                    return true;
                }
            });
        }
    }
    // 早晚点状态
    setSoonerOrLater(dt) {
        this.trainB && this.trainB.setSoonerOrLater(dt);
    }
    // 设置扣车状态
    setHoldStatus(status) {
        if (status) {
            this.trainB && this.trainB.setHShow(true);
        } else {
            this.trainB && this.trainB.setHShow(false);
        }
    }

    // 设置跳停状态
    setJumpStatus(status) {
        if (status) {
            this.trainB && this.trainB.setSShow(true);
        } else {
            this.trainB && this.trainB.setSShow(false);
        }
    }

    // 设置车门状态类型
    setDoorStatus(status) {
        if (status != undefined) {
            if (status) {
                this.trainB && this.trainB.setDShow(false);
            } else {
                this.trainB && this.trainB.setDShow(true);
            }
        } else {
            this.trainB && this.trainB.setDShow(false);
        }
    }
    // 设置通信状态类型
    setCommunicationStatus() {
        if (this.style.Train.trainStatusStyle.communicationStatus.length > 0) {
            this.style.Train.trainStatusStyle.communicationStatus.some((item) => {
                if (status === item.status) {
                    this.trainB && this.trainB.setTrainColor(item.trainColor);
                    return true;
                }
            });
        }
    }
    // 设置报警状态
    setAlarmStatus(status) {
        if (status) {
            this.trainB && this.trainB.setAShow(true);
        } else {
            this.trainB && this.trainB.setAShow(false);
        }
    }
    // 设置状态
    setState(model, object) {
        if (!this.isShowShape) return;
        const flag = model.trainWindowModel ? model.trainWindowModel.reversal : false;
        if (model) {
            this.recover();
            if (this.style.Train.common.trainHeadColorChangeMode) {
                this.setDriveMode(model.driveMode + model.runLevel);
            } else {
                this.setDriveMode(model.driveMode);
            }
            this.setRunStatus(model.stop, flag);
            this.setCommunicationStatus(model.runLevel);
            this.setDoorStatus(model.doorCloseLock);
            this.setAlarmStatus(model.alarmStatus);
            this.setHoldStatus(model.hold);
            this.setJumpStatus(model.jump);
            this.setSoonerOrLater(model.dt);
            this.setTrainTypeColor(model.type);
            this.setPlanRoutingTypeColor(model.planRoutingType);
            const style = this.style;
            if (style.Section.trainPosition.display) {
                this.updateSection(object);
            }
        }
    }
    setTrainTypeColor(type) {
        this.trainB && this.trainB.setTrainTypeColor(type);
    }
    setPlanRoutingTypeColor(planRoutingType) {
        this.trainB && this.trainB.setPlanRoutingTypeColor(planRoutingType);
    }
    removeTrainDetail() {
        this.trainB && this.trainB.removeTrainDetail();
    }

    getBoundingRect() {
        const list = [this.trainB, this.trainL, this.trainR];
        let rect = null;
        list.forEach(elem => {
            if (elem) {
                const tempRect = elem.getBoundingRect();
                if (tempRect.x && tempRect.y && tempRect.width && tempRect.height) {
                    if (rect) {
                        rect.union(tempRect);
                    } else {
                        rect = tempRect;
                    }
                }
            }
        });
        return rect || new BoundingRect(0, 0, 0, 0);
    }
    setShowMode() { }
    initShowStation(model) {
        if (model.trainWindowModel && model.trainWindowModel.instance && !model.trainWindowModel.instance.isShowShape) {
            this.eachChild(item => {
                item.hide();
            });
        }
    }
    setShowStation(stationCode) {
        if ((this.model.sectionModel && this.model.sectionModel.stationCode === stationCode) || !stationCode) {
            this.eachChild(item => {
                item.show();
            });
            this.isShowShape = true;
            this.setState(this.model, this);
        } else {
            this.eachChild(item => {
                item.hide();
            });
            this.isShowShape = false;
        }
    }
}