package com.talentcard.server.service;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeParseException;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Objects;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.talentcard.server.business.BusinessIdGenerator;
import com.talentcard.server.business.PageResult;
import com.talentcard.server.business.merchant.auth.MerchantPrincipal;
import com.talentcard.server.common.BusinessException;
import com.talentcard.server.common.ErrorCode;
import com.talentcard.server.entity.TransportParkingLot;
import com.talentcard.server.entity.TransportParkingPlateRegistration;
import com.talentcard.server.mapper.TransportParkingCardLevelRightMapper;
import com.talentcard.server.mapper.TransportParkingLotMapper;
import com.talentcard.server.mapper.TransportParkingPlateRegistrationMapper;
import com.talentcard.server.request.MerchantParkingPlateRegistrationRequest;
import com.talentcard.server.request.ParkingPlateStatusUpdateRequest;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class ParkingPlateMerchantService {
    private static final String STATUS_SUBMITTED = "SUBMITTED";
    private static final String STATUS_ACTIVE = "ACTIVE";
    private static final String STATUS_REJECTED = "REJECTED";
    private static final String STATUS_CANCELLED = "CANCELLED";
    private static final List<String> OCCUPIED_STATUSES = List.of(STATUS_SUBMITTED, STATUS_ACTIVE);

    private final TransportParkingPlateRegistrationMapper registrationMapper;
    private final TransportParkingCardLevelRightMapper rightMapper;
    private final TransportParkingLotMapper lotMapper;

    public ParkingPlateMerchantService(
            TransportParkingPlateRegistrationMapper registrationMapper,
            TransportParkingCardLevelRightMapper rightMapper,
            TransportParkingLotMapper lotMapper
    ) {
        this.registrationMapper = registrationMapper;
        this.rightMapper = rightMapper;
        this.lotMapper = lotMapper;
    }

    @Transactional(readOnly = true)
    public PageResult<Map<String, Object>> page(MerchantPrincipal principal,
                                                Long parkingLotId,
                                                String keyword,
                                                String cardLevel,
                                                String status,
                                                String submissionType,
                                                String submittedStart,
                                                String submittedEnd,
                                                int page,
                                                int size) {
        requireParkingMerchant(principal.merchantId());
        int safePage = Math.max(page, 1);
        int safeSize = Math.min(Math.max(size, 1), 100);
        LocalDateTime start = startTime(submittedStart, "提交开始日期格式不正确");
        LocalDateTime end = endTime(submittedEnd, "提交结束日期格式不正确");
        String normalizedStatus = normalizeFilterStatus(status);
        String normalizedSubmissionType = normalizeSubmissionType(submissionType, false);
        Long total = registrationMapper.countMerchantPage(principal.merchantId(), parkingLotId, clean(keyword), clean(cardLevel),
                normalizedStatus, normalizedSubmissionType, start, end);
        List<Map<String, Object>> records = registrationMapper.selectMerchantPage(principal.merchantId(), parkingLotId, clean(keyword), clean(cardLevel),
                        normalizedStatus, normalizedSubmissionType, start, end, safeSize, (safePage - 1) * safeSize)
                .stream()
                .map(this::listView)
                .toList();
        return new PageResult<>(records, safePage, safeSize, total == null ? 0 : total);
    }

    @Transactional(readOnly = true)
    public Map<String, Object> detail(MerchantPrincipal principal, Long id) {
        requireParkingMerchant(principal.merchantId());
        Map<String, Object> row = detailRow(principal, id);
        Map<String, Object> result = listView(row);

        Map<String, Object> talent = new LinkedHashMap<>();
        talent.put("talentId", value(row, "talentId", "talent_id"));
        talent.put("talentName", text(row, "talentName", "talent_name"));
        talent.put("talentMobile", text(row, "talentMobile", "talent_mobile"));
        talent.put("cardId", value(row, "cardId", "card_id"));
        talent.put("cardNo", text(row, "cardNo", "card_no"));
        talent.put("cardLevel", text(row, "cardLevel", "card_level"));
        result.put("talentInfo", talent);

        Map<String, Object> submission = new LinkedHashMap<>();
        submission.put("plateNumber", text(row, "plateNumber", "plate_number"));
        submission.put("merchantId", value(row, "merchantId", "merchant_id"));
        submission.put("merchantName", text(row, "merchantName", "merchant_name"));
        submission.put("parkingLotId", value(row, "parkingLotId", "parking_lot_id"));
        submission.put("parkingLotName", text(row, "parkingLotName", "parking_lot_name"));
        submission.put("parkingLotAddress", text(row, "parkingLotAddress", "parking_lot_address"));
        submission.put("submissionType", text(row, "submissionType", "submission_type"));
        submission.put("submittedAt", value(row, "submittedAt", "submitted_at"));
        result.put("submissionInfo", submission);

        Map<String, Object> statusInfo = new LinkedHashMap<>();
        statusInfo.put("status", text(row, "status"));
        statusInfo.put("statusName", statusName(text(row, "status")));
        statusInfo.put("handledAt", value(row, "handledAt", "handled_at"));
        statusInfo.put("handledBy", value(row, "handledBy", "handled_by"));
        statusInfo.put("handledByName", first(text(row, "handledByName", "handled_by_name"), handlerFallback(value(row, "handledBy", "handled_by"))));
        statusInfo.put("handleRemark", text(row, "handleRemark", "handle_remark"));
        result.put("statusInfo", statusInfo);
        return result;
    }

    @Transactional
    public Map<String, Object> create(MerchantPrincipal principal,
                                      MerchantParkingPlateRegistrationRequest request,
                                      String headerIdempotencyKey) {
        Map<String, Object> merchant = requireParkingMerchant(principal.merchantId());
        if (intValue(merchant, "merchantStatus", "merchant_status") != 1) {
            throw new BusinessException(ErrorCode.CONFLICT, "停车商家当前不可用");
        }
        String idempotencyKey = clean(first(headerIdempotencyKey, request.idempotencyKey()));
        if (idempotencyKey.isBlank()) {
            idempotencyKey = BusinessIdGenerator.next("PPI");
        }
        Map<String, Object> existing = registrationMapper.selectByIdempotencyKey(idempotencyKey);
        if (existing != null && !existing.isEmpty()) {
            Long existingId = longValue(existing, "id");
            Map<String, Object> existingDetail = registrationMapper.selectMerchantDetail(existingId, principal.merchantId());
            if (existingDetail == null || existingDetail.isEmpty()) {
                throw new BusinessException(ErrorCode.CONFLICT, "提交凭证已被其他商家使用");
            }
            return detail(principal, existingId);
        }

        Map<String, Object> card = activeCard(request.talentId(), request.cardId());
        Long talentId = longValue(card, "talentId", "talent_id");
        Long cardId = longValue(card, "cardId", "card_id");
        String cardLevel = text(card, "cardLevel", "card_level");
        Map<String, Object> right = rightMapper.selectAvailableForCard(cardLevel, principal.merchantId()).stream().findFirst()
                .orElseThrow(() -> new BusinessException(ErrorCode.CONFLICT, "当前人才卡不适用该停车商家"));
        Long benefitId = longValue(right, "benefitId", "benefit_id");
        if (benefitId == null || benefitId <= 0) {
            throw new BusinessException(ErrorCode.NOT_FOUND, "停车权益配置不存在");
        }
        String selectionMode = normalizeSelectionMode(text(right, "selectionMode", "selection_mode"));
        TransportParkingLot lot = requireParkingLot(principal.merchantId(), request.parkingLotId());
        String plateNumber = request.plateNumber().trim().toUpperCase(Locale.ROOT);

        TransportParkingPlateRegistration original = null;
        String submissionType = "新增";
        if (request.registrationId() != null) {
            original = registrationMapper.selectByIdForUpdate(requirePositive(request.registrationId(), "原车牌登记ID不能为空"));
            if (original == null || !Objects.equals(original.getMerchantId(), principal.merchantId())) {
                throw new BusinessException(ErrorCode.NOT_FOUND, "原车牌登记不存在");
            }
            if (!Objects.equals(original.getTalentId(), talentId)) {
                throw new BusinessException(ErrorCode.BAD_REQUEST, "原车牌登记与当前持卡人不匹配");
            }
            if (!OCCUPIED_STATUSES.contains(original.getStatus())) {
                throw new BusinessException(ErrorCode.CONFLICT, "原车牌登记当前状态不能修改");
            }
            submissionType = "修改";
        }

        long occupied = occupiedCount(talentId, cardId, principal.merchantId(), lot.getId(), selectionMode,
                original == null ? null : original.getId());
        if (occupied > 0) {
            if ("ALL".equals(selectionMode)) {
                throw new BusinessException(ErrorCode.CONFLICT, "该停车场已登记车牌，如需修改请传入原记录ID");
            }
            throw new BusinessException(ErrorCode.CONFLICT, "该停车商家仅能选择一个停车场录入车牌，如需修改请传入原记录ID");
        }

        LocalDateTime now = LocalDateTime.now();
        if (original != null) {
            registrationMapper.update(null, new UpdateWrapper<TransportParkingPlateRegistration>()
                    .set("status", STATUS_CANCELLED)
                    .set("handled_by", principal.operatorId())
                    .set("handled_at", now)
                    .set("handle_remark", "商户端修改车牌重新录入")
                    .eq("id", original.getId())
                    .eq("merchant_id", principal.merchantId())
                    .eq("deleted", 0));
        }

        TransportParkingPlateRegistration registration = new TransportParkingPlateRegistration();
        registration.setRegistrationNo(BusinessIdGenerator.next("PR"));
        registration.setMerchantId(principal.merchantId());
        registration.setBenefitId(benefitId);
        registration.setParkingLotId(lot.getId());
        registration.setParkingLotNameSnapshot(lot.getParkingLotName());
        registration.setParkingLotAddressSnapshot(lot.getAddress());
        registration.setTalentId(talentId);
        registration.setCardId(cardId);
        registration.setTalentName(text(card, "talentName", "talent_name"));
        registration.setTalentMobile(text(card, "talentMobile", "talent_mobile"));
        registration.setCardNo(text(card, "cardNo", "card_no"));
        registration.setCardLevel(cardLevel);
        registration.setPlateNumber(plateNumber);
        registration.setSubmissionType(submissionType);
        registration.setSubmittedAt(now);
        registration.setStatus(STATUS_ACTIVE);
        registration.setIdempotencyKey(idempotencyKey);
        registration.setHandledBy(principal.operatorId());
        registration.setHandledAt(now);
        registration.setHandleRemark(first(request.remark(), "商户端录入并处理"));
        registration.setDeleted(0);
        try {
            registrationMapper.insert(registration);
        } catch (DuplicateKeyException exception) {
            Map<String, Object> repeated = registrationMapper.selectByIdempotencyKey(idempotencyKey);
            if (repeated != null && !repeated.isEmpty()) {
                Long repeatedId = longValue(repeated, "id");
                Map<String, Object> repeatedDetail = registrationMapper.selectMerchantDetail(repeatedId, principal.merchantId());
                if (repeatedDetail != null && !repeatedDetail.isEmpty()) {
                    return detail(principal, repeatedId);
                }
            }
            throw new BusinessException(ErrorCode.CONFLICT, "车牌登记已提交，请稍后查询结果");
        }
        return detail(principal, registration.getId());
    }

    @Transactional
    public Map<String, Object> updateStatus(MerchantPrincipal principal, Long id, ParkingPlateStatusUpdateRequest request) {
        requireParkingMerchant(principal.merchantId());
        Long registrationId = requirePositive(id, "车牌登记ID不能为空");
        TransportParkingPlateRegistration current = registrationMapper.selectByIdForUpdate(registrationId);
        if (current == null || !Objects.equals(current.getMerchantId(), principal.merchantId())) {
            throw new BusinessException(ErrorCode.NOT_FOUND, "车牌登记不存在");
        }
        String nextStatus = normalizeStatus(request.status());
        String remark = clean(request.remark());
        LocalDateTime handledAt = STATUS_SUBMITTED.equals(nextStatus) ? null : LocalDateTime.now();
        UpdateWrapper<TransportParkingPlateRegistration> update = new UpdateWrapper<TransportParkingPlateRegistration>()
                .set("status", nextStatus)
                .set("handled_by", handledAt == null ? null : principal.operatorId())
                .set("handled_at", handledAt)
                .set("handle_remark", remark.isBlank() ? null : remark)
                .eq("id", registrationId)
                .eq("merchant_id", principal.merchantId())
                .eq("deleted", 0);
        int updated = registrationMapper.update(null, update);
        if (updated != 1) {
            throw new BusinessException(ErrorCode.CONFLICT, "车牌登记状态已变化，请刷新后重试");
        }
        return detail(principal, registrationId);
    }

    private Map<String, Object> listView(Map<String, Object> row) {
        Map<String, Object> result = new LinkedHashMap<>();
        String status = text(row, "status");
        result.put("id", value(row, "id"));
        result.put("registrationNo", text(row, "registrationNo", "registration_no"));
        result.put("talentName", text(row, "talentName", "talent_name"));
        result.put("talentMobile", text(row, "talentMobile", "talent_mobile"));
        result.put("cardLevel", text(row, "cardLevel", "card_level"));
        result.put("cardNo", text(row, "cardNo", "card_no"));
        result.put("plateNumber", text(row, "plateNumber", "plate_number"));
        result.put("merchantId", value(row, "merchantId", "merchant_id"));
        result.put("merchantName", text(row, "merchantName", "merchant_name"));
        result.put("parkingLotId", value(row, "parkingLotId", "parking_lot_id"));
        result.put("parkingLotName", text(row, "parkingLotName", "parking_lot_name"));
        result.put("submittedAt", value(row, "submittedAt", "submitted_at"));
        result.put("submissionType", text(row, "submissionType", "submission_type"));
        result.put("status", status);
        result.put("statusName", statusName(status));
        result.put("handledAt", value(row, "handledAt", "handled_at"));
        result.put("handledByName", first(text(row, "handledByName", "handled_by_name"), handlerFallback(value(row, "handledBy", "handled_by"))));
        return result;
    }

    private Map<String, Object> detailRow(MerchantPrincipal principal, Long id) {
        Long registrationId = requirePositive(id, "车牌登记ID不能为空");
        Map<String, Object> row = registrationMapper.selectMerchantDetail(registrationId, principal.merchantId());
        if (row == null || row.isEmpty()) {
            throw new BusinessException(ErrorCode.NOT_FOUND, "车牌登记不存在");
        }
        return row;
    }

    private Map<String, Object> requireParkingMerchant(Long merchantId) {
        Map<String, Object> merchant = registrationMapper.selectParkingMerchant(merchantId);
        if (merchant == null || merchant.isEmpty()) {
            throw new BusinessException(ErrorCode.NOT_FOUND, "停车商家不存在");
        }
        return merchant;
    }

    private Map<String, Object> activeCard(Long talentId, Long cardId) {
        if ((talentId == null || talentId <= 0) && (cardId == null || cardId <= 0)) {
            throw new BusinessException(ErrorCode.BAD_REQUEST, "持卡人ID或人才卡ID不能为空");
        }
        Map<String, Object> card = registrationMapper.selectActiveCardSnapshot(talentId, cardId);
        if (card == null || card.isEmpty()) {
            throw new BusinessException(ErrorCode.NOT_FOUND, "有效人才卡不存在");
        }
        String cardLevel = text(card, "cardLevel", "card_level");
        if (cardLevel.isBlank() || "普通游客".equals(cardLevel)) {
            throw new BusinessException(ErrorCode.CONFLICT, "当前用户无停车权益");
        }
        return card;
    }

    private TransportParkingLot requireParkingLot(Long merchantId, Long parkingLotId) {
        List<TransportParkingLot> lots = lotMapper.selectList(new QueryWrapper<TransportParkingLot>()
                .eq("merchant_id", merchantId)
                .eq("deleted", 0)
                .eq("enabled", 1)
                .orderByAsc("sort_no", "id"));
        if (lots.isEmpty()) {
            throw new BusinessException(ErrorCode.NOT_FOUND, "停车场配置不存在");
        }
        if (parkingLotId == null) {
            if (lots.size() == 1) {
                return lots.get(0);
            }
            throw new BusinessException(ErrorCode.BAD_REQUEST, "请选择停车场");
        }
        return lots.stream()
                .filter(lot -> Objects.equals(lot.getId(), parkingLotId))
                .findFirst()
                .orElseThrow(() -> new BusinessException(ErrorCode.BAD_REQUEST, "停车场不可用"));
    }

    private long occupiedCount(Long talentId, Long cardId, Long merchantId, Long parkingLotId, String selectionMode, Long excludeId) {
        QueryWrapper<TransportParkingPlateRegistration> wrapper = new QueryWrapper<TransportParkingPlateRegistration>()
                .eq("deleted", 0)
                .eq("talent_id", talentId)
                .eq("merchant_id", merchantId)
                .in("status", OCCUPIED_STATUSES);
        if (cardId != null) {
            wrapper.and(query -> query.eq("card_id", cardId).or().isNull("card_id"));
        }
        if ("ALL".equals(selectionMode)) {
            wrapper.eq("parking_lot_id", parkingLotId);
        }
        if (excludeId != null) {
            wrapper.ne("id", excludeId);
        }
        Long count = registrationMapper.selectCount(wrapper);
        return count == null ? 0 : count;
    }

    private String normalizeSelectionMode(String value) {
        String text = clean(value).toUpperCase(Locale.ROOT);
        return "ONE".equals(text) || "SELECT_ONE".equals(text) ? "ONE" : "ALL";
    }

    private String normalizeFilterStatus(String raw) {
        String value = clean(raw);
        return value.isBlank() ? "" : normalizeStatus(value);
    }

    private String normalizeStatus(String raw) {
        String value = clean(raw).toUpperCase(Locale.ROOT).replace("-", "_");
        return switch (value) {
            case "SUBMITTED", "PENDING", "待处理", "待审核" -> STATUS_SUBMITTED;
            case "ACTIVE", "PROCESSED", "PASSED", "APPROVED", "已处理", "处理完成", "通过", "已通过" -> STATUS_ACTIVE;
            case "REJECTED", "REFUSED", "DENIED", "已拒绝", "拒绝", "驳回", "已驳回" -> STATUS_REJECTED;
            case "CANCELLED", "CANCELED", "已取消", "取消" -> STATUS_CANCELLED;
            default -> throw new BusinessException(ErrorCode.BAD_REQUEST, "处理状态不正确");
        };
    }

    private String normalizeSubmissionType(String raw, boolean required) {
        String value = clean(raw);
        if (value.isBlank()) {
            if (required) {
                throw new BusinessException(ErrorCode.BAD_REQUEST, "提交类型不能为空");
            }
            return "";
        }
        String upper = value.toUpperCase(Locale.ROOT);
        return switch (upper) {
            case "CREATE", "ADD", "NEW", "新增" -> "新增";
            case "UPDATE", "MODIFY", "EDIT", "修改" -> "修改";
            default -> throw new BusinessException(ErrorCode.BAD_REQUEST, "提交类型不正确");
        };
    }

    private String statusName(String status) {
        return switch (clean(status).toUpperCase(Locale.ROOT)) {
            case STATUS_ACTIVE -> "已处理";
            case STATUS_REJECTED -> "已拒绝";
            case STATUS_CANCELLED -> "已取消";
            default -> "待处理";
        };
    }

    private LocalDateTime startTime(String value, String message) {
        LocalDate date = localDate(value, message);
        return date == null ? null : date.atStartOfDay();
    }

    private LocalDateTime endTime(String value, String message) {
        LocalDate date = localDate(value, message);
        return date == null ? null : date.plusDays(1).atStartOfDay();
    }

    private LocalDate localDate(String value, String message) {
        String text = clean(value);
        if (text.isBlank()) {
            return null;
        }
        try {
            return LocalDate.parse(text);
        } catch (DateTimeParseException exception) {
            throw new BusinessException(ErrorCode.BAD_REQUEST, message);
        }
    }

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

    private Object value(Map<String, Object> row, String... keys) {
        for (String key : keys) {
            if (row.containsKey(key)) {
                return row.get(key);
            }
        }
        return null;
    }

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

    private int intValue(Map<String, Object> row, String... keys) {
        Object value = value(row, keys);
        return value instanceof Number number ? number.intValue() : 0;
    }

    private Long longValue(Map<String, Object> row, String... keys) {
        Object value = value(row, keys);
        return value instanceof Number number ? number.longValue() : null;
    }

    private String first(String... values) {
        for (String value : values) {
            String text = clean(value);
            if (!text.isBlank()) {
                return text;
            }
        }
        return "";
    }

    private String handlerFallback(Object value) {
        return value instanceof Number number ? "商户操作员" + number.longValue() : "";
    }

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