package com.tcm.training.admin.system.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.tcm.training.admin.common.PageResponse;
import com.tcm.training.admin.system.dto.PlatformQualificationPublishStatusRequest;
import com.tcm.training.admin.system.dto.PlatformQualificationSaveRequest;
import com.tcm.training.admin.system.entity.PlatformQualification;
import com.tcm.training.admin.system.mapper.PlatformQualificationMapper;
import com.tcm.training.admin.system.vo.PlatformQualificationDetailVO;
import com.tcm.training.admin.system.vo.PlatformQualificationListItemVO;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.List;

@Service
public class PlatformQualificationAppService {

    private final PlatformQualificationMapper platformQualificationMapper;

    public PlatformQualificationAppService(PlatformQualificationMapper platformQualificationMapper) {
        this.platformQualificationMapper = platformQualificationMapper;
    }

    public PageResponse<PlatformQualificationListItemVO> page(int page, int pageSize, String qualificationName) {
        LambdaQueryWrapper<PlatformQualification> queryWrapper = new LambdaQueryWrapper<PlatformQualification>()
                .eq(PlatformQualification::getDeleted, 0)
                .like(qualificationName != null && !qualificationName.trim().isEmpty(),
                        PlatformQualification::getQualificationName,
                        qualificationName == null ? null : qualificationName.trim())
                .orderByDesc(PlatformQualification::getCreatedAt)
                .orderByDesc(PlatformQualification::getId);
        IPage<PlatformQualification> result = platformQualificationMapper.selectPage(
                new Page<PlatformQualification>(page, pageSize),
                queryWrapper
        );
        List<PlatformQualificationListItemVO> list = new ArrayList<PlatformQualificationListItemVO>();
        for (PlatformQualification item : result.getRecords()) {
            list.add(toListItem(item));
        }
        return PageResponse.of(list, result.getTotal(), result.getCurrent(), result.getSize());
    }

    public PlatformQualificationDetailVO detail(Long id) {
        return toDetailVO(requireItem(id));
    }

    @Transactional
    public PlatformQualificationDetailVO create(PlatformQualificationSaveRequest request) {
        PlatformQualification item = new PlatformQualification();
        fillEntity(item, request);
        item.setDeleted(0);
        platformQualificationMapper.insert(item);
        return detail(item.getId());
    }

    @Transactional
    public PlatformQualificationDetailVO update(Long id, PlatformQualificationSaveRequest request) {
        PlatformQualification item = requireItem(id);
        fillEntity(item, request);
        platformQualificationMapper.updateById(item);
        return detail(id);
    }

    @Transactional
    public void delete(Long id) {
        requireItem(id);
        platformQualificationMapper.deleteById(id);
    }

    @Transactional
    public void patchPublishStatus(Long id, PlatformQualificationPublishStatusRequest request) {
        PlatformQualification item = requireItem(id);
        item.setPublishEnabled(booleanToInteger(request.getPublishEnabled()));
        platformQualificationMapper.updateById(item);
    }

    private void fillEntity(PlatformQualification item, PlatformQualificationSaveRequest request) {
        String qualificationType = normalizeQualificationType(request.getQualificationType());
        item.setQualificationName(normalizeRequired(request.getQualificationName(), "请输入资质名称"));
        item.setQualificationType(qualificationType);
        item.setRecordNumber(normalizeRequired(request.getRecordNumber(), "请输入备案号"));
        item.setSort(request.getSort());
        item.setPublishEnabled(booleanToInteger(request.getPublishEnabled()));

        if (PlatformQualification.TYPE_RICH_TEXT.equals(qualificationType)) {
            item.setContentHtml(normalizeContent(request.getContentHtml()));
            item.setLinkUrl(null);
            return;
        }

        item.setLinkUrl(normalizeRequired(request.getLinkUrl(), "请输入跳转链接"));
        item.setContentHtml(null);
    }

    private PlatformQualification requireItem(Long id) {
        PlatformQualification item = platformQualificationMapper.selectOne(new LambdaQueryWrapper<PlatformQualification>()
                .eq(PlatformQualification::getId, id)
                .eq(PlatformQualification::getDeleted, 0)
                .last("limit 1"));
        if (item == null) {
            throw new IllegalArgumentException("平台资质不存在");
        }
        return item;
    }

    private PlatformQualificationListItemVO toListItem(PlatformQualification item) {
        PlatformQualificationListItemVO vo = new PlatformQualificationListItemVO();
        vo.setId(item.getId());
        vo.setQualificationName(item.getQualificationName());
        vo.setQualificationType(item.getQualificationType());
        vo.setRecordNumber(item.getRecordNumber());
        vo.setSort(item.getSort());
        vo.setPublishEnabled(integerToBoolean(item.getPublishEnabled()));
        vo.setCreatedBy(item.getCreatedBy());
        vo.setCreatedAt(item.getCreatedAt());
        return vo;
    }

    private PlatformQualificationDetailVO toDetailVO(PlatformQualification item) {
        PlatformQualificationDetailVO vo = new PlatformQualificationDetailVO();
        vo.setId(item.getId());
        vo.setQualificationName(item.getQualificationName());
        vo.setQualificationType(item.getQualificationType());
        vo.setRecordNumber(item.getRecordNumber());
        vo.setContentHtml(item.getContentHtml());
        vo.setLinkUrl(item.getLinkUrl());
        vo.setSort(item.getSort());
        vo.setPublishEnabled(integerToBoolean(item.getPublishEnabled()));
        vo.setCreatedBy(item.getCreatedBy());
        vo.setUpdatedBy(item.getUpdatedBy());
        vo.setCreatedAt(item.getCreatedAt());
        vo.setUpdatedAt(item.getUpdatedAt());
        return vo;
    }

    private String normalizeQualificationType(String qualificationType) {
        String normalized = normalizeRequired(qualificationType, "请选择资质类型").toUpperCase();
        if (PlatformQualification.TYPE_RICH_TEXT.equals(normalized) || PlatformQualification.TYPE_LINK.equals(normalized)) {
            return normalized;
        }
        throw new IllegalArgumentException("资质类型不合法");
    }

    private String normalizeRequired(String value, String message) {
        String trimmed = trimToNull(value);
        if (trimmed == null) {
            throw new IllegalArgumentException(message);
        }
        return trimmed;
    }

    private String normalizeContent(String contentHtml) {
        String trimmed = trimToNull(contentHtml);
        if (trimmed == null || isBlankRichText(trimmed)) {
            throw new IllegalArgumentException("请输入资质内容");
        }
        return trimmed;
    }

    private boolean isBlankRichText(String html) {
        String normalized = html
                .replaceAll("(?i)<br\\s*/?>", "")
                .replaceAll("(?i)</p>", "")
                .replace("&nbsp;", "")
                .replace("&#160;", "")
                .replaceAll("<[^>]+>", "")
                .trim();
        if (!normalized.isEmpty()) {
            return false;
        }
        String lowerCaseHtml = html.toLowerCase();
        return !lowerCaseHtml.contains("<img")
                && !lowerCaseHtml.contains("<video")
                && !lowerCaseHtml.contains("<audio")
                && !lowerCaseHtml.contains("<iframe");
    }

    private Integer booleanToInteger(Boolean value) {
        return Boolean.TRUE.equals(value) ? 1 : 0;
    }

    private Boolean integerToBoolean(Integer value) {
        return value != null && value == 1;
    }

    private String trimToNull(String value) {
        if (value == null) {
            return null;
        }
        String trimmed = value.trim();
        return trimmed.isEmpty() ? null : trimmed;
    }
}