<template>
	<view class="interview-container">
		<!-- 职位列表 v-if="!userInfoFilled"-->
		<view class="job-list-container" >
			<view class="job-list-title">可选职位列表</view>
			<view class="job-list">
				<view v-for="(job, index) in jobList" :key="index" class="job-item"
					:class="{'job-selected': selectedJobId === job.id}" v-show="job.status == 1" @click="selectJob(job)">
					<view class="job-name">{{job.title}}</view>
					<view class="job-actions">
						<button class="detail-btn" @click.stop="viewJobDetail(job)">查看详情</button>
					</view>
					<view class="job-details">
						<text class="job-salary"></text>
						<text class="job-location">{{formatLocation(job.location)}}</text>
					</view>
					
				</view>
			</view>

			<button class="apply-btn" :disabled="!selectedJobId" @click="applyForJob">申请面试</button>
		</view>

		<!-- 表单信息 -->
		<!-- <view class="form-container" v-if="userInfoFilled">
			<view class="form-title">请完成验证信息填写</view>

			<view class="form-item phone-item">
				<view class="country-code">
					<text>+86</text>
				</view>
				<input type="number" v-model="formData.phone" placeholder="请输入手机号" maxlength="11" @input="validatePhone" />
				<view class="validation-icon" v-if="formData.phone">
					<text class="icon-success" v-if="isPhoneValid">✓</text>
					<text class="icon-error" v-else>✗</text>
				</view>
			</view>

			<view class="form-item">
				<input type="text" v-model="formData.name" placeholder="请输入姓名" @input="validateName" />
				<view class="validation-icon" v-if="formData.name">
					<text class="icon-success" v-if="isNameValid">✓</text>
					<text class="icon-error" v-else>✗</text>
				</view>
			</view>
			<view class="form-item">
				<input type="text" v-model="formData.idCard" placeholder="请输入身份证号" maxlength="18" @input="validateIdCard" />
				<view class="validation-icon" v-if="formData.idCard">
					<text class="icon-success" v-if="isIdCardValid">✓</text>
					<text class="icon-error" v-else>✗</text>
				</view>
			</view>
			<view class="form-item">
				<picker @change="genderChange" :value="genderIndex" :range="genderOptions">
					<view class="picker-input">
						<input type="text" disabled placeholder="请选择性别" :value="formData.gender" />
						<view class="dropdown-icon">▼</view>
					</view>
				</picker>
			</view>

			

			<button class="verify-btn" :disabled="!canSubmitSimple" @click="submitForm">确认面试</button>

			<view class="agreement">
				<checkbox :checked="isAgreed" @tap="toggleAgreement" color="#0039b3" />
				<text class="agreement-text">
					我已阅读并同意<text class="agreement-link">《用户协议》</text>和<text class="agreement-link">《隐私政策》</text>
				</text>
			</view>
		</view> -->
	</view>
</template>

<script>
import { apiBaseUrl } from '@/common/config.js';
	import {
		fillUserInfo,
		getUserInfo,
		getJobList,
		applyJob
	} from '@/api/user';
	export default {
		data() {
			return {
				formData: {
					name: '',
					gender: '',
					phone: '',
					email: '',
					idCard: '',
					emergencyContact: '',
					emergencyPhone: '',
					relation: ''
				},
				relationOptions: ['父母', '配偶', '子女', '兄弟姐妹', '朋友', '其他'],
				relationIndex: 0,
				isAgreed: false,
				userInfoFilled: false,
				jobList: [],
				selectedJobId: null,
				selectedJob: null,
				isPhoneValid: false,
				isNameValid: false,
				isIdCardValid: false,
				genderOptions: ['男', '女'],
				genderIndex: 0,
				genderMapping: {
					'男': '1',
					'女': '2',
					'1': '男',
					'2': '女'
				}
			}
		},
		onLoad(options) {
			console.log('options:', options);
			if (options.scene) {
				// 对scene进行解码
				const scene = decodeURIComponent(options.scene);
				console.log('解码后的scene:', scene);
				
			// 如果scene是key1=val1&key2=val2格式
			const sceneParams = {};
			scene.split('&').forEach(pair => {
				const [key, value] = pair.split('=');
				sceneParams[key] = value;
			});
			console.log('解析后的参数:', sceneParams);
			}
			this.checkUserInfo();
			this.fetchJobList();
		},
		computed: {
			canSubmit() {
				return this.formData.name.trim() &&
					this.formData.gender &&
					this.formData.phone.trim() &&
					(/^1\d{10}$/.test(this.formData.phone)) &&
					(!this.formData.email || /^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$/.test(this.formData.email)) &&
					this.formData.idCard.trim() &&
					this.formData.emergencyContact.trim() &&
					this.formData.emergencyPhone.trim() &&
					(/^1\d{10}$/.test(this.formData.emergencyPhone)) &&
					this.formData.relation &&
					this.isAgreed;
			},
			canSubmitSimple() {
				return this.formData.name.trim() &&
					this.formData.phone.trim() &&
					this.isPhoneValid &&
					this.formData.idCard.trim() &&
					this.isIdCardValid &&
					this.isAgreed;
			}
		},
		methods: {
			checkLogin() {
				const userInfo = uni.getStorageSync('userInfo');
				if (!userInfo) {
					// 未登录时跳转到身份验证登录页面
					uni.reLaunch({
						url: '/pages/login/login',
						success: () => {
							console.log('跳转到身份验证登录页面成功');
						},
						fail: (err) => {
							console.error('跳转到身份验证登录页面失败:', err);
							uni.showToast({
								title: '跳转失败，请重试',
								icon: 'none'
							});
						}
					});
					return false;
				}
				
				try {
					const parsedUserInfo = JSON.parse(userInfo);
					if (!parsedUserInfo.openid) {
						// 没有openid时跳转到身份验证登录页面
						uni.navigateTo({
							url: '/pages/login/login'
						});
						return false;
					}
					return true;
				} catch (e) {
					console.error('解析用户信息失败:', e);
					uni.removeStorageSync('userInfo');
					uni.navigateTo({
						url: '/pages/login/login'
					});
					return false;
				}
			},
			goHome() {
				uni.navigateBack({
					delta: 1
				});
			},
			toggleAgreement() {
				this.isAgreed = !this.isAgreed;
			},
			relationChange(e) {
				this.relationIndex = e.detail.value;
				this.formData.relation = this.relationOptions[this.relationIndex];
			},
			checkUserInfo() {
				// if (!this.checkLogin()) {
				// 	return;
				// }
				
				uni.showLoading({
					title: '加载中...'
				});
				
				try {
					const userInfo = JSON.parse(uni.getStorageSync('userInfo'));
					console.log('id:', userInfo.id);
					
					getUserInfo(userInfo.id,userInfo.openid)
						.then(res => {
							uni.hideLoading();
							const userData = res;
							if (!userData.name || !userData.phone) {
								this.userInfoFilled = true;
								this.formData.name = userData.name || '';
								
								if (userData.gender) {
									this.formData.gender = this.genderMapping[userData.gender] || userData.gender;
									const index = this.genderOptions.findIndex(item => item === this.formData.gender);
									if (index !== -1) {
										this.genderIndex = index;
									}
								} else {
									this.formData.gender = '';
								}
								
								this.formData.phone = userData.phone || '';
								this.formData.idCard = userData.id_card || '';
								this.formData.emergencyContact = userData.emergency_contact || '';
								this.formData.emergencyPhone = userData.emergency_phone || '';
								this.formData.relation = userData.relation || '';
								if (userData.relation) {
									const index = this.relationOptions.findIndex(item => item === userData.relation);
									if (index !== -1) {
										this.relationIndex = index;
									}
								}
							}
						})
						.catch(err => {
							uni.hideLoading();
							console.error('获取用户信息失败:', err);
							uni.showToast({
								title: '获取用户信息失败',
								icon: 'none'
							});
						});
				} catch (e) {
					uni.hideLoading();
					console.error('获取用户信息失败:', e);
					uni.showToast({
						title: '获取用户信息失败',
						icon: 'none'
					});
					// uni.navigateTo({
					// 	url: '/pages/login/login'
					// });
				}
			},
			fetchJobList() {
				uni.showLoading({
					title: '加载职位列表...'
				});

				getJobList()
					.then(res => {
						uni.hideLoading();
						console.log('职位列表数据:', res);
						// 确保返回的数据是数组
						this.jobList = Array.isArray(res) ? res.filter(job => job !== null && job !== undefined) : [];
						if (this.jobList.length === 0) {
							uni.showToast({
								title: '暂无可用职位',
								icon: 'none'
							});
						}
					})
					.catch(err => {
						uni.hideLoading();
						console.error('获取职位列表失败:', err);
						this.jobList = []; // 确保发生错误时jobList是空数组
						uni.showToast({
							title: '网络错误，请稍后重试',
							icon: 'none'
						});
					});
			},
			selectJob(job) {
				// 清除之前的问题缓存
				try {
					uni.removeStorageSync('interviewQuestions');
					uni.removeStorageSync('currentQuestionIndex');
				} catch (e) {
					console.error('清除问题缓存失败:', e);
				}
				
				// 更新选中的职位
				this.selectedJobId = job.id;
				this.selectedJob = job;
				
				// 立即更新本地存储中的职位信息
				uni.setStorageSync('selectedJob', JSON.stringify(job));
				
				console.log('已选择职位:', job.id, job.title);
			},
			// 获取当前职位配置
			getConfig(){
				uni.request({
					url: `${apiBaseUrl}/api/job/config/position/${this.selectedJobId}`,
					method: 'GET',
					data: {
						openid: JSON.parse(uni.getStorageSync('userInfo')).openid
					},
					header: {
						'content-type': 'application/x-www-form-urlencoded'
					},
					success: (res) => {
						// 身份验证成功后，继续提交用户信息
						console.log(res);
						if (res.statusCode === 200) {
							if (res.data.code === 2000) {
								uni.setStorageSync('configData', JSON.stringify(res.data.data))
								// 调用获取用户完整信息的接口
								const openid = JSON.parse(uni.getStorageSync('userInfo')).openid;
								uni.request({
									url: `${apiBaseUrl}/api/wechat/user/get_full_info?tenant_id=1&openid=${openid}`,
									method: 'GET',
									success: (infoRes) => {
										if (infoRes.statusCode === 200 && infoRes.data && infoRes.data.data && infoRes.data.data.profile) {
											const resumeUrl = infoRes.data.data.profile.resume_url || '';
											if (!resumeUrl) {
												// resume_url 为空，跳转到其他页面
												uni.navigateTo({
													url: '/pages/uploadResume/uploadResume', // 假设跳转到上传简历页面
													fail: (err) => {
														console.error('页面跳转失败:', err);
														uni.showToast({
															title: '页面跳转失败',
															icon: 'none'
														});
													}
												});
											} else {
												// resume_url 不为空，跳转到 Personal 页面
												uni.navigateTo({
													url: '/pages/Personal/Personal',
													fail: (err) => {
														console.error('页面跳转失败:', err);
														uni.showToast({
															title: '页面跳转失败',
															icon: 'none'
														});
													}
												});
											}
										} else {
											// 获取用户信息失败，直接跳转到 Personal 页面
											uni.navigateTo({
												url: '/pages/Personal/Personal',
												fail: (err) => {
													console.error('页面跳转失败:', err);
													uni.showToast({
														title: '页面跳转失败',
														icon: 'none'
													});
												}
											});
										}
									},
									fail: (err) => {
										console.error('获取用户信息失败:', err);
										uni.navigateTo({
											url: '/pages/Personal/Personal',
											fail: (err) => {
												console.error('页面跳转失败:', err);
												uni.showToast({
													title: '页面跳转失败',
													icon: 'none'
												});
											}
										});
									}
								});
							} else {
								// 其他逻辑
							}
						} else {
							uni.hideLoading();
						}
					},
					fail: (err) => {
						uni.hideLoading();
						uni.showToast({
							title: '网络错误，请稍后重试',
							icon: 'none'
						});
					}
				});
			},
			applyForJob() {
				if (!this.checkLogin()) {
					return;
				}
				
				if (!this.selectedJobId) {
					uni.showToast({
						title: '请选择一个职位',
						icon: 'none'
					});
					return;
				}

				// 保存所选职位信息
				uni.setStorageSync('selectedJob', JSON.stringify(this.selectedJob));
				applyJob({
					job_id: this.selectedJobId,
					tenant_id: 1,
					openid: JSON.parse(uni.getStorageSync('userInfo')).openid
				}).then(res => {
					// 保存返回的应用ID到本地存储
					if (res && res.id) {
						// 将应用ID保存到本地
						uni.setStorageSync('appId', res.id);
						
						// 也可以更新已有的userInfo对象
						try {
							const userInfo = JSON.parse(uni.getStorageSync('userInfo') || '{}');
							userInfo.appId = res.id;
							uni.setStorageSync('userInfo', JSON.stringify(userInfo));
						} catch (e) {
							console.error('更新用户信息失败:', e);
						}
					}
					this.getConfig()
					
				}).catch(err => {
					console.error('申请职位失败:', err);
					uni.showToast({
						title: '申请职位失败，请重试',
						icon: 'none'
					});
				});
			},
			submitForm() {
				if (!this.checkLogin()) {
					return;
				}
				
				if (!this.formData.name.trim()) {
					uni.showToast({
						title: '请输入姓名',
						icon: 'none'
					});
					return;
				}

				if (!this.formData.gender) {
					uni.showToast({
						title: '请选择性别',
						icon: 'none'
					});
					return;
				}

				if (!this.formData.phone.trim()) {
					uni.showToast({
						title: '请输入手机号',
						icon: 'none'
					});
					return;
				}

				if (!/^1\d{10}$/.test(this.formData.phone)) {
					uni.showToast({
						title: '请输入正确的手机号',
						icon: 'none'
					});
					return;
				}

				if (!this.formData.idCard.trim()) {
					uni.showToast({
						title: '请输入身份证号',
						icon: 'none'
					});
					return;
				}

				const idCardReg = /(^\d{15}$)|(^\d{18}$)|(^\d{17}(\d|X|x)$)/;
				if (!idCardReg.test(this.formData.idCard)) {
					uni.showToast({
						title: '请输入正确的身份证号',
						icon: 'none'
					});
					return;
				}

				if (!this.isAgreed) {
					uni.showToast({
						title: '请阅读并同意相关协议',
						icon: 'none'
					});
					return;
				}
				
				uni.showLoading({
					title: '验证身份信息...'
				});

				// 先调用身份验证接口
				uni.request({
					url: `${apiBaseUrl}/wechat/identity/verify`,
					method: 'POST',
					data: {
						name: this.formData.name,
						id_number: this.formData.idCard,
						mobile: this.formData.phone
					},
					header: {
						'content-type': 'application/x-www-form-urlencoded'
					},
					success: (res) => {
						// 身份验证成功后，继续提交用户信息
						console.log(res);
						if (res.statusCode === 200) {
							if (res.data.code === 200) {
								this.submitUserInfo();
							} else {
								uni.showToast({
									title: res.data.data.message,
									icon: 'none'
								});
							}
						} else {
							uni.hideLoading();
							uni.showToast({
								title: '身份验证失败，请检查信息是否正确',
								icon: 'none'
							});
						}
					},
					fail: (err) => {
						uni.hideLoading();
						console.error('身份验证失败:', err);
						uni.showToast({
							title: '网络错误，请稍后重试',
							icon: 'none'
						});
					}
				});
			},
			submitUserInfo() {
				const genderValue = this.genderMapping[this.formData.gender] || this.formData.gender;
				
				const submitData = {
					openid: JSON.parse(uni.getStorageSync('userInfo') || '{}').openid || '',
					name: this.formData.name,
					phone: this.formData.phone,
					id_card: this.formData.idCard,
					status: 1,
					source: 'mini',
					examine: 0,
					tenant_id: '1',
					/* emergency_contact: this.formData.emergencyContact,
					emergency_phone: this.formData.emergencyPhone,
					relation: this.formData.relation, */
					age: '20',
					job_id: this.selectedJobId,
					gender: genderValue
				};

				fillUserInfo(submitData)
					.then(res => {
						uni.hideLoading();
						this.updateLocalUserInfo(res.id,JSON.parse(uni.getStorageSync('userInfo')).openid);

						uni.showToast({
							title: '提交成功',
							icon: 'success',
							duration: 1500,
							success: () => {
								this.userInfoFilled = false;
								// setTimeout(() => {
								// }, 1500);
							}
						});
					})
					.catch(err => {
						uni.hideLoading();
						console.error('提交表单失败:', err);
						uni.showToast({
							title: '网络错误，请稍后重试',
							icon: 'none'
						});
					});
			},
			updateLocalUserInfo(data) {
					getUserInfo(data)
					.then(res => {
						if (res.code === 200 && res.data) {
							let userInfo = {};
							try {
								userInfo = JSON.parse(uni.getStorageSync('userInfo') || '{}');
							} catch (e) {
								console.error('解析本地存储用户信息失败:', e);
								userInfo = {};
							}

							const updatedUserInfo = {
								...userInfo,
								...res.data
							};

							uni.setStorageSync('userInfo', JSON.stringify(updatedUserInfo));
						}
					})
					.catch(err => {
						console.error('更新本地用户信息失败:', err);
					});
			},
			validatePhone() {
				this.isPhoneValid = /^1\d{10}$/.test(this.formData.phone);
			},
			validateName() {
				this.isNameValid = this.formData.name.trim().length >= 2;
			},
			validateIdCard() {
				const idCardReg = /(^\d{15}$)|(^\d{18}$)|(^\d{17}(\d|X|x)$)/;
				this.isIdCardValid = idCardReg.test(this.formData.idCard);
			},
			genderChange(e) {
				this.genderIndex = e.detail.value;
				const displayGender = this.genderOptions[this.genderIndex];
				this.formData.gender = displayGender;
			},
			viewJobDetail(job) {
				// 保存所选职位信息到本地存储
				uni.setStorageSync('currentJobDetail', JSON.stringify(job));
				console.log(job);
				// 跳转到职位详情页面
				uni.navigateTo({
						url: '/pages/job-detail/job-detail?id=' + job.id,
						fail: (err) => {
							console.error('页面跳转失败:', err);
							uni.showToast({
								title: '页面跳转失败',
								icon: 'none'
							});
						}
					});
			},
			formatLocation(location) {
				if (!location) return '';
				
				// 处理字符串形式的数组
				if (typeof location === 'string' && location.startsWith('[')) {
					try {
						const locationArray = JSON.parse(location.replace(/'/g, '"'));
						return locationArray.join(' ');
					} catch (e) {
						console.error('解析location失败:', e);
						return location;
					}
				}
				
				// 处理数组格式
				if (Array.isArray(location)) {
					return location.join(' ');
				}
				
				// 处理对象格式
				if (typeof location === 'object' && location !== null) {
					const { province, city, district } = location;
					if (province && city) {
						return province + ' ' + city + (district ? ' ' + district : '');
					}
				}
				
				// 处理普通字符串格式
				return location;
			}
		}
	}
</script>

<style>
	.interview-container {
		display: flex;
		flex-direction: column;
		min-height: 100vh;
		background-color: #f5f7fa;
	}

	.nav-bar {
		display: flex;
		justify-content: space-between;
		align-items: center;
		padding: 20rpx 30rpx;
		background-color: #0039b3;
		color: #fff;
	}

	.scan-btn {
		display: flex;
		flex-direction: column;
		align-items: center;
		background-color: #ff9f43;
		padding: 10rpx 30rpx;
		border-radius: 30rpx;
		font-size: 24rpx;
	}

	.interview-info {
		background-color: #0039b3;
		color: #fff;
		padding: 20rpx 30rpx 40rpx;
	}

	.info-item {
		margin: 10rpx 0;
		font-size: 28rpx;
	}

	.label {
		margin-right: 10rpx;
	}

	.form-container {
		flex: 1;
		background-color: #fff;
		padding: 40rpx 30rpx;
	}

	.form-title {
		font-size: 32rpx;
		font-weight: bold;
		margin-bottom: 40rpx;
		text-align: center;
		color: #333;
	}

	.form-item {
		margin-bottom: 30rpx;
		position: relative;
	}

	.validation-icon {
		position: absolute;
		right: 20rpx;
		top: 50%;
		transform: translateY(-50%);
		font-size: 36rpx;
		display: flex;
		align-items: center;
		justify-content: center;
	}

	.icon-success {
		color: #4cd964;
	}

	.icon-error {
		color: #ff3b30;
	}

	input {
		width: 100%;
		height: 80rpx;
		border: 1px solid #eee;
		border-radius: 8rpx;
		padding: 0 60rpx 0 20rpx;
		font-size: 28rpx;
		box-sizing: border-box;
		background-color: #f9f9f9;
	}

	.phone-item {
		display: flex;
		align-items: center;
		position: relative;
	}

	.phone-item .validation-icon {
		right: 20rpx;
	}

	.phone-item input {
		flex: 1;
		border-radius: 0 8rpx 8rpx 0;
	}

	.verify-btn {
		width: 100%;
		height: 90rpx;
		line-height: 90rpx;
		background-color: #0039b3;
		color: #fff;
		border-radius: 45rpx;
		font-size: 32rpx;
		margin-top: 60rpx;
	}

	.verify-btn[disabled] {
		background-color: #b2b2b2;
		color: #fff;
		opacity: 0.7;
	}

	.agreement {
		display: flex;
		align-items: center;
		margin-top: 30rpx;
	}

	.agreement-text {
		font-size: 24rpx;
		color: #666;
		line-height: 1.5;
		margin-left: 10rpx;
	}

	.agreement-link {
		color: #0039b3;
	}

	/* 职位列表样式 */
	.job-list-container {
		flex: 1;
		background-color: #fff;
		border-radius: 20rpx 20rpx 0 0;
		margin-top: -20rpx;
		padding: 40rpx 30rpx;
	}

	.job-list-title {
		font-size: 32rpx;
		font-weight: bold;
		margin-bottom: 30rpx;
	}

	.job-list {
		max-height: 1000rpx;
		overflow-y: auto;
	}

	.job-item {
		padding: 30rpx;
		border-radius: 12rpx;
		background-color: #f8f9fa;
		margin-bottom: 20rpx;
		border: 2rpx solid transparent;
	}

	.job-selected {
		border-color: #0039b3;
		background-color: rgba(108, 92, 231, 0.1);
	}

	.job-name {
		font-size: 30rpx;
		font-weight: bold;
		margin-bottom: 10rpx;
	}

	.job-details {
		display: flex;
		justify-content: space-between;
		font-size: 24rpx;
		color: #666;
	}

	.job-salary {
		color: #fb752f;
	}

	.apply-btn {
		width: 100%;
		height: 90rpx;
		line-height: 90rpx;
		background-color: #0039b3;
		color: #fff;
		border-radius: 45rpx;
		font-size: 32rpx;
		margin-top: 40rpx;
	}

	.apply-btn[disabled] {
		background-color: #b2b2b2;
		color: #fff;
	}

	/* 修复国家代码样式 */
	.country-code {
		display: flex;
		align-items: center;
		justify-content: space-between;
		width: 100rpx;
		padding: 0 20rpx;
		height: 80rpx;
		border: 1px solid #eee;
		border-radius: 8rpx 0 0 8rpx;
		border-right: none;
		font-size: 28rpx;
		background-color: #f9f9f9;
	}
	
	.dropdown-icon {
		font-size: 20rpx;
		color: #999;
		margin-left: 10rpx;
	}
	
	/* 修复手机号输入框样式 */
	.phone-item {
		display: flex;
		align-items: center;
		position: relative;
	}
	
	.phone-item input {
		flex: 1;
		border-radius: 0 8rpx 8rpx 0;
	}
	
	/* 修复验证图标位置 */
	.validation-icon {
		position: absolute;
		right: 20rpx;
		top: 50%;
		transform: translateY(-50%);
		font-size: 36rpx;
		display: flex;
		align-items: center;
		justify-content: center;
		z-index: 2;
	}
	
	.phone-item .validation-icon {
		right: 20rpx;
	}
	
	/* 修改图标样式与图片一致 */
	.icon-success {
		color: #4cd964;
		font-weight: bold;
	}
	
	.icon-error {
		color: #ff3b30;
		font-weight: bold;
	}

	/* 修改性别选择样式，使其看起来像输入框 */
	.picker-input {
		position: relative;
		width: 100%;
	}

	.picker-input input {
		width: 100%;
		height: 80rpx;
		border: 1px solid #eee;
		border-radius: 8rpx;
		padding: 0 60rpx 0 20rpx;
		font-size: 28rpx;
		box-sizing: border-box;
		background-color: #f9f9f9;
	}

	.picker-input .dropdown-icon {
		position: absolute;
		right: 20rpx;
		top: 50%;
		transform: translateY(-50%);
		font-size: 24rpx;
		color: #999;
	}

	.job-actions {
		display: flex;
		justify-content: flex-end;
		margin-top: 15rpx;
		margin-bottom: 15rpx;
	}

	.detail-btn {
		background-color: #0039b3;
		color: #fff;
		font-size: 24rpx;
		padding: 6rpx 20rpx;
		border-radius: 30rpx;
		line-height: 1.5;
		margin: 0;
		min-height: auto;
	}
</style>