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

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.tcm.training.admin.system.dto.MessagePushSettingItemSaveRequest;
import com.tcm.training.admin.system.dto.MessagePushSettingsSaveRequest;
import com.tcm.training.admin.system.entity.MessagePushConfig;
import com.tcm.training.admin.system.mapper.MessagePushConfigMapper;
import com.tcm.training.admin.system.vo.MessagePushSettingVO;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

@Service
public class MessagePushSettingsAppService {

    private static final List<MessagePushTypeDefinition> TYPE_DEFINITIONS = Arrays.asList(
            new MessagePushTypeDefinition("MEMBER_EXPIRE_REMIND", "会员到期提醒", true, true),
            new MessagePushTypeDefinition("LIVE_REMIND", "直播提醒", true, true),
            new MessagePushTypeDefinition("ACTIVITY_NOTICE", "活动通知", true, false),
            new MessagePushTypeDefinition("ORDER_STATUS_UPDATE", "订单状态更新", true, false),
            new MessagePushTypeDefinition("COURSE_UPDATE_NOTICE", "课程更新通知", true, false),
            new MessagePushTypeDefinition("STUDY_PROGRESS_REMIND", "学习进度提醒", true, false)
    );

    private final MessagePushConfigMapper messagePushConfigMapper;

    public MessagePushSettingsAppService(MessagePushConfigMapper messagePushConfigMapper) {
        this.messagePushConfigMapper = messagePushConfigMapper;
    }

    @Transactional
    public List<MessagePushSettingVO> current() {
        ensureDefaults();
        return loadCurrentList();
    }

    @Transactional
    public List<MessagePushSettingVO> saveCurrent(MessagePushSettingsSaveRequest request) {
        ensureDefaults();
        Map<String, MessagePushSettingItemSaveRequest> requestMap = normalizeRequest(request);
        Map<String, MessagePushConfig> currentMap = currentConfigMap();
        for (MessagePushTypeDefinition definition : TYPE_DEFINITIONS) {
            MessagePushSettingItemSaveRequest itemRequest = requestMap.get(definition.getCode());
            MessagePushConfig config = currentMap.get(definition.getCode());
            if (config == null) {
                config = createDefaultConfig(definition);
                messagePushConfigMapper.insert(config);
            }
            config.setPushEnabled(booleanToInteger(itemRequest.getPushEnabled()));
            config.setSmsEnabled(booleanToInteger(itemRequest.getSmsEnabled()));
            messagePushConfigMapper.updateById(config);
        }
        return loadCurrentList();
    }

    private void ensureDefaults() {
        Map<String, MessagePushConfig> currentMap = currentConfigMap();
        for (MessagePushTypeDefinition definition : TYPE_DEFINITIONS) {
            if (!currentMap.containsKey(definition.getCode())) {
                MessagePushConfig config = createDefaultConfig(definition);
                messagePushConfigMapper.insert(config);
            }
        }
    }

    private MessagePushConfig createDefaultConfig(MessagePushTypeDefinition definition) {
        MessagePushConfig config = new MessagePushConfig();
        config.setNoticeTypeCode(definition.getCode());
        config.setNoticeTypeName(definition.getName());
        config.setPushEnabled(booleanToInteger(definition.getDefaultPushEnabled()));
        config.setSmsEnabled(booleanToInteger(definition.getDefaultSmsEnabled()));
        config.setDeleted(0);
        return config;
    }

    private Map<String, MessagePushSettingItemSaveRequest> normalizeRequest(MessagePushSettingsSaveRequest request) {
        Map<String, MessagePushSettingItemSaveRequest> requestMap = new LinkedHashMap<String, MessagePushSettingItemSaveRequest>();
        Set<String> expectedCodes = typeCodeSet();
        for (MessagePushSettingItemSaveRequest item : request.getItems()) {
            String code = item.getNoticeTypeCode().trim();
            if (!expectedCodes.contains(code)) {
                throw new IllegalArgumentException("通知类型不合法");
            }
            if (requestMap.containsKey(code)) {
                throw new IllegalArgumentException("通知类型不能重复");
            }
            item.setNoticeTypeCode(code);
            requestMap.put(code, item);
        }
        if (requestMap.size() != TYPE_DEFINITIONS.size()) {
            throw new IllegalArgumentException("消息推送配置项不完整");
        }
        for (MessagePushTypeDefinition definition : TYPE_DEFINITIONS) {
            if (!requestMap.containsKey(definition.getCode())) {
                throw new IllegalArgumentException("消息推送配置项不完整");
            }
        }
        return requestMap;
    }

    private List<MessagePushSettingVO> loadCurrentList() {
        Map<String, MessagePushConfig> currentMap = currentConfigMap();
        List<MessagePushSettingVO> list = new ArrayList<MessagePushSettingVO>();
        for (MessagePushTypeDefinition definition : TYPE_DEFINITIONS) {
            MessagePushConfig config = currentMap.get(definition.getCode());
            if (config != null) {
                list.add(toVO(config));
            }
        }
        return list;
    }

    private Map<String, MessagePushConfig> currentConfigMap() {
        List<MessagePushConfig> list = messagePushConfigMapper.selectList(new LambdaQueryWrapper<MessagePushConfig>()
                .eq(MessagePushConfig::getDeleted, 0)
                .orderByAsc(MessagePushConfig::getId));
        Map<String, MessagePushConfig> map = new LinkedHashMap<String, MessagePushConfig>();
        for (MessagePushConfig item : list) {
            if (!map.containsKey(item.getNoticeTypeCode())) {
                map.put(item.getNoticeTypeCode(), item);
            }
        }
        return map;
    }

    private Set<String> typeCodeSet() {
        Set<String> codes = new LinkedHashSet<String>();
        for (MessagePushTypeDefinition definition : TYPE_DEFINITIONS) {
            codes.add(definition.getCode());
        }
        return codes;
    }

    private MessagePushSettingVO toVO(MessagePushConfig config) {
        MessagePushSettingVO vo = new MessagePushSettingVO();
        vo.setId(config.getId());
        vo.setNoticeTypeCode(config.getNoticeTypeCode());
        vo.setNoticeTypeName(config.getNoticeTypeName());
        vo.setPushEnabled(integerToBoolean(config.getPushEnabled()));
        vo.setSmsEnabled(integerToBoolean(config.getSmsEnabled()));
        vo.setUpdatedAt(config.getUpdatedAt());
        return vo;
    }

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

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

    private static final class MessagePushTypeDefinition {

        private final String code;
        private final String name;
        private final boolean defaultPushEnabled;
        private final boolean defaultSmsEnabled;

        private MessagePushTypeDefinition(String code, String name, boolean defaultPushEnabled, boolean defaultSmsEnabled) {
            this.code = code;
            this.name = name;
            this.defaultPushEnabled = defaultPushEnabled;
            this.defaultSmsEnabled = defaultSmsEnabled;
        }

        private String getCode() {
            return code;
        }

        private String getName() {
            return name;
        }

        private boolean getDefaultPushEnabled() {
            return defaultPushEnabled;
        }

        private boolean getDefaultSmsEnabled() {
            return defaultSmsEnabled;
        }
    }
}