<template>
    <div class="bit-selection-info">
        <!-- 页面头部 -->
        <div class="page-header" v-if="!hideHeader">
            <div class="header-content">
                <div class="bit-basic-info">
                    <span>钻头型号: {{ getCurrentValue('ztxh') }}</span>
                    <span>尺寸mm: {{ getCurrentValue('ztcc') }}mm</span>
                    <span>类别: {{ getCurrentValue('ztlb') }}</span>
                    <span>编号: {{ getCurrentValue('ztbh') }}</span>
                </div>
            </div>
            <!-- <div class="header-actions">
                <el-button size="small" @click="handleModify">修改</el-button>
                <el-button size="small" @click="handleDigitalize">数字化</el-button>
                <el-button size="small" @click="handleDelete">删除</el-button>
                <el-button size="small" @click="handleReturn">返回</el-button>
            </div> -->
        </div>

        <!-- 匹配状态表格 -->
        <div class="matching-table">
            <el-table :data="[bitData || bitInfo]" border fit style="width: 100%; margin-bottom: 10px;"
                class="match-status-table">
                <el-table-column label="刀翼总数" min-width="120" align="center">
                    <template slot-scope="scope">
                        <span v-if="showValues" class="value-text">
                            {{ getCurrentValue('tzdm01') || '--' }}
                        </span>
                        <span v-else :class="['status-icon', isMatchStatus(scope.row.t01match) ? 'match' : 'no-match']">
                            {{ isMatchStatus(scope.row.t01match) ? '✓' : '✗' }}
                        </span>
                    </template>
                </el-table-column>
                <el-table-column label="布齿密度" min-width="120" align="center">
                    <template slot-scope="scope">
                        <span v-if="showValues" class="value-text">
                            {{ getCurrentValue('tzdm02') || '--' }}
                        </span>
                        <span v-else :class="['status-icon', isMatchStatus(scope.row.t02match) ? 'match' : 'no-match']">
                            {{ isMatchStatus(scope.row.t02match) ? '✓' : '✗' }}
                        </span>
                    </template>
                </el-table-column>
                <el-table-column label="切削齿尺寸mm" min-width="140" align="center">
                    <template slot-scope="scope">
                        <span v-if="showValues" class="value-text">
                            {{ getCurrentValue('tzdm03') || '--' }}
                        </span>
                        <span v-else :class="['status-icon', isMatchStatus(scope.row.t03match) ? 'match' : 'no-match']">
                            {{ isMatchStatus(scope.row.t03match) ? '✓' : '✗' }}
                        </span>
                    </template>
                </el-table-column>
                <el-table-column label="切削齿后倾角°" min-width="140" align="center">
                    <template slot-scope="scope">
                        <span v-if="showValues" class="value-text">
                            {{ getCurrentValue('tzdm04') || '--' }}
                        </span>
                        <span v-else :class="['status-icon', isMatchStatus(scope.row.t04match) ? 'match' : 'no-match']">
                            {{ isMatchStatus(scope.row.t04match) ? '✓' : '✗' }}
                        </span>
                    </template>
                </el-table-column>
                <el-table-column label="冠部轮廓" min-width="120" align="center">
                    <template slot-scope="scope">
                        <span v-if="showValues" class="value-text">
                            {{ getCurrentValue('tzdm05') || '--' }}
                        </span>
                        <span v-else :class="['status-icon', isMatchStatus(scope.row.t05match) ? 'match' : 'no-match']">
                            {{ isMatchStatus(scope.row.t05match) ? '✓' : '✗' }}
                        </span>
                    </template>
                </el-table-column>
                <!-- <el-table-column label="保径" min-width="100" align="center">
                    <template slot-scope="scope">
                        <span v-if="showValues" class="value-text">
                            {{ getCurrentValue('tzdm06') || '--' }}
                        </span>
                        <span v-else :class="['status-icon', isMatchStatus(scope.row.t06match) ? 'match' : 'no-match']">
                            {{ isMatchStatus(scope.row.t06match) ? '✓' : '✗' }}
                        </span>
                    </template>
                </el-table-column> -->
            </el-table>
        </div>
        <!-- 详细参数和图片 -->
        <div class="parameters-section">
            <div class="parameter-row">
                <div v-for="(item, index) in availableParameters" :key="index" class="parameter-item">
                    <!-- 左侧：参数名称 -->
                    <div class="parameter-label">
                        <h4>{{ item.tzdl }}:</h4>
                    </div>
                    <!-- 右侧：图片列表横向排列 -->
                    <div class="parameter-images-container">
                        <!-- 如果有多个图片，循环显示 -->
                        <div v-if="getImageList(item).length > 0" class="parameter-images-list">
                            <div v-for="(imgItem, imgIndex) in getImageList(item)" :key="imgIndex"
                                class="parameter-image-item">
                                <div class="parameter-image">
                                    <img :src="imgItem.slt" :alt="imgItem.tzxl || item.tzdl" v-if="imgItem.slt" />
                                    <div v-else class="no-image">暂无图片</div>
                                </div>
                                <div class="parameter-name" v-if="imgItem.tzxl">
                                    {{ imgItem.tzxl }}
                                </div>
                            </div>
                        </div>
                        <!-- 如果没有图片列表，显示单个图片（兼容旧数据） -->
                        <div v-else class="parameter-image-single">
                            <div class="parameter-image">
                                <img :src="getCurrentValue(item.imageField)"
                                    :alt="getCurrentValue(item.nameField) || item.tzdl"
                                    v-if="getCurrentValue(item.imageField)" />
                                <div v-else class="no-image">暂无图片</div>
                            </div>
                        </div>
                    </div>
                </div>
            </div>
        </div>

        <!-- 底部操作按钮 -->
        <div class="footer-actions">
            <el-button @click="handleClose">关闭</el-button>
        </div>
    </div>
</template>

<script>
import { getZtxxJcxx } from '@/api/ztxx'

export default {
    name: 'BitSelectionInfo',
    props: {
        bitData: {
            type: Object,
            default: () => ({
                model: 'HJT537GL',
                size: 150,
                category: 'PDC钻头',
                number: 1
            })
        },
        bitId: {
            type: String,
            default: ''
        },
        hideHeader: {
            type: Boolean,
            default: false
        },
        showValues: {
            type: Boolean,
            default: false
        }
    },
    created() {
        // 优先使用props传入的bitData
        if (this.bitData && Object.keys(this.bitData).length > 1) {
            console.log('使用props传入的钻头数据:', this.bitData)
            this.updateBitInfo(this.bitData)
        } else if (this.$route.params.bitData) {
            // 从路由参数获取钻头数据
            this.bitInfo = {
                ...this.bitInfo,
                ...this.$route.params.bitData
            }
        } else if (this.bitId || this.$route.query.id) {
            // 如果没有直接传入数据，则调用API获取
            this.fetchBitDetails()
        }
    },
    data() {
        return {
            // API返回的详细数据
            apiData: null,
            // 参数类型定义
            parameterTypes: [
                { tzdl: '刀翼总数', field: 'tzdm01', imageField: 'slt01', matchField: 't01match', nameField: 'tzxl01' },
                { tzdl: '布齿密度', field: 'tzdm02', imageField: 'slt02', matchField: 't02match', nameField: 'tzxl02' },
                { tzdl: '切削齿尺寸mm', field: 'tzdm03', imageField: 'slt03', matchField: 't03match', nameField: 'tzxl03' },
                { tzdl: '切削齿后倾角°', field: 'tzdm04', imageField: 'slt04', matchField: 't04match', nameField: 'tzxl04' },
                { tzdl: '冠部轮廓', field: 'tzdm05', imageField: 'slt05', matchField: 't05match', nameField: 'tzxl05' },
                // { tzdl: '保径', field: 'tzdm06', imageField: 'slt06', matchField: 't06match', nameField: 'tzxl06' }
            ],
            bitInfo: {
                // 基本信息
                ztxh: '',  // 钻头型号
                ztcc: '',  // 钻头尺寸
                ztlb: '',  // 钻头类别
                ztbh: '',  // 钻头编号
                // 参数值
                tzdm01: '', // 刀翼总数
                tzdm02: '', // 布齿密度
                tzdm03: '', // 切削齿尺寸
                tzdm04: '', // 切削齿后倾角
                tzdm05: '', // 冠部轮廓
                tzdm06: '', // 保径
                // 图片
                slt01: '', // 刀翼总数图片
                slt02: '', // 布齿密度图片
                slt03: '', // 切削齿尺寸图片
                slt04: '', // 切削齿后倾角图片
                slt05: '', // 冠部轮廓图片
                slt06: '', // 保径图片
                // 图片名称
                tzxl01: '', // 刀翼总数图片名称
                tzxl02: '', // 布齿密度图片名称
                tzxl03: '', // 切削齿尺寸图片名称
                tzxl04: '', // 切削齿后倾角图片名称
                tzxl05: '', // 冠部轮廓图片名称
                tzxl06: '', // 保径图片名称
                // 图片列表（支持多个图片）
                slt01List: [], // 刀翼总数图片列表
                slt02List: [], // 布齿密度图片列表
                slt03List: [], // 切削齿尺寸图片列表
                slt04List: [], // 切削齿后倾角图片列表
                slt05List: [], // 冠部轮廓图片列表
                slt06List: [], // 保径图片列表
                // 匹配状态
                t01match: '', // 刀翼总数匹配状态
                t02match: '', // 布齿密度匹配状态
                t03match: '', // 切削齿尺寸匹配状态
                t04match: '', // 切削齿后倾角匹配状态
                t05match: '', // 冠部轮廓匹配状态
                t06match: ''  // 保径匹配状态
            }
        }
    },
    computed: {
        // 显示所有参数（因为传入的数据中都有图片链接）
        availableParameters() {
            return this.parameterTypes
        }
    },
    watch: {
        // 监听bitData变化，当传入新数据时更新显示
        bitData: {
            handler(newData) {
                if (newData && Object.keys(newData).length > 1) {
                    console.log('监听到bitData变化:', newData)
                    this.updateBitInfo(newData)
                }
            },
            immediate: true,
            deep: true
        },
        // 监听bitId变化，当从弹窗传入新的ID时重新获取数据
        bitId: {
            handler(newId) {
                if (newId && (!this.bitData || Object.keys(this.bitData).length <= 1)) {
                    this.fetchBitDetails()
                }
            },
            immediate: true
        }
    },
    methods: {
        // 获取钻头详细信息
        fetchBitDetails() {
            // 优先使用props传入的bitId，其次使用路由参数中的id
            const id = this.bitId || this.$route.query.id
            if (!id) {
                console.warn('没有钻头ID，无法获取详细信息')
                return
            }

            console.log('调用getZtxxJcxx接口，ID:', id)

            getZtxxJcxx(id).then(response => {
                console.log('getZtxxJcxx接口返回数据:', response)
                this.apiData = response

                // 如果需要，可以根据API返回的数据更新bitInfo
                if (response && response.data) {
                    this.updateBitInfo(response.data)
                }

            }).catch(error => {
                console.error('调用getZtxxJcxx接口失败:', error)
                this.$message.error('获取钻头详细信息失败，请重试')
            })
        },

        // 更新钻头信息
        updateBitInfo(data) {
            console.log('更新钻头信息:', data)

            // 更新基本信息
            this.bitInfo.ztxh = data.ztxh || ''
            this.bitInfo.ztcc = data.ztcc || ''
            this.bitInfo.ztlb = data.ztlb || ''
            this.bitInfo.ztbh = data.ztbh || ''

            // 更新参数值
            this.bitInfo.tzdm01 = data.tzdm01 || ''
            this.bitInfo.tzdm02 = data.tzdm02 || ''
            this.bitInfo.tzdm03 = data.tzdm03 || ''
            this.bitInfo.tzdm04 = data.tzdm04 || ''
            this.bitInfo.tzdm05 = data.tzdm05 || ''
            this.bitInfo.tzdm06 = data.tzdm06 || ''

            // 更新图片
            this.bitInfo.slt01 = data.slt01 || ''
            this.bitInfo.slt02 = data.slt02 || ''
            this.bitInfo.slt03 = data.slt03 || ''
            this.bitInfo.slt04 = data.slt04 || ''
            this.bitInfo.slt05 = data.slt05 || ''
            this.bitInfo.slt06 = data.slt06 || ''

            // 更新图片名称 (tzxl)
            this.bitInfo.tzxl01 = data.tzxl01 || ''
            this.bitInfo.tzxl02 = data.tzxl02 || ''
            this.bitInfo.tzxl03 = data.tzxl03 || ''
            this.bitInfo.tzxl04 = data.tzxl04 || ''
            this.bitInfo.tzxl05 = data.tzxl05 || ''
            this.bitInfo.tzxl06 = data.tzxl06 || ''

            // 更新图片列表（支持多个图片）
            this.bitInfo.slt01List = data.slt01List || []
            this.bitInfo.slt02List = data.slt02List || []
            this.bitInfo.slt03List = data.slt03List || []
            this.bitInfo.slt04List = data.slt04List || []
            this.bitInfo.slt05List = data.slt05List || []
            this.bitInfo.slt06List = data.slt06List || []

            // 更新匹配状态
            this.bitInfo.t01match = data.t01match || ''
            this.bitInfo.t02match = data.t02match || ''
            this.bitInfo.t03match = data.t03match || ''
            this.bitInfo.t04match = data.t04match || ''
            this.bitInfo.t05match = data.t05match || ''
            this.bitInfo.t06match = data.t06match || ''

            console.log('更新后的bitInfo:', this.bitInfo)
        },

        // 检查是否有图片
        hasImage(imageField) {
            return this.bitInfo[imageField] && this.bitInfo[imageField].trim() !== ''
        },

        // 检查参数是否匹配（根据API返回的匹配状态）
        isParameterMatched(item) {
            // 根据API返回的匹配状态字段判断
            const matchStatus = this.bitInfo[item.matchField]
            return this.isMatchStatus(matchStatus)
        },

        // 判断是否为匹配状态（支持'匹配'和'推荐'）
        isMatchStatus(status) {
            return status === '匹配' || status === '推荐' || status === true
        },

        // 获取参数值
        getParameterValue(item) {
            return this.bitInfo[item.field] || '暂无数据'
        },

        // 获取当前值（优先使用bitData）
        getCurrentValue(field) {
            return (this.bitData && this.bitData[field]) || this.bitInfo[field] || ''
        },

        // 获取图片列表（支持多个图片）
        getImageList(item) {
            // 获取图片列表字段名（如 slt01List）
            const listField = item.imageField + 'List';
            const imageList = (this.bitData && this.bitData[listField]) || this.bitInfo[listField];

            // 如果存在图片列表且是数组，返回它
            if (Array.isArray(imageList) && imageList.length > 0) {
                return imageList;
            }

            // 否则返回空数组
            return [];
        },

        handleModify() {
            console.log('修改钻头信息')
            this.$emit('modify')
        },

        handleDigitalize() {
            console.log('数字化处理')
            this.$emit('digitalize')
        },

        handleDelete() {
            console.log('删除钻头')
            this.$confirm('确定要删除这个钻头吗？', '提示', {
                confirmButtonText: '确定',
                cancelButtonText: '取消',
                type: 'warning'
            }).then(() => {
                this.$emit('delete')
                this.$message.success('删除成功')
            }).catch(() => {
                this.$message.info('已取消删除')
            })
        },

        handleReturn() {
            console.log('返回上一页')
            // 根据来源页面决定返回路径
            const from = this.$route.query.from || 'main'
            if (from === 'main') {
                this.$router.push({ name: 'BitDesign' })
            } else if (from === 'matching') {
                this.$router.push({ name: 'BitMatching' })
            } else if (from === 'recommendation') {
                this.$router.push({ name: 'BitDesignRecommendation' })
            } else {
                this.$router.go(-1)
            }
        },

        handleClose() {
            console.log('关闭弹窗')
            // 触发关闭事件，让父组件（BitMatching）关闭弹窗
            this.$emit('close')
        }
    }
}
</script>

<style lang="scss" scoped>
.bit-selection-info {
    padding: 10px;
    background-color: #f5f7fa;
    height: 70vh;
    position: relative;

    .page-header {
        background-color: #fff;
        padding: 20px;
        border-radius: 4px;
        margin-bottom: 10px;
        display: flex;
        justify-content: center;
        align-items: center;

        .header-content {
            text-align: center;
            width: 100%;

            h2 {
                margin: 0 0 15px 0;
                color: #333;
                font-size: 24px;
                font-weight: bold;
            }

            .bit-basic-info {
                display: flex;
                gap: 30px;
                align-items: center;
                justify-content: center;

                span {
                    color: #666;
                    font-size: 22px;
                    font-weight: bold;
                }
            }
        }

        .header-actions {
            display: flex;
            gap: 10px;
            justify-content: center;
            margin-top: 15px;
        }
    }

    .matching-table {
        margin-bottom: 10px;

        .match-status-table {
            .status-icon {
                font-size: 16px;
                font-weight: bold;

                &.match {
                    color: #67C23A;
                }

                &.no-match {
                    color: #f56c6c;
                }
            }

            .value-text {
                font-size: 14px;
                color: #333;
                font-weight: 500;
            }
        }
    }

    .parameters-section {
        .parameter-row {
            display: grid;
            grid-template-columns: repeat(3, 1fr);
            gap: 15px;
            margin-bottom: 10px;

            .parameter-item {
                background-color: #fff;
                border-radius: 4px;
                padding: 15px;
                display: flex;
                align-items: flex-start;
                gap: 20px;
                border: 1px solid #e4e7ed;

                // 左侧：参数名称
                .parameter-label {
                    min-width: 120px;
                    flex-shrink: 0;

                    h4 {
                        margin: 0;
                        color: #333;
                        font-size: 14px;
                        font-weight: bold;
                        line-height: 1.5;
                    }
                }

                // 右侧：图片容器
                .parameter-images-container {
                    flex: 1;
                    display: flex;
                    align-items: flex-start;

                    .parameter-images-list {
                        display: flex;
                        flex-direction: row;
                        gap: 15px;
                        flex-wrap: wrap;

                        .parameter-image-item {
                            display: flex;
                            flex-direction: column;
                            align-items: center;
                            gap: 8px;

                            .parameter-image {
                                width: 150px;
                                height: 120px;
                                display: flex;
                                align-items: center;
                                justify-content: center;
                                border-radius: 4px;
                                border: 1px solid #e4e7ed;
                                overflow: hidden;
                                background-color: #fafafa;

                                img {
                                    max-width: 100%;
                                    max-height: 100%;
                                    width: auto;
                                    height: auto;
                                    object-fit: contain;
                                }

                                .no-image {
                                    width: 100%;
                                    height: 100%;
                                    display: flex;
                                    align-items: center;
                                    justify-content: center;
                                    background-color: #f5f7fa;
                                    color: #999;
                                    font-size: 12px;
                                }
                            }

                            .parameter-name {
                                margin: 0;
                                font-size: 12px;
                                color: #409EFF;
                                font-weight: 500;
                                text-align: center;
                                white-space: pre-line;
                            }
                        }
                    }

                    .parameter-image-single {
                        .parameter-image {
                            width: 150px;
                            height: 120px;
                            display: flex;
                            align-items: center;
                            justify-content: center;
                            border-radius: 4px;
                            border: 1px solid #e4e7ed;
                            overflow: hidden;
                            background-color: #fafafa;

                            img {
                                max-width: 100%;
                                max-height: 100%;
                                width: auto;
                                height: auto;
                                object-fit: contain;
                            }

                            .no-image {
                                width: 100%;
                                height: 100%;
                                display: flex;
                                align-items: center;
                                justify-content: center;
                                background-color: #f5f7fa;
                                color: #999;
                                font-size: 12px;
                            }
                        }
                    }
                }
            }
        }
    }

    .footer-actions {
        position: absolute;
        bottom: 20px;
        right: 20px;
    }
}
</style>
