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

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.tcm.training.admin.system.dto.AgreementContentSaveRequest;
import com.tcm.training.admin.system.entity.AgreementContent;
import com.tcm.training.admin.system.mapper.AgreementContentMapper;
import com.tcm.training.admin.system.vo.AgreementContentItemVO;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

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

@Service
public class AgreementContentAppService {

    private static final String[] AGREEMENT_TYPES = new String[]{
            AgreementContent.TYPE_USER_AGREEMENT,
            AgreementContent.TYPE_PRIVACY_POLICY,
            AgreementContent.TYPE_INVITE_CODE_INSTRUCTIONS
    };

    private final AgreementContentMapper agreementContentMapper;

    public AgreementContentAppService(AgreementContentMapper agreementContentMapper) {
        this.agreementContentMapper = agreementContentMapper;
    }

    public List<AgreementContentItemVO> list() {
        List<AgreementContent> records = agreementContentMapper.selectList(new LambdaQueryWrapper<AgreementContent>()
                .eq(AgreementContent::getDeleted, 0));
        List<AgreementContentItemVO> result = new ArrayList<AgreementContentItemVO>();
        for (String agreementType : AGREEMENT_TYPES) {
            result.add(toItemVO(agreementType, findByType(records, agreementType)));
        }
        return result;
    }

    /**
     * 按协议类型读取单条协议内容，供 APP 协议详情页使用。
     */
    public AgreementContentItemVO detail(String agreementType) {
        String normalizedType = normalizeAgreementType(agreementType);
        AgreementContent record = agreementContentMapper.selectOne(new LambdaQueryWrapper<AgreementContent>()
                .eq(AgreementContent::getAgreementType, normalizedType)
                .eq(AgreementContent::getDeleted, 0)
                .last("limit 1"));
        return toItemVO(normalizedType, record);
    }

    @Transactional
    public AgreementContentItemVO save(String agreementType, AgreementContentSaveRequest request) {
        String normalizedType = normalizeAgreementType(agreementType);
        String contentHtml = normalizeContent(request == null ? null : request.getContentHtml());
        AgreementContent record = agreementContentMapper.selectOne(new LambdaQueryWrapper<AgreementContent>()
                .eq(AgreementContent::getAgreementType, normalizedType)
                .eq(AgreementContent::getDeleted, 0)
                .last("limit 1"));
        if (record == null) {
            record = new AgreementContent();
            record.setAgreementType(normalizedType);
            record.setContentHtml(contentHtml);
            record.setDeleted(0);
            agreementContentMapper.insert(record);
        } else {
            record.setContentHtml(contentHtml);
            agreementContentMapper.updateById(record);
        }
        return toItemVO(normalizedType, record);
    }

    private AgreementContent findByType(List<AgreementContent> records, String agreementType) {
        for (AgreementContent record : records) {
            if (agreementType.equals(record.getAgreementType())) {
                return record;
            }
        }
        return null;
    }

    private AgreementContentItemVO toItemVO(String agreementType, AgreementContent record) {
        AgreementContentItemVO vo = new AgreementContentItemVO();
        vo.setAgreementType(agreementType);
        vo.setAgreementName(resolveAgreementName(agreementType));
        vo.setContentHtml(record == null || record.getContentHtml() == null ? "" : record.getContentHtml());
        return vo;
    }

    private String normalizeAgreementType(String agreementType) {
        String normalized = trimToNull(agreementType);
        if (normalized == null) {
            throw new IllegalArgumentException("协议类型不合法");
        }
        normalized = normalized.toUpperCase();
        for (String item : AGREEMENT_TYPES) {
            if (item.equals(normalized)) {
                return normalized;
            }
        }
        throw new IllegalArgumentException("协议类型不合法");
    }

    private String resolveAgreementName(String agreementType) {
        if (AgreementContent.TYPE_USER_AGREEMENT.equals(agreementType)) {
            return "用户协议";
        }
        if (AgreementContent.TYPE_PRIVACY_POLICY.equals(agreementType)) {
            return "隐私协议";
        }
        if (AgreementContent.TYPE_INVITE_CODE_INSTRUCTIONS.equals(agreementType)) {
            return "获取邀请码说明";
        }
        throw new IllegalArgumentException("协议类型不合法");
    }

    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 String trimToNull(String value) {
        if (value == null) {
            return null;
        }
        String trimmed = value.trim();
        return trimmed.isEmpty() ? null : trimmed;
    }
}