cfc/cfc-backend/src/main/java/com/etotem/cfc/service/AssessmentService.java

package com.etotem.cfc.service;

import com.etotem.cfc.service.api.AssessmentServiceInterface;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.etotem.cfc.entity.AssessmentMaterial;
import com.etotem.cfc.entity.AssessmentPointsConfig;
import com.etotem.cfc.entity.AssessmentRecord;
import com.etotem.cfc.entity.DanAssessmentResult;
import com.etotem.cfc.entity.FamilyAssessmentConfig;
import com.etotem.cfc.mapper.AssessmentMaterialMapper;
import com.etotem.cfc.mapper.AssessmentPointsConfigMapper;
import com.etotem.cfc.mapper.AssessmentRecordMapper;
import com.etotem.cfc.mapper.DanAssessmentResultMapper;
import com.etotem.cfc.mapper.FamilyAssessmentConfigMapper;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;

@Service
public class AssessmentService extends ServiceImpl<AssessmentMaterialMapper, AssessmentMaterial> {

    @Resource
    private AssessmentPointsConfigMapper pointsConfigMapper;

    @Resource
    private FamilyAssessmentConfigMapper familyConfigMapper;

    @Resource
    private AssessmentRecordMapper recordMapper;

    @Resource
    private DanAssessmentResultMapper danAssessmentResultMapper;

    public AssessmentMaterial getActiveMaterial() {
        LambdaQueryWrapper<AssessmentMaterial> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(AssessmentMaterial::getStatus, "active");
        return this.getOne(wrapper);
    }

    public List<AssessmentMaterial> getMaterialList() {
        LambdaQueryWrapper<AssessmentMaterial> wrapper = new LambdaQueryWrapper<>();
        wrapper.orderByDesc(AssessmentMaterial::getCreatedAt);
        return this.list(wrapper);
    }

    public AssessmentMaterial createMaterial(String title, String content, String coverImage) {
        AssessmentMaterial material = new AssessmentMaterial();
        material.setTitle(title);
        material.setContent(content);
        material.setCoverImage(coverImage);
        material.setStatus("active");
        material.setCreatedAt(new Date());
        material.setUpdatedAt(new Date());
        this.save(material);
        return material;
    }

    public AssessmentPointsConfig getPointsConfig() {
        LambdaQueryWrapper<AssessmentPointsConfig> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(AssessmentPointsConfig::getIsActive, 1);
        return pointsConfigMapper.selectOne(wrapper);
    }

    public boolean updatePointsConfig(Integer pointsValue, Double pointsValueYuan) {
        AssessmentPointsConfig config = getPointsConfig();
        if (config == null) {
            config = new AssessmentPointsConfig();
            config.setPointsValue(pointsValue);
            config.setPointsValueYuan((int)(pointsValueYuan * 100));
            config.setIsActive(1);
            config.setCreatedAt(new Date());
            config.setUpdatedAt(new Date());
            return pointsConfigMapper.insert(config) > 0;
        }
        config.setPointsValue(pointsValue);
        config.setPointsValueYuan((int)(pointsValueYuan * 100));
        config.setUpdatedAt(new Date());
        return pointsConfigMapper.updateById(config) > 0;
    }

    public FamilyAssessmentConfig getFamilyConfig(Long familyId) {
        LambdaQueryWrapper<FamilyAssessmentConfig> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(FamilyAssessmentConfig::getFamilyId, familyId);
        return familyConfigMapper.selectOne(wrapper);
    }

    public boolean enableFamilyAssessment(Long familyId, Long materialId, Integer remindMonths, Long createdBy) {
        FamilyAssessmentConfig config = getFamilyConfig(familyId);
        Date now = new Date();
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.MONTH, remindMonths);
        Date nextRemind = cal.getTime();

        if (config == null) {
            config = new FamilyAssessmentConfig();
            config.setFamilyId(familyId);
            config.setMaterialId(materialId);
            config.setRemindMonths(remindMonths);
            config.setLastRemindAt(now);
            config.setNextRemindAt(nextRemind);
            config.setIsEnabled(1);
            config.setCreatedBy(createdBy);
            config.setCreatedAt(now);
            config.setUpdatedAt(now);
            return familyConfigMapper.insert(config) > 0;
        }

        config.setMaterialId(materialId);
        config.setRemindMonths(remindMonths);
        config.setNextRemindAt(nextRemind);
        config.setIsEnabled(1);
        config.setUpdatedAt(now);
        return familyConfigMapper.updateById(config) > 0;
    }

    public boolean disableFamilyAssessment(Long familyId) {
        FamilyAssessmentConfig config = getFamilyConfig(familyId);
        if (config == null) {
            return false;
        }
        config.setIsEnabled(0);
        config.setUpdatedAt(new Date());
        return familyConfigMapper.updateById(config) > 0;
    }

    public List<FamilyAssessmentConfig> getEnabledConfigs() {
        LambdaQueryWrapper<FamilyAssessmentConfig> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(FamilyAssessmentConfig::getIsEnabled, 1);
        return familyConfigMapper.selectList(wrapper);
    }

    public List<FamilyAssessmentConfig> getFamiliesByTeacher(Long teacherId) {
        if (teacherId == null) {
            return familyConfigMapper.selectList(null);
        }
        LambdaQueryWrapper<FamilyAssessmentConfig> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(FamilyAssessmentConfig::getCreatedBy, teacherId);
        return familyConfigMapper.selectList(wrapper);
    }

    public AssessmentRecord createRecord(Long familyId, Long childId, Long materialId) {
        AssessmentRecord record = new AssessmentRecord();
        record.setFamilyId(familyId);
        record.setChildId(childId);
        record.setMaterialId(materialId);
        record.setStatus("pending");
        record.setCreatedAt(new Date());
        recordMapper.insert(record);
        return record;
    }

    public boolean completeRecord(Long recordId) {
        AssessmentRecord record = recordMapper.selectById(recordId);
        if (record == null) {
            return false;
        }
        record.setStatus("completed");
        record.setCompletedAt(new Date());
        return recordMapper.updateById(record) > 0;
    }

    public List<AssessmentRecord> getFamilyRecords(Long familyId) {
        LambdaQueryWrapper<AssessmentRecord> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(AssessmentRecord::getFamilyId, familyId);
        wrapper.orderByDesc(AssessmentRecord::getCreatedAt);
        return recordMapper.selectList(wrapper);
    }

    public AssessmentRecord getCurrentAssessment(Long familyId) {
        LambdaQueryWrapper<AssessmentRecord> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(AssessmentRecord::getFamilyId, familyId);
        wrapper.eq(AssessmentRecord::getStatus, "pending");
        wrapper.orderByDesc(AssessmentRecord::getCreatedAt);
        wrapper.last("LIMIT 1");
        return recordMapper.selectOne(wrapper);
    }

    public DanAssessmentResult recordResult(DanAssessmentResult result) {
        result.setStatus("completed");
        result.setCreatedAt(new Date());
        result.setUpdatedAt(new Date());
        if (result.getAssessmentDate() == null) {
            result.setAssessmentDate(new Date());
        }
        danAssessmentResultMapper.insert(result);
        return result;
    }

    public List<DanAssessmentResult> getResultsByGuide(Long guideId) {
        LambdaQueryWrapper<DanAssessmentResult> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(DanAssessmentResult::getTeacherId, guideId);
        wrapper.orderByDesc(DanAssessmentResult::getCreatedAt);
        return danAssessmentResultMapper.selectList(wrapper);
    }

    public DanAssessmentResult getByAppointmentId(Long appointmentId) {
        LambdaQueryWrapper<DanAssessmentResult> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(DanAssessmentResult::getAppointmentId, appointmentId);
        wrapper.last("LIMIT 1");
        return danAssessmentResultMapper.selectOne(wrapper);
    }

    public List<DanAssessmentResult> getAccessibleResults(Long userId, String role) {
        if ("teacher".equals(role)) {
            return getResultsByGuide(userId);
        }
        return new ArrayList<>();
    }
}