function createDefaultProfileConfig() {
    return {
        calcMaxDepth: 120,
        calcMaxPaths: 500,
        calcMaxCost: 300,
        s1TopK: 5,
        s1LenWeight: 1.0,
        s1TurnWeight: 3.0,
        s1LiftWeight: 8.0,
        s1SoftDeviationWeight: 4.0,
        s1MaxLenRatio: 1.15,
        s1MaxTurnDiff: 1,
        s2BusyWeight: 2.0,
        s2RunBlockWeight: 10.0,
        s2LoopLoadWeight: 12.0
    }
}

function createDefaultProfile() {
    return {
        id: null,
        profileCode: '',
        profileName: '',
        priority: 100,
        status: 1,
        memo: '',
        config: createDefaultProfileConfig(),
        _originCode: null
    }
}

function createDefaultRule(defaultProfileCode) {
    return {
        id: null,
        ruleCode: '',
        ruleName: '',
        priority: 100,
        status: 1,
        sceneType: 'station',
        startStationId: null,
        endStationId: null,
        profileCode: defaultProfileCode || 'default',
        memo: '',
        hard: {
            mustPassStations: [],
            forbidStations: [],
            mustPassEdges: [],
            forbidEdges: [],
            mustPassEdgesText: '',
            forbidEdgesText: ''
        },
        waypoint: {
            stations: []
        },
        soft: {
            keyStations: [],
            preferredPath: [],
            deviationWeight: 6.0,
            maxOffPathCount: 2
        },
        fallback: {
            strictWaypoint: false,
            allowSoftDegrade: true
        },
        _originCode: null
    }
}

var app = new Vue({
    el: '#app',
    data: function () {
        return {
            loading: false,
            saving: false,
            scoreMode: 'legacy',
            defaultProfileCode: 'default',
            profiles: [],
            rules: [],
            stations: [],
            levList: [],
            selectedProfileCode: '',
            selectedRuleCode: '',
            profileDialogVisible: false,
            ruleDialogVisible: false,
            profileForm: createDefaultProfile(),
            ruleForm: createDefaultRule('default'),
            previewForm: {
                startStationId: null,
                endStationId: null
            },
            previewLoading: false,
            previewResult: null,
            activeMapLev: null,
            mapContext: {
                lev: null,
                width: 0,
                height: 0,
                nodes: [],
                nodeMap: {}
            },
            mapZoomPercent: 100,
            pickedStationId: null,
            showRuleJson: false,
            showAllPathTags: false,
            softExpandLoading: false,
            mapDragActive: false,
            mapDragMoved: false,
            mapDragStartX: 0,
            mapDragStartY: 0,
            mapDragOriginPanX: 0,
            mapDragOriginPanY: 0,
            suppressNodeClick: false,
            mapPanX: 20,
            mapPanY: 20
        }
    },
    computed: {
        pickedStation: function () {
            return this.findStation(this.pickedStationId)
        },
        hasPickedStation: function () {
            return this.pickedStationId != null
        },
        stationMapById: function () {
            var map = {}
            ;(this.stations || []).forEach(function (station) {
                if (station && station.stationId != null) {
                    map[String(station.stationId)] = station
                }
            })
            return map
        },
        stationOptions: function () {
            return (this.stations || []).map(function (station) {
                return {
                    stationId: station.stationId,
                    label: this.stationOptionLabel(station)
                }
            }.bind(this))
        },
        selectedRule: function () {
            var code = this.selectedRuleCode
            if (!code) {
                return null
            }
            for (var i = 0; i < this.rules.length; i++) {
                if (this.rules[i].ruleCode === code) {
                    return this.rules[i]
                }
            }
            return null
        },
        activeRuleForVisual: function () {
            if (this.ruleDialogVisible && this.ruleForm) {
                return this.ruleForm
            }
            if (this.selectedRule) {
                return this.selectedRule
            }
            if (this.previewResult && this.previewResult.resolvedPolicy && this.previewResult.resolvedPolicy.ruleConfig) {
                return {
                    startStationId: this.previewForm.startStationId,
                    endStationId: this.previewForm.endStationId,
                    hard: this.previewResult.resolvedPolicy.ruleConfig.hard || this.defaultRule().hard,
                    waypoint: this.previewResult.resolvedPolicy.ruleConfig.waypoint || this.defaultRule().waypoint,
                    soft: this.previewResult.resolvedPolicy.ruleConfig.soft || this.defaultRule().soft,
                    fallback: this.previewResult.resolvedPolicy.ruleConfig.fallback || this.defaultRule().fallback
                }
            }
            return null
        },
        previewPathTags: function () {
            var result = this.previewResult
            if (!result || !result.pathStationIds) {
                return []
            }
            return result.pathStationIds.map(function (stationId) {
                return {
                    stationId: stationId,
                    label: this.stationLabel(stationId)
                }
            }.bind(this))
        },
        visiblePreviewPathTags: function () {
            if (this.showAllPathTags) {
                return this.previewPathTags
            }
            return this.previewPathTags.slice(0, 14)
        },
        hiddenPathTagCount: function () {
            return Math.max(this.previewPathTags.length - this.visiblePreviewPathTags.length, 0)
        },
        hasActualPath: function () {
            return !!this.actualPathPolyline
        },
        hasPreviewPath: function () {
            return !!(this.previewResult && this.previewResult.pathStationIds && this.previewResult.pathStationIds.length)
        },
        pathStationLookup: function () {
            return this.buildLookup(this.previewResult && this.previewResult.pathStationIds)
        },
        preferredStationLookup: function () {
            return this.buildLookup(this.activeRuleForVisual && this.activeRuleForVisual.soft ? this.activeRuleForVisual.soft.preferredPath : [])
        },
        waypointStationLookup: function () {
            return this.buildLookup(this.activeRuleForVisual && this.activeRuleForVisual.waypoint ? this.activeRuleForVisual.waypoint.stations : [])
        },
        forbidStationLookup: function () {
            return this.buildLookup(this.activeRuleForVisual && this.activeRuleForVisual.hard ? this.activeRuleForVisual.hard.forbidStations : [])
        },
        mustPassStationLookup: function () {
            return this.buildLookup(this.activeRuleForVisual && this.activeRuleForVisual.hard ? this.activeRuleForVisual.hard.mustPassStations : [])
        },
        renderedMapNodes: function () {
            var stationMap = this.stationMapById
            var pickedId = String(this.pickedStationId == null ? '' : this.pickedStationId)
            var startId = String(this.previewForm.startStationId == null ? '' : this.previewForm.startStationId)
            var endId = String(this.previewForm.endStationId == null ? '' : this.previewForm.endStationId)
            var pathLookup = this.pathStationLookup
            var preferredLookup = this.preferredStationLookup
            var waypointLookup = this.waypointStationLookup
            var forbidLookup = this.forbidStationLookup
            var mustPassLookup = this.mustPassStationLookup
            return (this.mapContext.nodes || []).map(function (node) {
                var stationId = node.stationId
                var key = String(stationId == null ? '' : stationId)
                var classes = []
                if (pickedId && pickedId === key) {
                    classes.push('is-picked')
                }
                if (startId && startId === key) {
                    classes.push('is-start')
                }
                if (endId && endId === key) {
                    classes.push('is-end')
                }
                if (pathLookup[key]) {
                    classes.push('is-path')
                }
                if (preferredLookup[key]) {
                    classes.push('is-preferred')
                }
                if (waypointLookup[key]) {
                    classes.push('is-waypoint')
                }
                if (forbidLookup[key]) {
                    classes.push('is-forbid')
                }
                if (mustPassLookup[key]) {
                    classes.push('is-must-pass')
                }
                var station = stationMap[key]
                return {
                    stationId: stationId,
                    x: node.x,
                    y: node.y,
                    left: node.x + 'px',
                    top: node.y + 'px',
                    classes: classes,
                    title: station ? this.stationOptionLabel(station) : String(stationId || ''),
                    showLabel: !!(startId === key || endId === key || pathLookup[key] || waypointLookup[key] || forbidLookup[key] || mustPassLookup[key] || pickedId === key)
                }
            }.bind(this))
        },
        mapStageStyle: function () {
            return {
                width: this.mapContext.width + 'px',
                height: this.mapContext.height + 'px',
                transform: 'translate(' + this.mapPanX + 'px, ' + this.mapPanY + 'px) scale(' + (this.mapZoomPercent / 100) + ')'
            }
        },
        actualPathPolyline: function () {
            var stationIds = this.previewResult && this.previewResult.pathStationIds ? this.previewResult.pathStationIds : []
            return this.buildPolyline(stationIds)
        },
        preferredPathPolyline: function () {
            var rule = this.activeRuleForVisual
            var preferredPath = rule && rule.soft ? rule.soft.preferredPath : []
            return this.buildPolyline(preferredPath)
        },
        activeRulePreviewJson: function () {
            if (!this.activeRuleForVisual) {
                return ''
            }
            return JSON.stringify(this.sanitizeRuleForSave(this.activeRuleForVisual), null, 2)
        },
        ruleDialogPickedHint: function () {
            if (!this.ruleDialogVisible) {
                return ''
            }
            if (!this.pickedStation) {
                return '规则弹窗开启时，仍可在右侧地图点击站点，再一键加入必经/禁用/途经/偏好。'
            }
            return '当前地图选中：' + this.stationOptionLabel(this.pickedStation)
        }
    },
    mounted: function () {
        this.loadData()
    },
    beforeDestroy: function () {
        this.detachMapDragListeners()
    },
    methods: {
        loadData: function () {
            var that = this
            this.loading = true
            $.ajax({
                url: baseUrl + '/basStationPathPolicy/data/auth',
                method: 'GET',
                headers: { token: localStorage.getItem('token') },
                success: function (res) {
                    that.loading = false
                    if (res.code !== 200) {
                        that.$message.error('加载失败: ' + res.msg)
                        return
                    }
                    var data = res.data || {}
                    that.scoreMode = data.scoreMode || 'legacy'
                    that.defaultProfileCode = data.defaultProfileCode || 'default'
                    that.showRuleJson = false
                    that.showAllPathTags = false
                    that.stations = (data.stations || []).sort(function (a, b) {
                        if ((a.stationLev || 0) !== (b.stationLev || 0)) {
                            return (a.stationLev || 0) - (b.stationLev || 0)
                        }
                        return (a.stationId || 0) - (b.stationId || 0)
                    })
                    that.levList = data.levList || []
                    that.profiles = (data.profiles || []).map(that.normalizeProfile)
                    that.rules = (data.rules || []).map(that.normalizeRule)
                    if (!that.defaultProfileCode && that.profiles.length) {
                        that.defaultProfileCode = that.profiles[0].profileCode
                    }
                    if (!that.selectedProfileCode && that.profiles.length) {
                        that.selectedProfileCode = that.defaultProfileCode || that.profiles[0].profileCode
                    }
                    if (!that.selectedRuleCode && that.rules.length) {
                        that.selectedRuleCode = that.rules[0].ruleCode
                    }
                    if (that.selectedRule) {
                        that.loadMapByRule(that.selectedRule)
                    } else if (that.levList.length && !that.activeMapLev) {
                        that.loadMapByLev(that.levList[0])
                    }
                },
                error: function () {
                    that.loading = false
                    that.$message.error('加载请求异常')
                }
            })
        },
        saveAll: function () {
            if (!this.profiles.length) {
                this.$message.warning('至少需要保留一个模板')
                return
            }
            var hasDefault = this.profiles.some(function (item) {
                return item.profileCode === this.defaultProfileCode
            }.bind(this))
            if (!hasDefault) {
                this.$message.warning('默认模板编码没有对应模板')
                return
            }
            var payload = {
                scoreMode: this.scoreMode,
                defaultProfileCode: this.defaultProfileCode,
                profiles: this.profiles.map(this.sanitizeProfileForSave),
                rules: this.rules.map(this.sanitizeRuleForSave)
            }
            var that = this
            this.saving = true
            $.ajax({
                url: baseUrl + '/basStationPathPolicy/save/auth',
                method: 'POST',
                headers: { token: localStorage.getItem('token') },
                contentType: 'application/json',
                data: JSON.stringify(payload),
                success: function (res) {
                    that.saving = false
                    if (res.code !== 200) {
                    that.$message.error('保存失败: ' + res.msg)
                        return
                    }
                    that.$message.success('保存成功')
                    that.loadData()
                },
                error: function () {
                    that.saving = false
                    that.$message.error('保存请求异常')
                }
            })
        },
        openProfileDialog: function (item) {
            this.profileForm = item ? this.cloneProfileModel(item) : this.defaultProfile()
            this.profileDialogVisible = true
        },
        confirmProfileDialog: function () {
            var form = this.profileForm
            if (this.isBlank(form.profileCode)) {
                this.$message.warning('模板编码不能为空')
                return
            }
            if (this.isBlank(form.profileName)) {
                this.$message.warning('模板名称不能为空')
                return
            }
            var existsIndex = this.findProfileIndex(form.profileCode)
            if (existsIndex >= 0 && (!form._originCode || form._originCode !== form.profileCode)) {
                this.$message.warning('模板编码已存在')
                return
            }
            var profile = this.cloneProfileModel(form)
            delete profile._originCode
            if (form._originCode) {
                var originIndex = this.findProfileIndex(form._originCode)
                if (originIndex >= 0) {
                    this.$set(this.profiles, originIndex, profile)
                    if (this.defaultProfileCode === form._originCode) {
                        this.defaultProfileCode = profile.profileCode
                    }
                    if (this.selectedProfileCode === form._originCode) {
                        this.selectedProfileCode = profile.profileCode
                    }
                    this.rules.forEach(function (rule) {
                        if (rule.profileCode === form._originCode) {
                            rule.profileCode = profile.profileCode
                        }
                    })
                }
            } else {
                this.profiles.push(profile)
                this.selectedProfileCode = profile.profileCode
                if (!this.defaultProfileCode) {
                    this.defaultProfileCode = profile.profileCode
                }
            }
            this.profileDialogVisible = false
        },
        cloneProfile: function (item) {
            var copy = this.cloneProfileModel(item)
            copy.profileCode = item.profileCode + '_copy'
            copy.profileName = item.profileName + ' - 副本'
            copy._originCode = null
            this.profileForm = copy
            this.profileDialogVisible = true
        },
        removeProfile: function (item) {
            if (!item) {
                return
            }
            if (this.profiles.length <= 1) {
                this.$message.warning('至少保留一个模板')
                return
            }
            var used = this.rules.some(function (rule) {
                return rule.profileCode === item.profileCode
            })
            if (used) {
                this.$message.warning('该模板仍被规则引用，不能删除')
                return
            }
            var that = this
            this.$confirm('确认删除模板 ' + item.profileCode + ' 吗？', '提示', { type: 'warning' })
                .then(function () {
                    that.profiles = that.profiles.filter(function (profile) {
                        return profile.profileCode !== item.profileCode
                    })
                    if (that.defaultProfileCode === item.profileCode) {
                        that.defaultProfileCode = that.profiles[0] ? that.profiles[0].profileCode : ''
                    }
                    if (that.selectedProfileCode === item.profileCode) {
                        that.selectedProfileCode = that.defaultProfileCode
                    }
                })
                .catch(function () {})
        },
        openRuleDialog: function (item) {
            this.ruleForm = item ? this.cloneRuleModel(item) : this.defaultRule()
            this.ruleDialogVisible = true
        },
        confirmRuleDialog: function () {
            var form = this.ruleForm
            if (this.isBlank(form.ruleCode)) {
                this.$message.warning('规则编码不能为空')
                return
            }
            if (this.isBlank(form.ruleName)) {
                this.$message.warning('规则名称不能为空')
                return
            }
            var existsIndex = this.findRuleIndex(form.ruleCode)
            if (existsIndex >= 0 && (!form._originCode || form._originCode !== form.ruleCode)) {
                this.$message.warning('规则编码已存在')
                return
            }
            var rule = this.cloneRuleModel(form)
            delete rule._originCode
            if (form._originCode) {
                var originIndex = this.findRuleIndex(form._originCode)
                if (originIndex >= 0) {
                    this.$set(this.rules, originIndex, rule)
                    if (this.selectedRuleCode === form._originCode) {
                        this.selectedRuleCode = rule.ruleCode
                    }
                }
            } else {
                this.rules.push(rule)
                this.selectedRuleCode = rule.ruleCode
            }
            this.ruleDialogVisible = false
            this.loadMapByRule(rule)
        },
        importPreviewPathToRule: function () {
            if (!this.hasPreviewPath) {
                this.$message.warning('请先在右侧完成一次路径预览')
                return
            }
            if (!this.ruleForm || !this.ruleForm.soft) {
                return
            }
            this.ruleForm.soft.preferredPath = (this.previewResult.pathStationIds || []).slice()
            this.ruleForm.soft.keyStations = []
            if (!this.ruleForm.startStationId && this.previewForm.startStationId) {
                this.ruleForm.startStationId = this.previewForm.startStationId
            }
            if (!this.ruleForm.endStationId && this.previewForm.endStationId) {
                this.ruleForm.endStationId = this.previewForm.endStationId
            }
            this.$message.success('已导入当前预览路径，共 ' + this.ruleForm.soft.preferredPath.length + ' 个站点')
        },
        expandRuleSoftPreferredPath: function () {
            if (this.softExpandLoading) {
                return
            }
            if (!this.ruleForm || !this.ruleForm.soft) {
                return
            }
            var startStationId = this.toNumberSafe(this.ruleForm.startStationId) || this.toNumberSafe(this.previewForm.startStationId)
            var endStationId = this.toNumberSafe(this.ruleForm.endStationId) || this.toNumberSafe(this.previewForm.endStationId)
            if (startStationId == null || endStationId == null) {
                this.$message.warning('请先为规则设置起点和终点，或先在右侧预览一条路径')
                return
            }
            var keyStations = this.uniqueNumbers((this.ruleForm.soft.keyStations || []).slice())
            var that = this
            this.softExpandLoading = true
            $.ajax({
                url: baseUrl + '/basStationPathPolicy/expandSoftPath/auth',
                method: 'POST',
                headers: { token: localStorage.getItem('token') },
                contentType: 'application/json',
                data: JSON.stringify({
                    startStationId: startStationId,
                    endStationId: endStationId,
                    keyStations: keyStations
                }),
                success: function (res) {
                    that.softExpandLoading = false
                    if (res.code !== 200) {
                        that.$message.error('展开失败: ' + res.msg)
                        return
                    }
                    var data = res.data || {}
                    var pathStationIds = data.pathStationIds || []
                    if (!pathStationIds.length) {
                        that.$message.warning('没有生成可用的软偏好路径')
                        return
                    }
                    that.ruleForm.startStationId = startStationId
                    that.ruleForm.endStationId = endStationId
                    that.ruleForm.soft.keyStations = keyStations
                    that.ruleForm.soft.preferredPath = pathStationIds.slice()
                    that.$message.success(keyStations.length
                        ? '已按关键点展开完整软偏好路径'
                        : '已按起终点生成完整软偏好路径')
                },
                error: function () {
                    that.softExpandLoading = false
                    that.$message.error('展开软偏好路径请求异常')
                }
            })
        },
        clearSoftPreferredPath: function () {
            if (!this.ruleForm || !this.ruleForm.soft) {
                return
            }
            this.ruleForm.soft.keyStations = []
            this.ruleForm.soft.preferredPath = []
        },
        cloneRule: function (item) {
            var copy = this.cloneRuleModel(item)
            copy.ruleCode = item.ruleCode + '_copy'
            copy.ruleName = item.ruleName + ' - 副本'
            copy._originCode = null
            this.ruleForm = copy
            this.ruleDialogVisible = true
        },
        removeRule: function (item) {
            var that = this
            this.$confirm('确认删除规则 ' + item.ruleCode + ' 吗？', '提示', { type: 'warning' })
                .then(function () {
                    that.rules = that.rules.filter(function (rule) {
                        return rule.ruleCode !== item.ruleCode
                    })
                    if (that.selectedRuleCode === item.ruleCode) {
                        that.selectedRuleCode = that.rules[0] ? that.rules[0].ruleCode : ''
                    }
                })
                .catch(function () {})
        },
        selectRule: function (item) {
            this.selectedRuleCode = item.ruleCode
            this.loadMapByRule(item)
        },
        previewRule: function (item) {
            this.selectRule(item)
            this.previewForm.startStationId = item.startStationId
            this.previewForm.endStationId = item.endStationId
            this.showRuleJson = false
            this.showAllPathTags = false
            if (item.startStationId && item.endStationId) {
                this.loadPreview()
            }
        },
        loadPreview: function () {
            if (!this.previewForm.startStationId || !this.previewForm.endStationId) {
                this.$message.warning('请选择起点和终点')
                return
            }
            var that = this
            this.previewLoading = true
            $.ajax({
                url: baseUrl + '/basStationPathPolicy/preview/auth',
                method: 'GET',
                headers: { token: localStorage.getItem('token') },
                data: {
                    startStationId: this.previewForm.startStationId,
                    endStationId: this.previewForm.endStationId
                },
                success: function (res) {
                    that.previewLoading = false
                    if (res.code !== 200) {
                        that.$message.error('预览失败: ' + res.msg)
                        return
                    }
                    that.showRuleJson = false
                    that.showAllPathTags = false
                    that.previewResult = res.data || null
                    if (that.previewResult && that.previewResult.lev) {
                        that.activeMapLev = that.previewResult.lev
                    }
                    if (that.previewResult && that.previewResult.mapData) {
                        that.applyMapData(that.previewResult.mapData, that.previewResult.lev)
                    } else if (that.activeMapLev && that.mapContext.lev !== that.activeMapLev) {
                        that.loadMapByLev(that.activeMapLev)
                    }
                    that.$nextTick(function () {
                        that.centerOnPath()
                    })
                    if (!that.hasActualPath) {
                        that.$message.warning('当前起终点未计算到可行路径，请检查规则或楼层地图')
                    }
                },
                error: function () {
                    that.previewLoading = false
                    that.$message.error('预览请求异常')
                }
            })
        },
        loadMapByRule: function (rule) {
            if (!rule) {
                return
            }
            var station = this.findStation(rule.startStationId || rule.endStationId)
            if (station && station.stationLev && this.mapContext.lev !== station.stationLev) {
                this.loadMapByLev(station.stationLev)
            }
        },
        loadMapByLev: function (lev) {
            if (!lev) {
                return
            }
            if (this.mapContext.lev === lev && this.mapContext.nodes && this.mapContext.nodes.length) {
                return
            }
            var that = this
            $.ajax({
                url: baseUrl + '/basMap/lev/' + lev + '/auth',
                method: 'GET',
                headers: { token: localStorage.getItem('token') },
                success: function (res) {
                    if (res.code !== 200) {
                        that.$message.error('加载楼层地图失败: ' + res.msg)
                        return
                    }
                    that.applyMapData(res.data, lev)
                },
                error: function () {
                    that.$message.error('加载楼层地图请求异常')
                }
            })
        },
        applyMapData: function (mapData, lev) {
            var parsed = mapData
            if (typeof mapData === 'string') {
                try {
                    parsed = JSON.parse(mapData)
                } catch (e) {
                    parsed = []
                }
            }
            if (!Array.isArray(parsed)) {
                this.mapContext = { lev: lev, width: 0, height: 0, nodes: [], nodeMap: {} }
                return
            }
            var cellStep = 26
            var margin = 22
            var nodes = []
            var nodeMap = {}
            var rows = parsed.length
            var cols = 0
            for (var r = 0; r < parsed.length; r++) {
                var row = parsed[r] || []
                cols = Math.max(cols, row.length)
                for (var c = 0; c < row.length; c++) {
                    var cell = row[c] || {}
                    var type = cell.type
                    var mergeType = cell.mergeType
                    if (!(type === 'devp' || (type === 'merge' && mergeType === 'devp'))) {
                        continue
                    }
                    var value = this.parseJson(cell.value)
                    var stationId = value ? value.stationId : null
                    if (!stationId) {
                        continue
                    }
                    var node = {
                        stationId: stationId,
                        row: r,
                        col: c,
                        x: margin + c * cellStep,
                        y: margin + r * cellStep,
                        stationAlias: value.stationAlias || '',
                        isLiftTransfer: value.isLiftTransfer === 1 || value.isLiftTransfer === true
                    }
                    nodes.push(node)
                    nodeMap[String(stationId)] = node
                }
            }
            this.mapContext = {
                lev: lev,
                width: margin * 2 + Math.max(cols - 1, 0) * cellStep + 40,
                height: margin * 2 + Math.max(rows - 1, 0) * cellStep + 40,
                nodes: nodes,
                nodeMap: nodeMap
            }
            this.fitMap()
        },
        fitMap: function () {
            var wrap = this.$refs.mapCanvasWrap
            if (!wrap || !this.mapContext.width || !this.mapContext.height) {
                return
            }
            var bounds = this.getMapContentBounds()
            var contentWidth = Math.max((bounds.maxX - bounds.minX), 1)
            var contentHeight = Math.max((bounds.maxY - bounds.minY), 1)
            var usableWidth = Math.max(wrap.clientWidth - 30, 320)
            var usableHeight = Math.max(wrap.clientHeight - 30, 240)
            var scaleX = usableWidth / contentWidth
            var scaleY = usableHeight / contentHeight
            var scale = Math.min(scaleX, scaleY, 1.7)
            var zoomPercent = Math.max(60, Math.min(220, Math.floor(scale * 100)))
            var centerX = (bounds.minX + bounds.maxX) / 2
            var centerY = (bounds.minY + bounds.maxY) / 2
            this.mapZoomPercent = zoomPercent
            this.mapPanX = Math.round(wrap.clientWidth / 2 - centerX * (zoomPercent / 100))
            this.mapPanY = Math.round(wrap.clientHeight / 2 - centerY * (zoomPercent / 100))
        },
        centerOnPath: function () {
            var wrap = this.$refs.mapCanvasWrap
            var stage = this.$refs.mapStage
            if (!wrap || !stage || !this.actualPathPolyline) {
                return
            }
            var stationIds = this.previewResult && this.previewResult.pathStationIds ? this.previewResult.pathStationIds : []
            var points = this.resolvePoints(stationIds)
            if (!points.length) {
                return
            }
            var minX = points[0].x
            var maxX = points[0].x
            var minY = points[0].y
            var maxY = points[0].y
            points.forEach(function (point) {
                minX = Math.min(minX, point.x)
                maxX = Math.max(maxX, point.x)
                minY = Math.min(minY, point.y)
                maxY = Math.max(maxY, point.y)
            })
            var scale = this.mapZoomPercent / 100
            this.mapPanX = Math.round(wrap.clientWidth / 2 - ((minX + maxX) / 2) * scale)
            this.mapPanY = Math.round(wrap.clientHeight / 2 - ((minY + maxY) / 2) * scale)
        },
        resetPreview: function () {
            this.previewForm.startStationId = null
            this.previewForm.endStationId = null
            this.previewResult = null
            this.pickedStationId = null
            this.showRuleJson = false
            this.showAllPathTags = false
        },
        updateMapZoom: function (nextPercent) {
            var wrap = this.$refs.mapCanvasWrap
            var zoomPercent = this.toNumberSafe(nextPercent)
            if (zoomPercent == null) {
                return
            }
            zoomPercent = Math.max(60, Math.min(220, zoomPercent))
            if (!wrap || !this.mapContext.width || !this.mapContext.height) {
                this.mapZoomPercent = zoomPercent
                return
            }
            this.setMapZoomAroundPoint(zoomPercent, wrap.clientWidth / 2, wrap.clientHeight / 2)
        },
        setMapZoomAroundPoint: function (nextPercent, anchorX, anchorY) {
            var currentPercent = this.mapZoomPercent
            if (!currentPercent || currentPercent === nextPercent) {
                this.mapZoomPercent = nextPercent
                return
            }
            var currentScale = currentPercent / 100
            var nextScale = nextPercent / 100
            if (!currentScale || !nextScale) {
                this.mapZoomPercent = nextPercent
                return
            }
            var mapX = (anchorX - this.mapPanX) / currentScale
            var mapY = (anchorY - this.mapPanY) / currentScale
            this.mapZoomPercent = nextPercent
            this.mapPanX = Math.round(anchorX - mapX * nextScale)
            this.mapPanY = Math.round(anchorY - mapY * nextScale)
        },
        handleMapWheel: function (event) {
            if (!this.mapContext.nodes.length) {
                return
            }
            if (event.ctrlKey || event.metaKey) {
                var wrap = this.$refs.mapCanvasWrap
                if (!wrap) {
                    return
                }
                var rect = wrap.getBoundingClientRect()
                var delta = event.deltaY < 0 ? 10 : -10
                var nextPercent = Math.max(60, Math.min(220, this.mapZoomPercent + delta))
                this.setMapZoomAroundPoint(nextPercent, event.clientX - rect.left, event.clientY - rect.top)
                return
            }
            this.mapPanX -= event.deltaX
            this.mapPanY -= event.deltaY
        },
        beginMapDrag: function (event) {
            var wrap = this.$refs.mapCanvasWrap
            if (!wrap || !this.mapContext.nodes.length) {
                return
            }
            if (event && event.button != null && event.button !== 0) {
                return
            }
            this.mapDragActive = true
            this.mapDragMoved = false
            this.mapDragStartX = event.clientX
            this.mapDragStartY = event.clientY
            this.mapDragOriginPanX = this.mapPanX
            this.mapDragOriginPanY = this.mapPanY
            document.addEventListener('mousemove', this.handleMapDragMove)
            document.addEventListener('mouseup', this.endMapDrag)
            if (event.preventDefault) {
                event.preventDefault()
            }
        },
        handleMapDragMove: function (event) {
            if (!this.mapDragActive) {
                return
            }
            var wrap = this.$refs.mapCanvasWrap
            if (!wrap) {
                this.endMapDrag()
                return
            }
            var deltaX = event.clientX - this.mapDragStartX
            var deltaY = event.clientY - this.mapDragStartY
            if (Math.abs(deltaX) > 3 || Math.abs(deltaY) > 3) {
                this.mapDragMoved = true
            }
            this.mapPanX = this.mapDragOriginPanX + deltaX
            this.mapPanY = this.mapDragOriginPanY + deltaY
        },
        endMapDrag: function () {
            if (!this.mapDragActive) {
                this.detachMapDragListeners()
                return
            }
            this.mapDragActive = false
            this.detachMapDragListeners()
            if (this.mapDragMoved) {
                this.suppressNodeClick = true
                var that = this
                window.setTimeout(function () {
                    that.suppressNodeClick = false
                }, 0)
            }
        },
        detachMapDragListeners: function () {
            document.removeEventListener('mousemove', this.handleMapDragMove)
            document.removeEventListener('mouseup', this.endMapDrag)
        },
        pickNode: function (node) {
            if (this.suppressNodeClick) {
                return
            }
            this.pickedStationId = node.stationId
        },
        applyPickedStation: function (field) {
            if (!this.pickedStationId) {
                return
            }
            if (field === 'start') {
                this.previewForm.startStationId = this.pickedStationId
            } else if (field === 'end') {
                this.previewForm.endStationId = this.pickedStationId
            } else if (field === 'ruleStart' && this.ruleForm) {
                this.ruleForm.startStationId = this.pickedStationId
            } else if (field === 'ruleEnd' && this.ruleForm) {
                this.ruleForm.endStationId = this.pickedStationId
            } else if (field === 'mustPass' && this.ruleForm) {
                this.pushUniqueStation(this.ruleForm.hard.mustPassStations, this.pickedStationId)
            } else if (field === 'forbid' && this.ruleForm) {
                this.pushUniqueStation(this.ruleForm.hard.forbidStations, this.pickedStationId)
            } else if (field === 'waypoint' && this.ruleForm) {
                this.pushUniqueStation(this.ruleForm.waypoint.stations, this.pickedStationId)
            } else if (field === 'preferred' && this.ruleForm) {
                this.pushUniqueStation(this.ruleForm.soft.preferredPath, this.pickedStationId)
            }
        },
        pushUniqueStation: function (list, stationId) {
            if (!Array.isArray(list)) {
                return
            }
            var value = this.toNumberSafe(stationId)
            if (value == null) {
                return
            }
            var exists = list.some(function (item) {
                return String(item) === String(value)
            })
            if (!exists) {
                list.push(value)
            }
        },
        moveListItem: function (list, index, offset) {
            if (!Array.isArray(list)) {
                return
            }
            var targetIndex = index + offset
            if (index < 0 || targetIndex < 0 || index >= list.length || targetIndex >= list.length) {
                return
            }
            var moved = list.splice(index, 1)[0]
            list.splice(targetIndex, 0, moved)
        },
        removeListItem: function (list, index) {
            if (!Array.isArray(list) || index < 0 || index >= list.length) {
                return
            }
            list.splice(index, 1)
        },
        buildLookup: function (list) {
            var lookup = {}
            ;(list || []).forEach(function (item) {
                if (item != null && item !== '') {
                    lookup[String(item)] = true
                }
            })
            return lookup
        },
        nodeStyle: function (node) {
            return {
                left: node.x + 'px',
                top: node.y + 'px'
            }
        },
        nodeClasses: function (node) {
            var stationId = node.stationId
            var classes = []
            if (String(this.pickedStationId || '') === String(stationId)) {
                classes.push('is-picked')
            }
            if (this.previewForm.startStationId === stationId) {
                classes.push('is-start')
            }
            if (this.previewForm.endStationId === stationId) {
                classes.push('is-end')
            }
            if (this.pathStationSet()[stationId]) {
                classes.push('is-path')
            }
            if (this.preferredStationSet()[stationId]) {
                classes.push('is-preferred')
            }
            if (this.waypointStationSet()[stationId]) {
                classes.push('is-waypoint')
            }
            if (this.forbidStationSet()[stationId]) {
                classes.push('is-forbid')
            }
            if (this.mustPassStationSet()[stationId]) {
                classes.push('is-must-pass')
            }
            return classes
        },
        showNodeLabel: function (node) {
            var stationId = node.stationId
            return !!(
                this.previewForm.startStationId === stationId
                || this.previewForm.endStationId === stationId
                || this.pathStationSet()[stationId]
                || this.waypointStationSet()[stationId]
                || this.forbidStationSet()[stationId]
                || this.mustPassStationSet()[stationId]
                || String(this.pickedStationId || '') === String(stationId)
            )
        },
        stationNodeTitle: function (node) {
            return this.stationLabel(node.stationId)
        },
        stationOptionLabel: function (station) {
            if (!station) {
                return ''
            }
            var alias = station.stationAlias ? ' · ' + station.stationAlias : ''
            return 'L' + (station.stationLev || '-') + ' · ' + station.stationId + alias
        },
        stationLabel: function (stationId) {
            var station = this.findStation(stationId)
            return station ? this.stationOptionLabel(station) : String(stationId || '')
        },
        findStation: function (stationId) {
            if (stationId == null) {
                return null
            }
            return this.stationMapById[String(stationId)] || null
        },
        routeLabel: function (rule) {
            if (!rule.startStationId && !rule.endStationId) {
                return '通配规则'
            }
            return (rule.startStationId || '*') + ' → ' + (rule.endStationId || '*')
        },
        ruleSummaryCount: function (hard) {
            hard = hard || {}
            return (hard.mustPassStations || []).length
                + (hard.forbidStations || []).length
                + (hard.mustPassEdges || []).length
                + (hard.forbidEdges || []).length
        },
        pathStationSet: function () {
            return this.pathStationLookup
        },
        preferredStationSet: function () {
            return this.preferredStationLookup
        },
        waypointStationSet: function () {
            return this.waypointStationLookup
        },
        forbidStationSet: function () {
            return this.forbidStationLookup
        },
        mustPassStationSet: function () {
            return this.mustPassStationLookup
        },
        buildPolyline: function (stationIds) {
            var points = this.resolvePoints(stationIds)
            if (!points.length) {
                return ''
            }
            return points.map(function (point) {
                return point.x + ',' + point.y
            }).join(' ')
        },
        resolvePoints: function (stationIds) {
            var points = []
            var map = this.mapContext.nodeMap || {}
            ;(stationIds || []).forEach(function (stationId) {
                var node = map[String(stationId)]
                if (node) {
                    points.push({ x: node.x, y: node.y })
                }
            })
            return points
        },
        getMapContentBounds: function () {
            var nodes = this.mapContext && this.mapContext.nodes ? this.mapContext.nodes : []
            if (!nodes.length) {
                return {
                    minX: 0,
                    maxX: this.mapContext.width || 0,
                    minY: 0,
                    maxY: this.mapContext.height || 0
                }
            }
            var minX = null
            var maxX = null
            var minY = null
            var maxY = null
            nodes.forEach(function (node) {
                if (!node) {
                    return
                }
                minX = minX == null ? node.x : Math.min(minX, node.x)
                maxX = maxX == null ? node.x : Math.max(maxX, node.x)
                minY = minY == null ? node.y : Math.min(minY, node.y)
                maxY = maxY == null ? node.y : Math.max(maxY, node.y)
            })
            var padding = 48
            return {
                minX: Math.max((minX == null ? 0 : minX) - padding, 0),
                maxX: Math.min((maxX == null ? 0 : maxX) + padding, this.mapContext.width || Number.MAX_SAFE_INTEGER),
                minY: Math.max((minY == null ? 0 : minY) - padding, 0),
                maxY: Math.min((maxY == null ? 0 : maxY) + padding, this.mapContext.height || Number.MAX_SAFE_INTEGER)
            }
        },
        defaultProfileConfig: function () {
            return createDefaultProfileConfig()
        },
        defaultProfile: function () {
            return createDefaultProfile()
        },
        defaultRule: function () {
            return createDefaultRule(this.defaultProfileCode || 'default')
        },
        normalizeProfile: function (raw) {
            var config = Object.assign({}, this.defaultProfileConfig(), this.parseJson(raw.configJson) || raw.config || {})
            return {
                id: raw.id || null,
                profileCode: raw.profileCode || '',
                profileName: raw.profileName || raw.profileCode || '',
                priority: raw.priority == null ? 100 : Number(raw.priority),
                status: raw.status == null ? 1 : Number(raw.status),
                memo: raw.memo || '',
                config: config
            }
        },
        normalizeRule: function (raw) {
            var rule = this.defaultRule()
            var hard = Object.assign({}, rule.hard, this.parseJson(raw.hardJson) || raw.hard || {})
            var waypoint = Object.assign({}, rule.waypoint, this.parseJson(raw.waypointJson) || raw.waypoint || {})
            var soft = Object.assign({}, rule.soft, this.parseJson(raw.softJson) || raw.soft || {})
            var fallback = Object.assign({}, rule.fallback, this.parseJson(raw.fallbackJson) || raw.fallback || {})
            hard.mustPassEdgesText = (hard.mustPassEdges || []).join('\n')
            hard.forbidEdgesText = (hard.forbidEdges || []).join('\n')
            rule.id = raw.id || null
            rule.ruleCode = raw.ruleCode || ''
            rule.ruleName = raw.ruleName || raw.ruleCode || ''
            rule.priority = raw.priority == null ? 100 : Number(raw.priority)
            rule.status = raw.status == null ? 1 : Number(raw.status)
            rule.sceneType = raw.sceneType || 'station'
            rule.startStationId = raw.startStationId == null ? null : Number(raw.startStationId)
            rule.endStationId = raw.endStationId == null ? null : Number(raw.endStationId)
            rule.profileCode = raw.profileCode || ''
            rule.memo = raw.memo || ''
            rule.hard = hard
            rule.waypoint = waypoint
            rule.soft = soft
            rule.fallback = fallback
            return rule
        },
        cloneProfileModel: function (item) {
            var model = this.normalizeProfile(item)
            model._originCode = item.profileCode || item._originCode || null
            return JSON.parse(JSON.stringify(model))
        },
        cloneRuleModel: function (item) {
            var model = this.normalizeRule(item)
            model._originCode = item.ruleCode || item._originCode || null
            return JSON.parse(JSON.stringify(model))
        },
        sanitizeProfileForSave: function (item) {
            return {
                id: item.id || null,
                profileCode: item.profileCode,
                profileName: item.profileName,
                priority: Number(item.priority || 100),
                status: Number(item.status || 0),
                memo: item.memo || '',
                config: Object.assign({}, item.config || {})
            }
        },
        sanitizeRuleForSave: function (item) {
            var hard = Object.assign({}, item.hard || {})
            hard.mustPassEdges = this.parseLines(hard.mustPassEdgesText || hard.mustPassEdges || [])
            hard.forbidEdges = this.parseLines(hard.forbidEdgesText || hard.forbidEdges || [])
            delete hard.mustPassEdgesText
            delete hard.forbidEdgesText
            return {
                id: item.id || null,
                ruleCode: item.ruleCode,
                ruleName: item.ruleName,
                priority: Number(item.priority || 100),
                status: Number(item.status || 0),
                sceneType: item.sceneType || '',
                startStationId: item.startStationId == null ? null : Number(item.startStationId),
                endStationId: item.endStationId == null ? null : Number(item.endStationId),
                profileCode: item.profileCode || '',
                memo: item.memo || '',
                hard: {
                    mustPassStations: this.uniqueNumbers(hard.mustPassStations || []),
                    forbidStations: this.uniqueNumbers(hard.forbidStations || []),
                    mustPassEdges: hard.mustPassEdges,
                    forbidEdges: hard.forbidEdges
                },
                waypoint: {
                    stations: this.uniqueNumbers((item.waypoint && item.waypoint.stations) || [])
                },
                soft: {
                    keyStations: this.uniqueNumbers((item.soft && item.soft.keyStations) || []),
                    preferredPath: this.uniqueNumbers((item.soft && item.soft.preferredPath) || []),
                    deviationWeight: this.toNumberSafe(item.soft && item.soft.deviationWeight) || 0,
                    maxOffPathCount: this.toNumberSafe(item.soft && item.soft.maxOffPathCount) || 0
                },
                fallback: {
                    strictWaypoint: !!(item.fallback && item.fallback.strictWaypoint),
                    allowSoftDegrade: !(item.fallback && item.fallback.allowSoftDegrade === false)
                }
            }
        },
        findProfileIndex: function (profileCode) {
            for (var i = 0; i < this.profiles.length; i++) {
                if (this.profiles[i].profileCode === profileCode) {
                    return i
                }
            }
            return -1
        },
        findRuleIndex: function (ruleCode) {
            for (var i = 0; i < this.rules.length; i++) {
                if (this.rules[i].ruleCode === ruleCode) {
                    return i
                }
            }
            return -1
        },
        parseJson: function (value) {
            if (!value) {
                return null
            }
            if (typeof value === 'object') {
                return value
            }
            try {
                return JSON.parse(value)
            } catch (e) {
                return null
            }
        },
        parseLines: function (value) {
            if (Array.isArray(value)) {
                return value.filter(function (item) { return !!String(item || '').trim() })
            }
            return String(value || '')
                .split('\n')
                .map(function (item) { return item.trim() })
                .filter(function (item) { return !!item })
        },
        toNumberSafe: function (value) {
            if (value == null || value === '') {
                return null
            }
            var num = Number(value)
            return isNaN(num) ? null : num
        },
        notNull: function (value) {
            return value != null
        },
        uniqueNumbers: function (list) {
            var result = []
            var seen = {}
            ;(list || []).forEach(function (item) {
                var num = this.toNumberSafe(item)
                if (num == null) {
                    return
                }
                if (!seen[String(num)]) {
                    seen[String(num)] = true
                    result.push(num)
                }
            }.bind(this))
            return result
        },
        isBlank: function (text) {
            return text == null || String(text).trim() === ''
        }
    }
})