package com.trafficaudit.holiday.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.trafficaudit.holiday.HolidayConstants;
import com.trafficaudit.holiday.HolidayNumberUtils;
import com.trafficaudit.holiday.entity.HolidayVehicleAdjustment;
import com.trafficaudit.holiday.entity.HolidayVehicleFlow;
import com.trafficaudit.holiday.mapper.HolidayVehicleFlowMapper;
import com.trafficaudit.holiday.mapper.HolidayVehicleAdjustmentMapper;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

@Service
public class HolidayVehicleAdjustmentService {

    private static final int REASON_MAX_LENGTH = 500;

    @Resource
    private HolidayVehicleAdjustmentMapper adjustmentMapper;
    @Resource
    private HolidayVehicleFlowMapper vehicleFlowMapper;

    public List<HolidayVehicleAdjustment> list(Integer year) {
        List<HolidayVehicleAdjustment> rows = adjustmentMapper.selectList(
                new LambdaQueryWrapper<HolidayVehicleAdjustment>()
                        .eq(year != null, HolidayVehicleAdjustment::getYear, year)
                        .orderByDesc(HolidayVehicleAdjustment::getYear)
                        .orderByAsc(HolidayVehicleAdjustment::getFlowDate));
        if (rows.isEmpty()) return rows;

        Set<Integer> years = new HashSet<>();
        for (HolidayVehicleAdjustment row : rows) {
            if (row.getYear() != null) years.add(row.getYear());
        }
        if (years.isEmpty()) return rows;

        List<HolidayVehicleFlow> sourceRows = vehicleFlowMapper.selectList(
                new LambdaQueryWrapper<HolidayVehicleFlow>()
                        .eq(HolidayVehicleFlow::getRoadCategory, HolidayConstants.ROAD_NATIONAL_PROVINCIAL)
                        .eq(HolidayVehicleFlow::getVehicleType, HolidayConstants.VEHICLE_MEDIUM_SMALL_PASSENGER)
                        .in(HolidayVehicleFlow::getYear, years));
        Map<String, BigDecimal> originalValues = new HashMap<>();
        for (HolidayVehicleFlow sourceRow : sourceRows) {
            if (sourceRow.getYear() == null || sourceRow.getFlowDate() == null || sourceRow.getVehicleCount() == null) {
                continue;
            }
            originalValues.put(sourceKey(sourceRow.getYear(), sourceRow.getFlowDate()), sourceRow.getVehicleCount());
        }
        for (HolidayVehicleAdjustment row : rows) {
            if (row.getYear() != null && row.getFlowDate() != null) {
                row.setOriginalValue(originalValues.get(sourceKey(row.getYear(), row.getFlowDate())));
            }
        }
        return rows;
    }

    public BigDecimal findOriginalValue(Integer year, LocalDate flowDate) {
        if (year == null || flowDate == null || flowDate.getYear() != year) {
            throw new IllegalArgumentException("年份和日期不正确");
        }
        HolidayVehicleFlow sourceRow = vehicleFlowMapper.selectOne(
                new LambdaQueryWrapper<HolidayVehicleFlow>()
                        .eq(HolidayVehicleFlow::getYear, year)
                        .eq(HolidayVehicleFlow::getFlowDate, flowDate)
                        .eq(HolidayVehicleFlow::getRoadCategory, HolidayConstants.ROAD_NATIONAL_PROVINCIAL)
                        .eq(HolidayVehicleFlow::getVehicleType, HolidayConstants.VEHICLE_MEDIUM_SMALL_PASSENGER)
                        .last("limit 1"));
        return sourceRow == null ? null : sourceRow.getVehicleCount();
    }

    @Transactional
    public HolidayVehicleAdjustment save(Map<String, Object> params) {
        Long id = longValue(params.get("id"));
        Integer year = intValue(params.get("year"));
        LocalDate flowDate = dateValue(params.get("flowDate"));
        BigDecimal adjustedValue = decimalValue(params.get("adjustedValue"));
        String reason = textValue(params.get("reason"));

        if (year == null || year < 2000 || year > 2100) {
            throw new IllegalArgumentException("年份不正确");
        }
        if (year >= LocalDate.now().getYear()) {
            throw new IllegalArgumentException("往年国省道数据调整仅维护历史年份");
        }
        if (flowDate == null || flowDate.getYear() != year) {
            throw new IllegalArgumentException("日期必须属于所选年份");
        }
        if (adjustedValue == null || adjustedValue.compareTo(BigDecimal.ZERO) < 0) {
            throw new IllegalArgumentException("调整后的国省道车流量不能小于 0");
        }
        if (reason.isEmpty()) {
            throw new IllegalArgumentException("调整原因不能为空");
        }
        if (reason.length() > REASON_MAX_LENGTH) {
            throw new IllegalArgumentException("调整原因不能超过 " + REASON_MAX_LENGTH + " 个字符");
        }

        HolidayVehicleAdjustment sameKey = adjustmentMapper.selectOne(
                new LambdaQueryWrapper<HolidayVehicleAdjustment>()
                        .eq(HolidayVehicleAdjustment::getYear, year)
                        .eq(HolidayVehicleAdjustment::getFlowDate, flowDate)
                        .last("limit 1"));
        HolidayVehicleAdjustment entity;
        if (id == null) {
            entity = sameKey == null ? new HolidayVehicleAdjustment() : sameKey;
        } else {
            entity = adjustmentMapper.selectById(id);
            if (entity == null) {
                throw new IllegalArgumentException("调整记录不存在");
            }
            if (sameKey != null && !sameKey.getId().equals(id)) {
                throw new IllegalArgumentException("该年份和日期已存在调整记录");
            }
        }

        if (entity.getId() == null) {
            entity.setCreatedAt(LocalDateTime.now());
        }
        entity.setYear(year);
        entity.setFlowDate(flowDate);
        entity.setAdjustedValue(HolidayNumberUtils.normalize(adjustedValue));
        entity.setReason(reason);
        entity.setUpdatedAt(LocalDateTime.now());
        if (entity.getId() == null) {
            adjustmentMapper.insert(entity);
        } else {
            adjustmentMapper.updateById(entity);
        }
        return entity;
    }

    @Transactional
    public void delete(Long id) {
        if (id == null) {
            throw new IllegalArgumentException("缺少记录 id");
        }
        adjustmentMapper.deleteById(id);
    }

    private String sourceKey(Integer year, LocalDate flowDate) {
        return year + "|" + flowDate;
    }

    private Long longValue(Object value) {
        if (value == null || value.toString().trim().isEmpty()) return null;
        return Long.valueOf(value.toString().trim());
    }

    private Integer intValue(Object value) {
        if (value == null || value.toString().trim().isEmpty()) return null;
        return Integer.valueOf(value.toString().trim());
    }

    private BigDecimal decimalValue(Object value) {
        if (value == null || value.toString().trim().isEmpty()) return null;
        return HolidayNumberUtils.decimalValue(value);
    }

    private LocalDate dateValue(Object value) {
        if (value == null || value.toString().trim().isEmpty()) return null;
        return LocalDate.parse(value.toString().trim());
    }

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