package com.talentcard.server.service;

import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Objects;
import java.util.Set;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.talentcard.server.business.PageResult;
import com.talentcard.server.common.BusinessException;
import com.talentcard.server.common.ErrorCode;
import com.talentcard.server.entity.MerchantCardBenefit;
import com.talentcard.server.entity.MerchantDisplayPolicyMerchant;
import com.talentcard.server.entity.ShoppingTopicMerchant;
import com.talentcard.server.mapper.DisplayServiceMapper;
import com.talentcard.server.mapper.MerchantCardBenefitMapper;
import com.talentcard.server.mapper.ShoppingTopicMerchantMapper;
import com.talentcard.server.request.DisplayServiceSaveRequest;
import com.talentcard.server.request.DisplayServiceSortBatchRequest;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class DisplayServiceAdminService {

    private static final List<Category> CATEGORIES = List.of(
            new Category("parking", "停车"),
            new Category("medical", "体检"),
            new Category("housing", "购房"),
            new Category("car", "购车"),
            new Category("appliance", "家电"),
            new Category("apartment", "公寓租赁")
    );
    private static final Set<String> CATEGORY_KEYS = Set.of("parking", "medical", "housing", "car", "appliance", "apartment");
    private static final Set<String> SHOPPING_CATEGORY_KEYS = Set.of("housing", "car", "appliance");
    private static final Map<String, String> CATEGORY_MERCHANT_TYPES = Map.of(
            "parking", "parking",
            "medical", "medical",
            "apartment", "apartment",
            "housing", "shopping",
            "car", "shopping",
            "appliance", "shopping"
    );

    private final DisplayServiceMapper serviceMapper;
    private final MerchantCardBenefitMapper benefitMapper;
    private final ShoppingTopicMerchantMapper shoppingMapper;

    public DisplayServiceAdminService(
            DisplayServiceMapper serviceMapper,
            MerchantCardBenefitMapper benefitMapper,
            ShoppingTopicMerchantMapper shoppingMapper
    ) {
        this.serviceMapper = serviceMapper;
        this.benefitMapper = benefitMapper;
        this.shoppingMapper = shoppingMapper;
    }

    @Transactional(readOnly = true)
    public List<Map<String, Object>> categories() {
        return CATEGORIES.stream().map(category -> {
            Map<String, Object> result = new LinkedHashMap<>();
            result.put("key", category.key());
            result.put("name", category.name());
            return result;
        }).toList();
    }

    @Transactional(readOnly = true)
    public PageResult<Map<String, Object>> page(String category, String keyword, Integer status, int page, int size) {
        validateCategoryFilter(category);
        validateStatus(status, "上下架状态只能为1上架或0下架");
        int safePage = Math.max(page, 1);
        int safeSize = Math.min(Math.max(size, 1), 100);
        List<Map<String, Object>> records = serviceMapper.selectAdminPage(
                        clean(category),
                        clean(keyword),
                        status,
                        safeSize,
                        (safePage - 1) * safeSize
                ).stream()
                .map(this::view)
                .toList();
        Long total = serviceMapper.countAdminPage(clean(category), clean(keyword), status);
        return new PageResult<>(records, safePage, safeSize, total == null ? 0 : total);
    }

    @Transactional(readOnly = true)
    public Map<String, Object> detail(Long serviceId) {
        Long id = requireId(serviceId, "展示服务ID不能为空");
        Map<String, Object> row = serviceMapper.selectAdminDetail(id);
        if (row == null || row.isEmpty()) {
            throw new BusinessException(ErrorCode.NOT_FOUND, "展示服务不存在");
        }
        List<Map<String, Object>> policies = benefitMapper.selectList(new QueryWrapper<MerchantCardBenefit>()
                        .eq("merchant_id", id)
                        .orderByDesc("sort_no")
                        .orderByDesc("id"))
                .stream()
                .map(this::policyView)
                .toList();
        Map<String, Object> result = view(row);
        result.put("cardPolicies", policies);
        return result;
    }

    @Transactional
    public Map<String, Object> create(DisplayServiceSaveRequest request) {
        String category = validateCategory(request.category());
        String merchantType = CATEGORY_MERCHANT_TYPES.get(category);
        MerchantDisplayPolicyMerchant merchant = new MerchantDisplayPolicyMerchant();
        applyMerchant(merchant, request, merchantType);
        merchant.setDeleted(0);
        serviceMapper.insert(merchant);
        if (SHOPPING_CATEGORY_KEYS.contains(category)) {
            upsertShoppingMapping(merchant.getId(), category, merchant.getSortNo());
        }
        upsertCardPolicies(merchant.getId(), request.cardPolicies());
        return detail(merchant.getId());
    }

    @Transactional
    public Map<String, Object> update(Long serviceId, DisplayServiceSaveRequest request) {
        Long id = requireId(serviceId, "展示服务ID不能为空");
        requireMerchant(id);
        String category = validateCategory(request.category());
        String merchantType = CATEGORY_MERCHANT_TYPES.get(category);
        int sortNo = request.sortNo() == null ? 0 : request.sortNo();
        int status = request.status() == null ? 1 : request.status();
        validateStatus(status, "上下架状态只能为1上架或0下架");
        int updated = serviceMapper.update(null, new UpdateWrapper<MerchantDisplayPolicyMerchant>()
                .set("merchant_name", cleanRequired(request.merchantName(), "展示服务名称不能为空"))
                .set("merchant_type", merchantType)
                .set("contact_name", clean(request.contactName()))
                .set("contact_mobile", clean(request.contactMobile()))
                .set("logo_url", clean(request.logoUrl()))
                .set("cover_url", clean(request.coverUrl()))
                .set("address", clean(request.address()))
                .set("service_label", clean(request.serviceLabel()))
                .set("rights_text", clean(request.rightsText()))
                .set("usage_instructions", clean(request.handlingInstructions()))
                .set("sort_no", sortNo)
                .set("status", status)
                .set("recommend", request.recommend() == null ? 0 : request.recommend())
                .eq("id", id)
                .eq("deleted", 0));
        if (updated != 1) {
            throw new BusinessException(ErrorCode.CONFLICT, "展示服务信息已变更，请刷新后重试");
        }
        if (SHOPPING_CATEGORY_KEYS.contains(category)) {
            upsertShoppingMapping(id, category, sortNo);
        } else {
            removeShoppingMapping(id);
        }
        upsertCardPolicies(id, request.cardPolicies());
        return detail(id);
    }

    @Transactional
    public Map<String, Object> updateStatus(Long serviceId, Integer status) {
        Long id = requireId(serviceId, "展示服务ID不能为空");
        requireMerchant(id);
        validateStatus(status, "上下架状态只能为1上架或0下架");
        int updated = serviceMapper.update(null, new UpdateWrapper<MerchantDisplayPolicyMerchant>()
                .set("status", status)
                .eq("id", id)
                .eq("deleted", 0));
        if (updated != 1) {
            throw new BusinessException(ErrorCode.CONFLICT, "展示服务状态已变更，请刷新后重试");
        }
        return detail(id);
    }

    @Transactional
    public Map<String, Object> updateSort(Long serviceId, Integer sortNo) {
        Long id = requireId(serviceId, "展示服务ID不能为空");
        requireMerchant(id);
        int sort = sortNo == null ? 0 : sortNo;
        int updated = serviceMapper.update(null, new UpdateWrapper<MerchantDisplayPolicyMerchant>()
                .set("sort_no", sort)
                .eq("id", id)
                .eq("deleted", 0));
        if (updated != 1) {
            throw new BusinessException(ErrorCode.CONFLICT, "展示服务状态已变更，请刷新后重试");
        }
        shoppingMapper.update(null, new UpdateWrapper<ShoppingTopicMerchant>()
                .set("sort_no", sort)
                .eq("merchant_id", id)
                .eq("deleted", 0));
        return detail(id);
    }

    @Transactional
    public Map<String, Object> updateSortBatch(DisplayServiceSortBatchRequest request) {
        if (request.items() == null || request.items().isEmpty()) {
            throw new BusinessException(ErrorCode.BAD_REQUEST, "排序项列表不能为空");
        }
        int updatedCount = 0;
        for (DisplayServiceSortBatchRequest.SortItem item : request.items()) {
            Long id = requireId(item.serviceId(), "展示服务ID不能为空");
            requireMerchant(id);
            int sort = item.sortNo() == null ? 0 : item.sortNo();
            int updated = serviceMapper.update(null, new UpdateWrapper<MerchantDisplayPolicyMerchant>()
                    .set("sort_no", sort)
                    .eq("id", id)
                    .eq("deleted", 0));
            if (updated != 1) {
                throw new BusinessException(ErrorCode.CONFLICT, "展示服务状态已变更，请刷新后重试");
            }
            shoppingMapper.update(null, new UpdateWrapper<ShoppingTopicMerchant>()
                    .set("sort_no", sort)
                    .eq("merchant_id", id)
                    .eq("deleted", 0));
            updatedCount++;
        }
        Map<String, Object> result = new LinkedHashMap<>();
        result.put("updated", updatedCount);
        return result;
    }

    private void applyMerchant(MerchantDisplayPolicyMerchant merchant, DisplayServiceSaveRequest request, String merchantType) {
        merchant.setMerchantName(cleanRequired(request.merchantName(), "展示服务名称不能为空"));
        merchant.setMerchantType(merchantType);
        merchant.setContactName(clean(request.contactName()));
        merchant.setContactMobile(clean(request.contactMobile()));
        merchant.setLogoUrl(clean(request.logoUrl()));
        merchant.setCoverUrl(clean(request.coverUrl()));
        merchant.setAddress(clean(request.address()));
        merchant.setServiceLabel(clean(request.serviceLabel()));
        merchant.setRightsText(clean(request.rightsText()));
        merchant.setUsageInstructions(clean(request.handlingInstructions()));
        merchant.setSortNo(request.sortNo() == null ? 0 : request.sortNo());
        int status = request.status() == null ? 1 : request.status();
        validateStatus(status, "上下架状态只能为1上架或0下架");
        merchant.setStatus(status);
        merchant.setRecommend(request.recommend() == null ? 0 : request.recommend());
    }

    private void upsertShoppingMapping(Long merchantId, String categoryKey, int sortNo) {
        ShoppingTopicMerchant mapping = shoppingMapper.selectOne(new QueryWrapper<ShoppingTopicMerchant>()
                .eq("merchant_id", merchantId)
                .last("limit 1"));
        if (mapping == null) {
            ShoppingTopicMerchant entity = new ShoppingTopicMerchant();
            entity.setMerchantId(merchantId);
            entity.setCategoryKey(categoryKey);
            entity.setSortNo(sortNo);
            entity.setDeleted(0);
            shoppingMapper.insert(entity);
            return;
        }
        int updated = shoppingMapper.update(null, new UpdateWrapper<ShoppingTopicMerchant>()
                .set("category_key", categoryKey)
                .set("sort_no", sortNo)
                .set("deleted", 0)
                .eq("id", mapping.getId()));
        if (updated != 1) {
            throw new BusinessException(ErrorCode.CONFLICT, "服务分类映射已变更，请刷新后重试");
        }
    }

    private void removeShoppingMapping(Long merchantId) {
        shoppingMapper.update(null, new UpdateWrapper<ShoppingTopicMerchant>()
                .set("deleted", 1)
                .eq("merchant_id", merchantId)
                .eq("deleted", 0));
    }

    private void upsertCardPolicies(Long merchantId, List<DisplayServiceSaveRequest.CardPolicy> policies) {
        if (policies == null || policies.isEmpty()) {
            return;
        }
        if (policies.stream().anyMatch(Objects::isNull)) {
            throw new BusinessException(ErrorCode.BAD_REQUEST, "人才卡级别政策不能为空");
        }
        Set<String> levels = new LinkedHashSet<>();
        for (DisplayServiceSaveRequest.CardPolicy policy : policies) {
            String level = normalizeCardLevel(policy.cardLevel());
            if (level.isBlank()) {
                throw new BusinessException(ErrorCode.BAD_REQUEST, "人才卡级别不能为空");
            }
            levels.add(level);
        }
        if (levels.size() != policies.size()) {
            throw new BusinessException(ErrorCode.BAD_REQUEST, "同一服务不能包含重复的人才卡级别");
        }
        for (DisplayServiceSaveRequest.CardPolicy policy : policies) {
            saveCardPolicy(merchantId, policy);
        }
    }

    private void saveCardPolicy(Long merchantId, DisplayServiceSaveRequest.CardPolicy request) {
        String cardLevel = normalizeCardLevel(request.cardLevel());
        String benefitText = clean(request.benefitText());
        if (benefitText.isBlank()) {
            throw new BusinessException(ErrorCode.BAD_REQUEST, "优惠政策内容不能为空");
        }
        int status = request.status() == null ? 1 : request.status();
        validateStatus(status, "政策状态只能为1启用或0停用");
        MerchantCardBenefit current = benefitMapper.selectOne(new QueryWrapper<MerchantCardBenefit>()
                .eq("merchant_id", merchantId)
                .eq("card_level", cardLevel)
                .last("limit 1"));
        if (current == null) {
            MerchantCardBenefit benefit = new MerchantCardBenefit();
            benefit.setMerchantId(merchantId);
            benefit.setCardLevel(cardLevel);
            benefit.setCardName(firstNonBlank(request.cardName(), defaultCardName(cardLevel)));
            benefit.setBenefitText(benefitText);
            benefit.setTheme(firstNonBlank(request.theme(), defaultTheme(cardLevel)));
            benefit.setSortNo(request.sortNo() == null ? defaultSortNo(cardLevel) : request.sortNo());
            benefit.setStatus(status);
            try {
                benefitMapper.insert(benefit);
            } catch (DuplicateKeyException exception) {
                throw new BusinessException(ErrorCode.CONFLICT, "该服务的人才卡级别政策已存在，请刷新后重试");
            }
            return;
        }
        int updated = benefitMapper.update(null, new UpdateWrapper<MerchantCardBenefit>()
                .set("card_name", firstNonBlank(request.cardName(), defaultCardName(cardLevel)))
                .set("benefit_text", benefitText)
                .set("theme", firstNonBlank(request.theme(), defaultTheme(cardLevel)))
                .set("sort_no", request.sortNo() == null ? current.getSortNo() : request.sortNo())
                .set("status", status)
                .eq("id", current.getId()));
        if (updated != 1) {
            throw new BusinessException(ErrorCode.CONFLICT, "政策配置已变更，请刷新后重试");
        }
    }

    private MerchantDisplayPolicyMerchant requireMerchant(Long id) {
        MerchantDisplayPolicyMerchant merchant = serviceMapper.selectOne(new QueryWrapper<MerchantDisplayPolicyMerchant>()
                .eq("id", id)
                .eq("deleted", 0)
                .last("limit 1"));
        if (merchant == null) {
            throw new BusinessException(ErrorCode.NOT_FOUND, "展示服务不存在");
        }
        return merchant;
    }

    private Map<String, Object> view(Map<String, Object> row) {
        Map<String, Object> result = new LinkedHashMap<>();
        result.put("serviceId", value(row, "merchantId"));
        result.put("merchantId", value(row, "merchantId"));
        result.put("serviceName", text(row, "merchantName"));
        result.put("merchantName", text(row, "merchantName"));
        result.put("category", text(row, "category"));
        result.put("categoryName", categoryName(text(row, "category")));
        result.put("merchantType", text(row, "merchantType"));
        result.put("contactName", text(row, "contactName"));
        result.put("contactMobile", text(row, "contactMobile"));
        result.put("logoUrl", text(row, "logoUrl"));
        result.put("coverUrl", text(row, "coverUrl"));
        result.put("address", text(row, "address"));
        result.put("businessStatus", text(row, "businessStatus"));
        result.put("longitude", value(row, "longitude"));
        result.put("latitude", value(row, "latitude"));
        result.put("serviceLabel", text(row, "serviceLabel"));
        result.put("rightsText", text(row, "rightsText"));
        result.put("handlingInstructions", text(row, "handlingInstructions"));
        result.put("recommend", intValue(value(row, "recommend")));
        result.put("sortNo", intValue(value(row, "sortNo")));
        result.put("status", intValue(value(row, "status")));
        result.put("statusName", intValue(value(row, "status")) == 1 ? "上架" : "下架");
        result.put("policyCount", intValue(value(row, "policyCount")));
        result.put("cardPolicies", List.of());
        result.put("createdAt", value(row, "createdAt"));
        result.put("updatedAt", value(row, "updatedAt"));
        return result;
    }

    private Map<String, Object> policyView(MerchantCardBenefit benefit) {
        Map<String, Object> result = new LinkedHashMap<>();
        result.put("id", benefit.getId());
        result.put("cardLevel", benefit.getCardLevel());
        result.put("cardName", benefit.getCardName());
        result.put("benefitText", benefit.getBenefitText());
        result.put("theme", benefit.getTheme());
        result.put("sortNo", benefit.getSortNo());
        result.put("status", benefit.getStatus());
        result.put("statusName", intValue(benefit.getStatus()) == 1 ? "启用" : "停用");
        result.put("createdAt", benefit.getCreatedAt());
        result.put("updatedAt", benefit.getUpdatedAt());
        return result;
    }

    private String validateCategory(String category) {
        String value = clean(category);
        if (!CATEGORY_KEYS.contains(value)) {
            throw new BusinessException(ErrorCode.BAD_REQUEST, "服务分类不正确，仅支持停车、体检、购房、购车、家电、公寓租赁");
        }
        return value;
    }

    private void validateCategoryFilter(String category) {
        String value = clean(category);
        if (!value.isBlank() && !CATEGORY_KEYS.contains(value)) {
            throw new BusinessException(ErrorCode.BAD_REQUEST, "服务分类不正确，仅支持停车、体检、购房、购车、家电、公寓租赁");
        }
    }

    private void validateStatus(Integer status, String message) {
        if (status != null && status != 0 && status != 1) {
            throw new BusinessException(ErrorCode.BAD_REQUEST, message);
        }
    }

    private String categoryName(String key) {
        return CATEGORIES.stream()
                .filter(category -> category.key().equals(key))
                .map(Category::name)
                .findFirst()
                .orElse(key);
    }

    private String normalizeCardLevel(String value) {
        String raw = clean(value);
        String upper = raw.toUpperCase(Locale.ROOT);
        if (upper.contains("EXCELLENT") || raw.contains("卓越")) {
            return "EXCELLENT";
        }
        if (upper.contains("OUTSTANDING") || raw.contains("杰出")) {
            return "OUTSTANDING";
        }
        if (upper.contains("ELITE") || raw.contains("精英")) {
            return "ELITE";
        }
        return upper;
    }

    private String defaultCardName(String cardLevel) {
        return switch (cardLevel) {
            case "EXCELLENT" -> "卓越人才卡";
            case "OUTSTANDING" -> "杰出人才卡";
            case "ELITE" -> "精英人才卡";
            default -> cardLevel;
        };
    }

    private String defaultTheme(String cardLevel) {
        return switch (cardLevel) {
            case "EXCELLENT" -> "excellent";
            case "OUTSTANDING" -> "outstanding";
            case "ELITE" -> "elite";
            default -> "default";
        };
    }

    private int defaultSortNo(String cardLevel) {
        return switch (cardLevel) {
            case "EXCELLENT" -> 30;
            case "OUTSTANDING" -> 20;
            case "ELITE" -> 10;
            default -> 0;
        };
    }

    private Long requireId(Long id, String message) {
        if (id == null || id <= 0) {
            throw new BusinessException(ErrorCode.BAD_REQUEST, message);
        }
        return id;
    }

    private String cleanRequired(String value, String message) {
        String text = clean(value);
        if (text.isBlank()) {
            throw new BusinessException(ErrorCode.BAD_REQUEST, message);
        }
        return text;
    }

    private Object value(Map<String, Object> row, String key) {
        return row == null ? null : row.get(key);
    }

    private String text(Map<String, Object> row, String key) {
        Object value = value(row, key);
        return value == null ? "" : String.valueOf(value).trim();
    }

    private int intValue(Object value) {
        return value instanceof Number number ? number.intValue() : 0;
    }

    private String firstNonBlank(String first, String fallback) {
        String value = clean(first);
        return value.isBlank() ? fallback : value;
    }

    private String clean(String value) {
        return value == null ? "" : value.trim();
    }

    private record Category(String key, String name) {
    }
}