<!--
 * @Date: 2024-01-17 14:00
 * @LastEditors: hookehuyr hookehuyr@gmail.com
 * @LastEditTime: 2026-01-22 22:12:11
 * @FilePath: /mlaj/src/views/profile/StudyCoursePage.vue
 * @Description: 课程详情页面
-->
<template>
<AppLayout :has-title="false">
    <div class="study-course-page bg-gradient-to-b from-green-50/70 to-white/90 min-h-screen">
        <div v-if="course" class="bg-white">
            <van-image class="w-full object-cover" :src="course?.cover || 'https://cdn.ipadbiz.cn/mlaj/images/default_block.png'" :alt="course?.title" />
            <div class="p-4">
                <div class="flex items-start justify-between gap-3 mb-2">
                    <h1 class="text-black text-xl font-bold flex-1 min-w-0">{{ course?.title }}</h1>
                    <div v-if="course?.price !== '0.00'" class="text-orange-500 font-bold text-xl flex-shrink-0">¥{{ course?.price || '0' }}</div>
                    <div v-else class="text-orange-500 text-base font-semibold"> 免费 </div>
                </div>
                <div class="flex items-center text-gray-500 text-sm">
                    <span>已更新 {{ course?.count }} 期</span>
                    <span class="mx-2">|</span>
                    <span>{{ course?.buy_count }} 人订阅</span>
                </div>
            </div>

            <div class="h-2 bg-gray-100"></div>

            <div ref="tabs_wrapper_ref" class="py-3 bg-white sticky top-0 z-10">
                <div class="flex justify-around items-center relative" ref="tabs_container_ref">
                    <div
                        v-for="(tab, index) in tabs"
                        :key="tab.name"
                        :class="['px-4 py-2 cursor-pointer transition-colors relative', activeTab === tab.name ? 'text-green-600 font-medium' : 'text-gray-600']"
                        @click="handleTabChange(tab.name)"
                        :ref="el => setTabRef(tab.name, el)"
                    >
                        {{ tab.title }}
                    </div>
                    <div
                        class="absolute bottom-0 left-0 bg-green-600 transition-all duration-300 z-20"
                        :style="indicatorStyle"
                    ></div>
                </div>
            </div>

            <!-- <div v-if="!course?.feature && !course?.highlights && !course?.learning_goal" class="h-2 bg-gray-100"></div> -->

            <div id="detail" class="py-4 px-4">
                <template v-if="course?.feature || course?.highlights || course?.learning_goal">
                    <div v-if="course?.feature">
                        <div class="text-black text-xl font-bold mb-2">课程特色</div>
                        <div class="text-gray-700 text-sm leading-relaxed" v-html="course?.feature"></div>
                        <br />
                    </div>
                    <div v-if="course?.highlights">
                        <div class="text-black text-xl font-bold mb-2">课程亮点</div>
                        <div class="text-gray-700 text-sm leading-relaxed" v-html="course?.highlights"></div>
                        <br />
                    </div>
                    <div v-if="course?.learning_goal">
                        <div class="text-black text-xl font-bold mb-2">学习目标</div>
                        <div class="text-gray-700 text-sm leading-relaxed" v-html="course?.learning_goal"></div>
                        <br />
                    </div>
                </template>
                <van-empty v-else description="暂无课程详情" />
            </div>

            <!-- <div v-if="course?.feature || course?.highlights || course?.learning_goal" class="h-2 bg-gray-100"></div> -->
            <div class="h-2 bg-gray-100"></div>

            <div id="catalog" class="py-4">
                <div v-if="course_lessons.length" class="space-y-4">
                    <div v-for="(lesson, index) in course_lessons" :key="index"
                        :data-lesson-id="lesson.id"
                        @click="goToStudyDetail(lesson.id)"
                        class="bg-white p-4 cursor-pointer hover:bg-gray-50 transition-colors border-b border-gray-200 relative">
                        <div class="text-black text-base font-medium mb-2">{{ lesson.title }}</div>
                        <div class="flex items-center text-sm text-gray-500">
                            <span>{{ course_type_maps[lesson.course_type] }}</span>
                            <span v-if="course_type_maps[lesson.course_type]" class="mx-2">|</span>
                            <span>开课时间: {{ lesson.schedule_time ? dayjs(lesson.schedule_time).format('YYYY-MM-DD') : '暂无' }}</span>
                            <span class="mx-2">|</span>
                            <span v-if="lesson.duration">建议时长: {{ lesson.duration }} 分钟</span>
                        </div>
                    </div>
                </div>
                <van-empty v-else description="暂无课程目录" />
            </div>

            <div v-if="course_lessons.length" class="h-2 bg-gray-100"></div>

            <div id="interaction" class="py-4 px-4" v-if="task_list.length > 0">
                <div class="bg-white rounded-lg p-4 mb-4 cursor-pointer">
                    <div class="flex items-center justify-between" @click="goToCheckin()">
                        <div class="flex items-center gap-3">
                            <van-icon size="3rem" name="calendar-o" class="text-xl text-gray-600" />
                            <div>
                                <div class="text-base font-medium">打卡</div>
                                <div class="text-sm text-gray-500">关联{{ task_list.length }}个打卡</div>
                            </div>
                        </div>
                        <van-icon name="arrow" class="text-gray-400" />
                    </div>
                </div>
            </div>

            <div style="height: 80vh;"></div>
        </div>

        <!-- 打卡弹窗：统一使用 CheckInDialog 组件 -->
        <CheckInDialog
            v-model:show="showCheckInDialog"
            :items_today="task_list"
            :items_history="timeout_task_list"
            @check-in-success="handleCheckInSuccess"
        />
    </div>
</AppLayout>
</template>

<script setup>
import { ref, onMounted, nextTick, onUnmounted, computed } from 'vue';
import { useTitle } from '@vueuse/core';
import { useRouter } from "vue-router";
import dayjs from 'dayjs';
import { showToast } from 'vant';
import { normalizeCheckinTaskItems } from '@/utils/tools'
import AppLayout from '@/components/layout/AppLayout.vue';
import CheckInDialog from '@/components/checkin/CheckInDialog.vue';

// 导入接口
import { getCourseDetailAPI } from '@/api/course';

const router = useRouter();
const course_id = computed(() => {
    return router.currentRoute.value.params.id || '';
});

// 页面标题
useTitle('课程详情');

// 当前激活的标签页
const activeTab = ref('detail');
// tabs DOM映射
const tabRefs = ref([]);
const tabElMap = ref({});

/**
 * 设置标签引用映射
 * @param {string} name - 标签名称
 * @param {HTMLElement} el - 对应的元素
 * 注释：用于根据激活标签定位指示条位置
 */
const setTabRef = (name, el) => {
    if (el) {
        tabElMap.value[name] = el;
    }
};

/**
 * 计算标签配置
 * @returns {Array<{title:string,name:string}>} 标签数组（含条件展示的打卡互动）
 * 注释：当存在打卡任务时，追加“打卡互动”标签
 */
const tabs = computed(() => {
    const base = [
        { title: '课程详情', name: 'detail' },
        { title: '课程目录', name: 'catalog' },
    ];
    if (task_list.value && task_list.value.length > 0) {
        base.push({ title: '打卡互动', name: 'interaction' });
    }
    return base;
});

/**
 * 当前激活标签的索引
 * @returns {number} 当前标签在 tabs 中的索引
 * 注释：用于计算底部指示条的宽度和位置
 */
const currentTabIndex = computed(() => {
    return tabs.value.findIndex((t) => t.name === activeTab.value);
});

// 标签容器引用与尺寸
const tabs_container_ref = ref(null);
const tabs_container_width = ref(0);
const tabs_resize_observer = ref(null);
const tabs_wrapper_ref = ref(null);
const tabs_wrapper_height = ref(0);
const tabs_wrapper_resize_observer = ref(null);
const is_tab_scrolling = ref(false);

/**
 * 初始化并监听标签容器宽度
 * @returns {void}
 * 注释：确保在首次渲染和尺寸变化时能正确计算分段宽度
 */
const initTabsContainerWidth = () => {
    nextTick(() => {
        const el = tabs_container_ref.value;
        if (!el) return;
        tabs_container_width.value = el.clientWidth;
        if (tabs_resize_observer.value) {
            tabs_resize_observer.value.disconnect();
        }
        tabs_resize_observer.value = new ResizeObserver(() => {
            tabs_container_width.value = el.clientWidth;
        });
        tabs_resize_observer.value.observe(el);
    });
};

/**
 * 指示条样式计算
 * @returns {{width:string, transform:string, height:string}} 指示条宽度与位置样式
 * 注释：优先按栏目数量进行分段计算，缺省时回退到DOM测量
 */
const indicatorStyle = computed(() => {
    const count = tabs.value.length || 1;
    const index = currentTabIndex.value >= 0 ? currentTabIndex.value : 0;

    // 优先使用容器分段宽度进行计算
    if (tabs_container_width.value > 0 && count > 0) {
        const segment = tabs_container_width.value / count;
        return {
            width: segment + 'px',
            transform: `translateX(${segment * index}px)`,
            height: '2px',
        };
    }

    // 回退：使用激活标签的实际尺寸
    const el = tabElMap.value[activeTab.value];
    const width = el ? el.offsetWidth : 0;
    const left = el ? el.offsetLeft : 0;
    return {
        width: width + 'px',
        transform: `translateX(${left}px)`,
        height: '2px',
    };
});

const updateTabsWrapperHeight = () => {
    nextTick(() => {
        const el = tabs_wrapper_ref.value;
        if (!el) return;
        tabs_wrapper_height.value = el.offsetHeight || 0;
        if (tabs_wrapper_resize_observer.value) {
            tabs_wrapper_resize_observer.value.disconnect();
        }
        tabs_wrapper_resize_observer.value = new ResizeObserver(() => {
            tabs_wrapper_height.value = el.offsetHeight || 0;
        });
        tabs_wrapper_resize_observer.value.observe(el);
    });
};

const course = ref([]);
const course_lessons = ref([]);
const course_type_maps = ref({
    video: '视频',
    audio: '音频',
    image: '图片',
    file: '文件',
})

const task_list = ref([]);
const timeout_task_list = ref([]);

/**
 * 生成课程滚动状态存储键
 * @returns {string} 滚动状态存储键
 * 注释：用于在会话存储中保存和恢复课程目录滚动位置
 */

const get_scroll_store_key = () => {
    return `study_course_scroll_${course_id.value}`;
};

/**
 * 判断是否需要恢复滚动位置
 * @returns {boolean} 是否需要恢复滚动
 * 注释：根据历史状态判断是否从课程详情页返回
 */

const should_restore_scroll = () => {
    const forward = window.history && window.history.state ? window.history.state.forward : null;
    if (!forward) return false;
    return String(forward).includes('studyDetail');
};

/**
 * 保存当前滚动位置
 * @param {string} lesson_id - 当前课程目录项ID
 * 注释：在用户滚动到目录项时调用，记录滚动位置和目录项ID
 */

const save_scroll_state = (lesson_id) => {
    const key = get_scroll_store_key();
    const payload = {
        scroll_y: window.scrollY || 0,
        lesson_id: lesson_id || '',
        saved_at: Date.now(),
    };
    sessionStorage.setItem(key, JSON.stringify(payload));
};

/**
 * 滚动到指定目录项
 * @param {string} lesson_id - 目标目录项ID
 * @returns {boolean} 是否成功滚动
 * 注释：根据目录项ID找到元素并滚动到其位置，考虑顶部导航栏高度
 */

const scroll_to_lesson = (lesson_id) => {
    if (!lesson_id) return false;
    const el = document.querySelector(`[data-lesson-id="${lesson_id}"]`);
    if (!el) return false;
    const rect = el.getBoundingClientRect();
    const buffer = 10;
    const offset_top = (tabs_wrapper_height.value || 0) + buffer;
    const top_offset = Math.max(0, rect.top + window.scrollY - offset_top);
    window.scrollTo({ top: top_offset, left: 0, behavior: 'auto' });
    return true;
};

/**
 * 恢复滚动位置
 * @returns {void}
 * 注释：在组件挂载时调用，根据存储状态滚动到上次记录位置
 */

const restore_scroll_state = async () => {
    if (!should_restore_scroll()) return;
    const key = get_scroll_store_key();
    const raw = sessionStorage.getItem(key);
    if (!raw) return;

    let state = null;
    try {
        state = JSON.parse(raw);
    } catch (e) {
        sessionStorage.removeItem(key);
        return;
    }

    await nextTick();
    await new Promise((resolve) => requestAnimationFrame(() => requestAnimationFrame(resolve)));

    const restored = scroll_to_lesson(state.lesson_id);
    if (!restored && typeof state.scroll_y === 'number') {
        window.scrollTo({ top: state.scroll_y, left: 0, behavior: 'auto' });
    }
    sessionStorage.removeItem(key);
};

onMounted(async () => {
    /**
     * 组件挂载时获取课程详情
     */
    // 获取课程ID
    const courseId = router.currentRoute.value.params.id;
    // 调用接口获取课程详情
    const { code, data } = await getCourseDetailAPI({ i: courseId });
    if (code === 1) {
        course.value = data;
        task_list.value = [];
        timeout_task_list.value = [];

        // 处理task_list数据格式
        task_list.value = normalizeCheckinTaskItems(data.task_list)

        // 处理timeout_task_list数据格式
        timeout_task_list.value = normalizeCheckinTaskItems(data.timeout_task_list)

        course_lessons.value = data.schedule || [];
    }
    else {
        // 课程不存在，跳转到课程主页面
        showToast('课程不存在')
        router.go(-1);
    }
    /**
     * 初始化滚动监听与标签高度
     */
    window.addEventListener('scroll', handleScroll, { passive: true });
    window.addEventListener('resize', updateTabsWrapperHeight);
    updateTabsWrapperHeight();
    // 初始化标签容器宽度监听
    initTabsContainerWidth();
    handleScroll();
    // 恢复滚动位置
    restore_scroll_state();
});

// 在组件卸载时移除监听器
onUnmounted(() => {
    window.removeEventListener('scroll', handleScroll);
    window.removeEventListener('resize', updateTabsWrapperHeight);
    // 取消标签容器监听
    if (tabs_resize_observer.value) {
        tabs_resize_observer.value.disconnect();
        tabs_resize_observer.value = null;
    }
    if (tabs_wrapper_resize_observer.value) {
        tabs_wrapper_resize_observer.value.disconnect();
        tabs_wrapper_resize_observer.value = null;
    }
});

// 防抖函数
const debounce = (fn, delay) => {
    let timer = null;
    return function (...args) {
        if (timer) clearTimeout(timer);
        timer = setTimeout(() => {
            fn.apply(this, args);
        }, delay);
    };
};

// 修改handleScroll函数
/**
 * 处理滚动联动，更新标签激活态
 * 注释：当互动区域不存在时，仅在详情与目录之间联动
 */
const handleScroll = debounce(() => {
    if (is_tab_scrolling.value) return;

    const buffer = 20;
    const offset_top = (tabs_wrapper_height.value || 0) + buffer;
    const current_scroll = window.scrollY + offset_top;

    const sections = tabs.value
        .map((t) => {
            const el = document.getElementById(t.name);
            if (!el) return null;
            const rect = el.getBoundingClientRect();
            const top = rect.top + window.scrollY;
            return { name: t.name, top };
        })
        .filter(Boolean)
        .sort((a, b) => a.top - b.top);

    if (!sections.length) return;

    const doc_height = document.documentElement.scrollHeight;
    const win_height = window.innerHeight;
    const is_at_bottom = window.scrollY + win_height >= doc_height - buffer;

    if (is_at_bottom) {
        activeTab.value = sections[sections.length - 1].name;
        return;
    }

    let matched = sections[0].name;
    for (let i = 0; i < sections.length; i++) {
        if (current_scroll >= sections[i].top) {
            matched = sections[i].name;
        } else {
            break;
        }
    }
    activeTab.value = matched;
}, 100);


// 处理标签页切换
// 在script setup中添加
const previousTab = ref('detail');

// 修改handleTabChange函数
const handleTabChange = (name) => {
    previousTab.value = activeTab.value;
    activeTab.value = name; // 立即更新activeTab的值
    is_tab_scrolling.value = true;
    nextTick(() => {
        const element = document.getElementById(name);
        if (element) {
            const rect = element.getBoundingClientRect();
            const buffer = 10;
            const offset_top = (tabs_wrapper_height.value || 0) + buffer;
            const topOffset = Math.max(0, rect.top + window.scrollY - offset_top);
            window.scrollTo({ top: topOffset, behavior: 'smooth' });
            setTimeout(() => {
                is_tab_scrolling.value = false;
            }, 500);
        } else {
            is_tab_scrolling.value = false;
        }
    });
};

const goToStudyDetail = (lessonId) => {
    save_scroll_state(lessonId);
    router.push({ path: `/studyDetail/${lessonId}`, query: { from_course_id: course_id.value } });
};

// 打卡相关状态
const showCheckInDialog = ref(false);

// 处理打卡选择
const goToCheckin = () => {
    if(!(task_list.value.length || timeout_task_list.value.length)) {
        showToast('暂无打卡任务');
        return;
    }
    showCheckInDialog.value = true;
};

/**
 * 处理打卡成功
 * 注释：统一弹窗触发成功事件后，页面提示成功。
 */
const handleCheckInSuccess = () => {
    showToast('打卡成功');
}
</script>

<style scoped>
.study-course-page {
    min-height: 100vh;
}

.course-header {
    height: auto;
}

.course-tabs {
    background-color: #fff;
}

.course-catalog {
    background-color: #fff;
}
</style>