package com.ruoyi.other.service.impl;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson2.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.common.core.exception.ServiceException;
import com.ruoyi.common.core.utils.StringUtils;
import com.ruoyi.common.core.web.page.PageInfo;
import com.ruoyi.other.api.domain.TStationCollect;
import com.ruoyi.other.api.domain.TStationInfo;
import com.ruoyi.other.mapper.TStationCollectMapper;
import com.ruoyi.other.mapper.TStationInfoMapper;
import com.ruoyi.other.query.StationCollectQuery;
import com.ruoyi.other.service.TStationCollectService;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * 电站逆变器服务实现。
 */
@Service
public class TStationCollectServiceImpl
        extends ServiceImpl<TStationCollectMapper, TStationCollect>
        implements TStationCollectService {

    @Resource
    private TStationInfoMapper stationInfoMapper;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean addStationCollect(TStationCollect stationCollect) {
        validate(stationCollect);
        stationCollect.setCollectId("1"+System.currentTimeMillis());
        stationCollect.setDataSource(1);
        fillDefaults(stationCollect);
        stationCollect.setId(null);
        stationCollect.setCreateTime(LocalDateTime.now());
        stationCollect.setUpdateTime(LocalDateTime.now());
        return save(stationCollect);
    }

    @Override
    public PageInfo<TStationCollect> pageList(StationCollectQuery query) {
        if (query == null) query = new StationCollectQuery();
        PageInfo<TStationCollect> page = new PageInfo<>(query.getPageCurr(), query.getPageSize());
        lambdaQuery()
                .eq(query.getPlatformId() != null, TStationCollect::getPlatformId, query.getPlatformId())
                .like(StringUtils.isNotBlank(query.getStationName()), TStationCollect::getStationName, query.getStationName())
                .like(StringUtils.isNotBlank(query.getCollectName()), TStationCollect::getCollectName, query.getCollectName())
                .like(StringUtils.isNotBlank(query.getDeviceModel()), TStationCollect::getDeviceModel, query.getDeviceModel())
                .like(StringUtils.isNotBlank(query.getInverterId()), TStationCollect::getInverterId, query.getInverterId())
                .eq(StringUtils.isNotBlank(query.getStatus()), TStationCollect::getStatus, query.getStatus())
                .in(StringUtils.isBlank(query.getStatus()) && Boolean.TRUE.equals(query.getAbnormalOnly()),
                        TStationCollect::getStatus, "2", "3")
                .orderByAsc(TStationCollect::getSortOrder).orderByDesc(TStationCollect::getCreateTime).page(page);
        fillStationAddress(page.getRecords());
        return page;
    }

    @Override
    public TStationCollect getStationCollectDetail(Long id) {
        if (id == null) {
            return null;
        }
        TStationCollect stationCollect = getById(id);
        if (stationCollect != null) {
            List<TStationCollect> stationCollectList = new ArrayList<>(1);
            stationCollectList.add(stationCollect);
            fillStationAddress(stationCollectList);
        }
        return stationCollect;
    }

    private void fillStationAddress(List<TStationCollect> stationCollectList) {
        if (stationCollectList == null || stationCollectList.isEmpty()) {
            return;
        }
        Set<String> stationIds = stationCollectList.stream()
                .map(TStationCollect::getStationId)
                .filter(StringUtils::isNotBlank)
                .collect(Collectors.toSet());
        if (stationIds.isEmpty()) {
            return;
        }

        List<TStationInfo> stationInfoList = stationInfoMapper.selectList(
                new LambdaQueryWrapper<TStationInfo>()
                        .select(TStationInfo::getStationId,
                                TStationInfo::getProvinceName,
                                TStationInfo::getCityName,
                                TStationInfo::getAreaName,
                                TStationInfo::getAddress)
                        .in(TStationInfo::getStationId, stationIds));
        Map<String, TStationInfo> stationInfoMap = stationInfoList.stream()
                .filter(item -> StringUtils.isNotBlank(item.getStationId()))
                .collect(Collectors.toMap(TStationInfo::getStationId,
                        Function.identity(), (first, ignored) -> first));

        for (TStationCollect stationCollect : stationCollectList) {
            TStationInfo stationInfo = stationInfoMap.get(stationCollect.getStationId());
            if (stationInfo != null) {
                stationCollect.setProvinceName(stationInfo.getProvinceName());
                stationCollect.setCityName(stationInfo.getCityName());
                stationCollect.setAreaName(stationInfo.getAreaName());
                stationCollect.setAddress(stationInfo.getAddress());
            }
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean updateStationCollect(TStationCollect stationCollect) {
        if (stationCollect == null || stationCollect.getId() == null) {
            throw new ServiceException("逆变器记录ID不能为空");
        }
        if (getById(stationCollect.getId()) == null) {
            throw new ServiceException("逆变器记录不存在");
        }
        validate(stationCollect);
        if (lambdaQuery().eq(TStationCollect::getCollectId, stationCollect.getCollectId())
                .ne(TStationCollect::getId, stationCollect.getId()).count() > 0) {
            throw new ServiceException("逆变器ID已存在");
        }
        stationCollect.setCreateBy(null);
        stationCollect.setCreateTime(null);
        stationCollect.setDelFlag(null);
        stationCollect.setUpdateTime(LocalDateTime.now());
        return updateById(stationCollect);
    }

    /**
     * 将第三方逆变器基础数据转换为实体并批量保存。
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean saveCollectBaseList(JSONArray collectBaseList) {
        if (collectBaseList == null || collectBaseList.isEmpty()) {
            return false;
        }

        Set<String> existingKeys = getExistingCollectKeys(); // 数据库中存在的所有逆变器ID
        List<TStationCollect> stationCollectList = new ArrayList<>(collectBaseList.size());
        for (Object item : collectBaseList) {
            JSONObject jsonObject = JSONObject.parseObject(item.toString());
            TStationCollect stationCollect = buildStationCollect(jsonObject);
            if (existingKeys.contains(stationCollect.getCollectId())) {
                continue;
            }
            stationCollectList.add(stationCollect);
        }
        return !stationCollectList.isEmpty() && saveBatch(stationCollectList);
    }

    private TStationCollect buildStationCollect(JSONObject jsonObject) {
        String stationId = jsonObject.getString("stationId");
        String stationName = jsonObject.getString("stationName");
        String collectName = jsonObject.getString("collectName");
        TStationCollect stationCollect = new TStationCollect();
        stationCollect.setPlatformId(0L);
        stationCollect.setStationId(stationId);
        stationCollect.setStationName(stationName);
        stationCollect.setCollectId(jsonObject.getString("collectId"));
        stationCollect.setCollectName(collectName);
        stationCollect.setDeviceModel(jsonObject.getString("deviceModel"));
        stationCollect.setInverterId(jsonObject.getString("inverterId"));
        stationCollect.setInstalledCapacity(jsonObject.getString("capacity"));
        stationCollect.setPowerNum(parsePowerNum(jsonObject.getString("powerNum")));
        stationCollect.setProvinceName(jsonObject.getString("province"));
        stationCollect.setCityName(jsonObject.getString("city"));
        stationCollect.setAreaName(jsonObject.getString("district"));
        stationCollect.setAddress(jsonObject.getString("address"));
        stationCollect.setLatitude(jsonObject.getString("lat"));
        stationCollect.setLongitude(jsonObject.getString("lon"));
        stationCollect.setDataSource(2);
        stationCollect.setSyncTime(LocalDateTime.now());
        stationCollect.setCreateTime(parseDateTime(jsonObject.getString("saveTime")));
        stationCollect.setUpdateTime(LocalDateTime.now());
        fillDefaults(stationCollect);
        return stationCollect;
    }

    private Set<String> getExistingCollectKeys() {
        List<TStationCollect> existingList = lambdaQuery().select(TStationCollect::getCollectId).list();
        Set<String> existingKeys = new HashSet<>();
        for (TStationCollect stationCollect : existingList) {
            existingKeys.add(stationCollect.getCollectId());
        }
        return existingKeys;
    }


    private void validate(TStationCollect stationCollect) {
        if (stationCollect == null) {
            throw new ServiceException("电站逆变器参数不能为空");
        }
        if (stationCollect.getStationId() == null) {
            throw new ServiceException("电站ID不能为空");
        }
        if (StringUtils.isBlank(stationCollect.getStationName())) {
            throw new ServiceException("电站名称不能为空");
        }
        if (StringUtils.isBlank(stationCollect.getCollectName())) {
            throw new ServiceException("逆变器名称不能为空");
        }
    }

    private void fillDefaults(TStationCollect stationCollect) {
        stationCollect.setPlatformId(stationCollect.getPlatformId() == null ? 0L : stationCollect.getPlatformId());
        stationCollect.setPowerNum(stationCollect.getPowerNum() == null ? 0 : stationCollect.getPowerNum());
        stationCollect.setStatus(StringUtils.isBlank(stationCollect.getStatus()) ? "0" : stationCollect.getStatus());
        stationCollect.setSortOrder(stationCollect.getSortOrder() == null ? 0 : stationCollect.getSortOrder());
        stationCollect.setCreateBy(StringUtils.defaultString(stationCollect.getCreateBy()));
        stationCollect.setUpdateBy(StringUtils.defaultString(stationCollect.getUpdateBy()));
        stationCollect.setDelFlag("0");
    }

    private Long parseLong(String value) {
        if (StringUtils.isBlank(value)) {
            return null;
        }
        try {
            return Long.valueOf(value);
        } catch (NumberFormatException exception) {
            return null;
        }
    }

    private BigDecimal parseBigDecimal(String value) {
        if (StringUtils.isBlank(value)) {
            return BigDecimal.ZERO;
        }
        try {
            return new BigDecimal(value);
        } catch (NumberFormatException exception) {
            return BigDecimal.ZERO;
        }
    }

    private Integer parsePowerNum(String value) {
        if (StringUtils.isBlank(value)) {
            return 0;
        }
        String number = value.replaceAll("[^0-9.]", "");
        if (StringUtils.isBlank(number)) {
            return 0;
        }
        try {
            return new BigDecimal(number).intValue();
        } catch (NumberFormatException exception) {
            return 0;
        }
    }

    private Integer parseInteger(String value) {
        if (StringUtils.isBlank(value)) {
            return 0;
        }
        try {
            return Integer.valueOf(value);
        } catch (NumberFormatException exception) {
            return parsePowerNum(value);
        }
    }

    private LocalDateTime parseDateTime(String value) {
        if (StringUtils.isBlank(value)) {
            return null;
        }
        try {
            return LocalDateTime.parse(value, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        } catch (DateTimeParseException exception) {
            return null;
        }
    }

    private String firstNotBlank(String preferred, String fallback) {
        return StringUtils.isNotBlank(preferred) ? preferred : fallback;
    }


    /**
     * 根据ids删除数据时，校验示范存在第三方同步的数据，第三方同步的数据不允许删除
     * @param ids 数据id
     * @return true可以删除，false不可以删除
     */
    public Boolean validateDelete(Long[] ids) {
        if(ids != null && ids.length > 0) {
            List<Long> idList = Arrays.stream(ids).collect(Collectors.toList());
            List<TStationCollect> infoList = lambdaQuery().eq(TStationCollect::getDataSource, 2).in(TStationCollect::getId, idList).list();
            if(CollectionUtils.isNotEmpty(infoList) && !infoList.isEmpty()) {
                return false;
            }
        }
        return true;
    }

    /**
     * 将华为 FusionSolar 设备列表转换为逆变器记录并批量保存。
     * devDn 作为设备唯一标识（接口未提供时使用 esnCode）。
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean saveCollectHuaWeiList(JSONArray devList) {
        if (devList == null || devList.isEmpty()) {
            return false;
        }
        Set<String> existingKeys = getExistingCollectKeys();
        Set<String> pendingKeys = new HashSet<>();
        List<TStationCollect> insertList = new ArrayList<>(devList.size());
        for (Object item : devList) {
            if (item == null) {
                continue;
            }
            JSONObject json = JSONObject.parseObject(item.toString());
            String collectId = firstNotBlank(json.getString("devDn"), json.getString("esnCode"));
            String stationId = json.getString("stationCode");
            Integer devTypeId = json.getInteger("devTypeId");
            if (StringUtils.isBlank(collectId) || StringUtils.isBlank(stationId)
                    || existingKeys.contains(collectId) || !pendingKeys.add(collectId) || devTypeId != 1) {
                continue;
            }
            TStationCollect collect = new TStationCollect();
            collect.setPlatformId(1L);
            collect.setStationId(stationId);
            collect.setStationName(firstNotBlank(json.getString("stationName"), ""));
            collect.setCollectId(collectId);
            collect.setCollectName(firstNotBlank(json.getString("devName"), collectId));
            collect.setDeviceModel(firstNotBlank(json.getString("invType"), json.getString("model")));
            collect.setInverterId(json.getString("esnCode"));
            collect.setInstalledCapacity(firstNotBlank(json.getString("capacity"), "0"));
            collect.setPowerNum(parseInteger(json.getString("optimizerNumber")));
            collect.setLatitude(json.getString("latitude"));
            collect.setLongitude(json.getString("longitude"));
            collect.setStatus("1");
            collect.setDataSource(2);
            collect.setSyncTime(LocalDateTime.now());
            collect.setCreateTime(LocalDateTime.now());
            collect.setUpdateTime(LocalDateTime.now());
            fillDefaults(collect);
            insertList.add(collect);
        }
        // 设置电站名称
        List<TStationInfo> infoList = stationInfoMapper.selectList(new LambdaQueryWrapper<>());
        insertList.forEach(s -> infoList.forEach(info -> {
            if(StringUtils.isNotEmpty(s.getStationId()) && s.getStationId().equals(info.getStationId())) {
                s.setStationName(info.getStationName());
            }
        }));
        return CollectionUtils.isNotEmpty(insertList) && saveBatch(insertList);
    }
}