package com.iot.scheduler.service;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.Consts;
import org.apache.http.HttpEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.util.UriComponentsBuilder;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.TimeUnit;

@Slf4j
@Service
public class EnergyPullService {

    @Value("${energy.token.url}")
    private String energyTokenUrl;
    @Value("${energy.deviceList.url}")
    private String energyDeviceListUrl;
    @Value("${energy.detail.url}")
    private String energyDetailUrl;
    @Value("${energy.runStatus.url}")
    private String energyRunStatusUrl;

    @Resource
    private RedisTemplate<String, String> redisTemplate;
    @Resource
    private JdbcTemplate jdbcTemplate;
    @Resource
    private CorpConfigService corpConfigService;

    /**
     * 定时任务：同步能耗设备数据（遍历所有已配置公司）
     */
    @Scheduled(cron = "${scheduler.energy.cron:0 0/5 * * ?}")
    public void pullEnergyDeviceAndSave() {
        List<String> corpCodes = corpConfigService.getAllCorpCodes();
        if (corpCodes.isEmpty()) {
            log.warn("[Scheduled] energy: no corp config found, skip");
            return;
        }
        for (String corpCode : corpCodes) {
            pullEnergyDeviceAndSave(corpCode);
        }
    }

    public void pullEnergyDeviceAndSave(String corpCode) {
        if (!corpConfigService.hasValidIotCredentials(corpCode)) {
            log.warn("【能耗数据同步】IoT凭证为空, 跳过同步, corpCode={}", corpCode);
            return;
        }
        log.info("【能耗数据同步】开始同步能耗设备数据, corpCode={}", corpCode);
        try {
            String energyResult = getEnergyDeviceList(corpCode);
            if (StringUtils.isBlank(energyResult)) {
                log.error("【能耗数据同步】获取能耗设备列表失败");
                return;
            }

            Map<String, Object> energyInfos = JSON.parseObject(energyResult, new TypeReference<>() {
            });
            Integer code = (Integer) energyInfos.get("code");
            if (code == null || code != 200) {
                log.error("【能耗数据同步】获取能耗设备列表返回code不为200, code:{}, response:{}", code, energyResult);
                return;
            }

            JSONArray dataList = (JSONArray) energyInfos.get("data");
            if (CollectionUtils.isEmpty(dataList)) {
                log.warn("【能耗数据同步】能耗设备列表为空");
                return;
            }

            int successCount = 0;
            for (Object o : dataList) {
                JSONObject deviceJson = (JSONObject) o;
                String projectState = deviceJson.getString("projectState");
                String projectType = deviceJson.getString("projectType");
                String deviceName = deviceJson.getString("deviceName");
                String dtuId = deviceJson.getString("dtuId");
                String deviceId = deviceJson.getString("deviceId");
                String dtuSn = deviceJson.getString("dtuSn");
                log.info("【能耗数据处理】corpCode:{}, deviceName:{}, dtuSn:{}, projectState:{}, projectType:{}",
                        corpCode, deviceName, dtuSn, projectState, projectType);

                String todayEvalue = getTodayEnergyValue(corpCode, dtuSn);
                Map<String, String> runStatusMap = getEnergyRunStatus(corpCode, dtuSn);
                String duration = runStatusMap.get("duration");
                String runStatus = runStatusMap.get("runStatus");

                saveOrUpdateEnergyDevice(corpCode, projectState, projectType, deviceName, dtuId, deviceId, dtuSn,
                        todayEvalue, duration, runStatus);
                successCount++;
            }
            log.info("【能耗数据同步】同步完成，共处理 {} 条设备数据", successCount);
        } catch (Exception e) {
            log.error("【能耗数据同步】同步过程发生异常", e);
        }
    }

    public String getEnergyDeviceList(String corpCode) {
        String accessToken = getEnergyAccessToken(corpCode);
        Map<String, String> headerMap = new HashMap<>(1);
        headerMap.put("Authorization", "Bearer " + accessToken);
        Map<String, String> paramsMap = new HashMap<>();
        paramsMap.put("groupName", corpConfigService.getIotOrg(corpCode));
        String result = sendRequestGet(energyDeviceListUrl, paramsMap, headerMap);
        if (StringUtils.isBlank(result)) return null;

        Map<String, Object> resultMap = JSON.parseObject(result, new TypeReference<>() {
        });
        Integer resultCode = (Integer) resultMap.get("code");

        if (resultCode == null || resultCode != 200) {
            log.warn("【能耗设备列表】第一次请求失败，重新获取Token重试");
            accessToken = getEnergyAccessToken(corpCode);
            if (StringUtils.isEmpty(accessToken)) return null;
            headerMap.put("Authorization", "Bearer " + accessToken);
            result = sendRequestGet(energyDeviceListUrl, paramsMap, headerMap);
            if (StringUtils.isBlank(result)) return null;
            resultMap = JSON.parseObject(result, new TypeReference<>() {
            });
            resultCode = (Integer) resultMap.get("code");
            if (resultCode == null || resultCode != 200) {
                log.error("【能耗设备列表】重试后仍然失败, code:{}", resultCode);
                return null;
            }
        }
        return result;
    }

    private String getEnergyAccessToken(String corpCode) {
        String redisKey = "hnyssl_energy_token_" + corpCode;
        String cachedToken = redisTemplate.opsForValue().get(redisKey);
        if (StringUtils.isNotBlank(cachedToken) && redisTemplate.getExpire(redisKey) > 0) return cachedToken;

        // 使用公司配置中的用户名密码
        String userName = corpConfigService.getIotUsername(corpCode);
        String password = corpConfigService.getIotPassword(corpCode);
        Map<String, String> param = new HashMap<>(2);
        param.put("username", userName);
        param.put("password", password);

        HttpPost httpPost = new HttpPost(energyTokenUrl);
        String result = sendPost(httpPost, JSON.toJSONString(param));
        if (StringUtils.isBlank(result)) {
            log.error("【能耗Token】请求Token失败，响应为空");
            return "";
        }

        Map<String, Object> res = JSON.parseObject(result, new TypeReference<>() {
        });
        Integer code = (Integer) res.get("code");
        if (code == null || code != 200) {
            log.error("【能耗Token】请求Token返回异常, code:{}", code);
            return "";
        }

        JSONObject data = (JSONObject) res.get("data");
        String token = data.getString("token");
        if (StringUtils.isBlank(token)) {
            log.error("【能耗Token】响应中没有token");
            return "";
        }

        redisTemplate.opsForValue().set(redisKey, token, 3600, TimeUnit.SECONDS);
        log.info("【能耗Token】获取Token成功并缓存, corpCode={}", corpCode);
        return token;
    }

    private void saveOrUpdateEnergyDevice(String corpCode, String projectState, String projectType, String deviceName,
                                          String dtuId, String deviceId, String dtuSn,
                                          String evalue, String duration, String runStatus) {
        String energyTableName = corpConfigService.getEnergyTableName(corpCode);
        JdbcTemplate jt = corpConfigService.getJdbcTemplate(corpCode);

        List<Map<String, Object>> existList = jt.queryForList(
                "SELECT id FROM " + energyTableName + " WHERE corp_code = ? AND dtuSn = ?", corpCode, dtuSn);
        Date now = new Date();
        if (!existList.isEmpty()) {
            jt.update("UPDATE " + energyTableName +
                            " SET projectState = ?, projectType = ?, deviceName = ?, dtuId = ?, deviceId = ?, evalue = ?, duration = ?, runStatus = ?, updated_at = ?" +
                            " WHERE corp_code = ? AND dtuSn = ?",
                    projectState, projectType, deviceName, dtuId, deviceId, evalue, duration, runStatus, now, corpCode, dtuSn);
        } else {
            String id = UUID.randomUUID().toString().replace("-", "");
            jt.update("INSERT INTO " + energyTableName +
                            " (id, corp_code, created_at, created_by, updated_at, updated_by, deviceName, projectType, projectState, dtuSn, dtuId, deviceId, evalue, duration, runStatus)" +
                            " VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
                    id, corpCode, now, "system", now, "system",
                    deviceName, projectType, projectState, dtuSn, dtuId, deviceId, evalue, duration, runStatus);
        }
    }

    private Map<String, String> getEnergyRunStatus(String corpCode, String dtuSn) {
        Map<String, String> result = new HashMap<>();
        result.put("duration", null);
        result.put("runStatus", null);
        try {
            String accessToken = getEnergyAccessToken(corpCode);
            Map<String, String> headerMap = new HashMap<>(1);
            headerMap.put("Authorization", "Bearer " + accessToken);
            Map<String, String> paramsMap = new HashMap<>();
            paramsMap.put("dtuSn", dtuSn);
            paramsMap.put("date", new SimpleDateFormat("yyyy-MM-dd").format(new Date()));
            String response = sendRequestGet(energyRunStatusUrl, paramsMap, headerMap);
            if (StringUtils.isBlank(response)) return result;
            Map<String, Object> resultMap = JSON.parseObject(response, new TypeReference<>() {
            });
            Integer resultCode = (Integer) resultMap.get("code");
            if (resultCode == null || resultCode != 200) {
                accessToken = getEnergyAccessToken(corpCode);
                if (StringUtils.isEmpty(accessToken)) return result;
                headerMap.put("Authorization", "Bearer " + accessToken);
                response = sendRequestGet(energyRunStatusUrl, paramsMap, headerMap);
                if (StringUtils.isBlank(response)) return result;
                resultMap = JSON.parseObject(response, new TypeReference<>() {
                });
                resultCode = (Integer) resultMap.get("code");
                if (resultCode == null || resultCode != 200) return result;
            }
            JSONArray dataList = (JSONArray) resultMap.get("data");
            String description = dataList != null ? dataList.toJSONString() : "[]";
            saveOrUpdateERunDtl(corpCode, dtuSn, description, new SimpleDateFormat("yyyy-MM-dd 00:00:00").format(new Date()));

            if (!CollectionUtils.isEmpty(dataList)) {
                JSONObject lastItem = (JSONObject) dataList.get(dataList.size() - 1);
                Long durVal = lastItem.getLong("duration");
                Integer statusVal = lastItem.getInteger("runStatus");
                result.put("duration", durVal != null ? String.valueOf(durVal) : null);
                result.put("runStatus", statusVal != null ? String.valueOf(statusVal) : null);
            }
        } catch (Exception e) {
            log.error("【能耗OEE】获取异常 - corpCode:{}, dtuSn:{}", corpCode, dtuSn, e);
        }
        return result;
    }

    private void saveOrUpdateERunDtl(String corpCode, String dtuSn, String description, String useDate) {
        String eRunDtlTableName = corpConfigService.getERunDtlTableName(corpCode);
        JdbcTemplate jt = corpConfigService.getJdbcTemplate(corpCode);
        int maxLen = 60000;
        String rs1 = "";
        String rs2 = "";
        if (description.length() > maxLen) {
            rs1 = description.substring(0, maxLen);
            rs2 = description.substring(maxLen);
        } else {
            rs1 = description;
        }

        List<Map<String, Object>> existList = jt.queryForList(
                "SELECT id FROM " + eRunDtlTableName + " WHERE corp_code = ? AND dtuSn = ? AND use_date = ?", corpCode, dtuSn, useDate);
        Date now = new Date();
        if (!existList.isEmpty()) {
            jt.update("UPDATE " + eRunDtlTableName + " SET runStatus1=?, runStatus2=?, updated_at=? WHERE corp_code=? AND dtuSn=? AND use_date=?", rs1, rs2, now, corpCode, dtuSn, useDate);
        } else {
            String id = UUID.randomUUID().toString().replace("-", "");
            jt.update("INSERT INTO " + eRunDtlTableName + " (id,corp_code,created_at,created_by,updated_at,updated_by,dtuSn,use_date,runStatus1,runStatus2)" +
                    " VALUES (?,?,?,?,?,?,?,?,?,?)", id, corpCode, now, "system", now, "system", dtuSn, useDate, rs1, rs2);
        }
    }

    // ==================== 能耗历史数据全量/增量同步 ====================

    public void pullEnergyHistoryAndSave(String corpCode) {
        if (!corpConfigService.hasValidIotCredentials(corpCode)) {
            log.warn("【能耗历史-全量】IoT凭证为空, 跳过同步, corpCode={}", corpCode);
            return;
        }
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.DAY_OF_MONTH, -1);
        String endDate = sdf.format(cal.getTime());
        cal.set(cal.get(Calendar.YEAR), Calendar.JANUARY, 1);
        String startDate = sdf.format(cal.getTime());
        log.info("【能耗历史-全量】开始同步, corpCode:{}, 日期范围: {} ~ {}", corpCode, startDate, endDate);
        doSyncEnergyHistory(corpCode, startDate, endDate);
    }

    private void doSyncEnergyHistory(String corpCode, String startDate, String endDate) {
        String energyResult = getEnergyDeviceList(corpCode);
        if (StringUtils.isBlank(energyResult)) {
            log.error("【能耗历史】获取设备列表失败");
            return;
        }

        Map<String, Object> energyInfos = JSON.parseObject(energyResult, new TypeReference<>() {
        });
        Integer code = (Integer) energyInfos.get("code");
        if (code == null || code != 200) {
            log.error("【能耗历史】获取设备列表返回code异常, code:{}", code);
            return;
        }

        JSONArray deviceList = (JSONArray) energyInfos.get("data");
        if (CollectionUtils.isEmpty(deviceList)) {
            log.warn("【能耗历史】设备列表为空");
            return;
        }

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        List<String> dateList = new ArrayList<>();
        try {
            Date start = sdf.parse(startDate);
            Date end = sdf.parse(endDate);
            Calendar cur = Calendar.getInstance();
            cur.setTime(start);
            while (!cur.getTime().after(end)) {
                dateList.add(sdf.format(cur.getTime()));
                cur.add(Calendar.DAY_OF_MONTH, 1);
            }
        } catch (Exception e) {
            log.error("【能耗历史】日期解析失败: {} ~ {}", startDate, endDate, e);
            return;
        }

        log.info("【能耗历史】开始同步, corpCode:{}, 设备数:{}, 天数:{}, 总计{}条记录待处理", corpCode, deviceList.size(), dateList.size(), deviceList.size() * dateList.size());
        int totalSaved = 0;
        for (Object o : deviceList) {
            JSONObject deviceJson = (JSONObject) o;
            String dtuSn = deviceJson.getString("dtuSn");
            for (String dateStr : dateList) {
                try {
                    syncEnergyValueForDate(corpCode, dtuSn, dateStr);
                    syncRunStatusForDate(corpCode, dtuSn, dateStr);
                    totalSaved++;
                } catch (Exception e) {
                    log.error("【能耗历史】处理异常 - corpCode:{}, dtuSn:{}, date:{}", corpCode, dtuSn, dateStr, e);
                }
            }
        }
        log.info("【能耗历史】同步完成，共保存 {} 条记录", totalSaved);
    }

    private void syncEnergyValueForDate(String corpCode, String dtuSn, String dateStr) {
        String accessToken = getEnergyAccessToken(corpCode);
        Map<String, String> headerMap = new HashMap<>(1);
        headerMap.put("Authorization", "Bearer " + accessToken);
        Map<String, String> paramsMap = new HashMap<>();
        paramsMap.put("dtuSn", dtuSn);
        paramsMap.put("startDate", dateStr);
        paramsMap.put("type", "0");
        String result = sendRequestGet(energyDetailUrl, paramsMap, headerMap);
        if (StringUtils.isBlank(result)) return;
        Map<String, Object> resultMap = JSON.parseObject(result, new TypeReference<>() {
        });
        Integer resultCode = (Integer) resultMap.get("code");
        if (resultCode == null || resultCode != 200) {
            accessToken = getEnergyAccessToken(corpCode);
            if (StringUtils.isEmpty(accessToken)) return;
            headerMap.put("Authorization", "Bearer " + accessToken);
            result = sendRequestGet(energyDetailUrl, paramsMap, headerMap);
            if (StringUtils.isBlank(result)) return;
            resultMap = JSON.parseObject(result, new TypeReference<>() {
            });
            resultCode = (Integer) resultMap.get("code");
            if (resultCode == null || resultCode != 200) return;
        }
        JSONArray dataList = (JSONArray) resultMap.get("data");
        String description = dataList != null ? dataList.toJSONString() : "[]";
        saveOrUpdateEqKwh(corpCode, dtuSn, description, dateStr + " 00:00:00");
    }

    private void syncRunStatusForDate(String corpCode, String dtuSn, String dateStr) {
        String accessToken = getEnergyAccessToken(corpCode);
        Map<String, String> headerMap = new HashMap<>(1);
        headerMap.put("Authorization", "Bearer " + accessToken);
        Map<String, String> paramsMap = new HashMap<>();
        paramsMap.put("dtuSn", dtuSn);
        paramsMap.put("date", dateStr);
        String response = sendRequestGet(energyRunStatusUrl, paramsMap, headerMap);
        if (StringUtils.isBlank(response)) return;
        Map<String, Object> resultMap = JSON.parseObject(response, new TypeReference<>() {
        });
        Integer resultCode = (Integer) resultMap.get("code");
        if (resultCode == null || resultCode != 200) {
            accessToken = getEnergyAccessToken(corpCode);
            if (StringUtils.isEmpty(accessToken)) return;
            headerMap.put("Authorization", "Bearer " + accessToken);
            response = sendRequestGet(energyRunStatusUrl, paramsMap, headerMap);
            if (StringUtils.isBlank(response)) return;
            resultMap = JSON.parseObject(response, new TypeReference<>() {
            });
            resultCode = (Integer) resultMap.get("code");
            if (resultCode == null || resultCode != 200) return;
        }
        JSONArray dataList = (JSONArray) resultMap.get("data");
        String description = dataList != null ? dataList.toJSONString() : "[]";
        saveOrUpdateERunDtl(corpCode, dtuSn, description, dateStr + " 00:00:00");
    }

    private String getTodayEnergyValue(String corpCode, String dtuSn) {
        try {
            String accessToken = getEnergyAccessToken(corpCode);
            Map<String, String> headerMap = new HashMap<>(1);
            headerMap.put("Authorization", "Bearer " + accessToken);
            Map<String, String> paramsMap = new HashMap<>();
            paramsMap.put("dtuSn", dtuSn);
            paramsMap.put("startDate", new SimpleDateFormat("yyyy-MM-dd").format(new Date()));
            paramsMap.put("type", "0");
            String result = sendRequestGet(energyDetailUrl, paramsMap, headerMap);
            if (StringUtils.isBlank(result)) return null;
            Map<String, Object> resultMap = JSON.parseObject(result, new TypeReference<>() {
            });
            Integer resultCode = (Integer) resultMap.get("code");
            if (resultCode == null || resultCode != 200) {
                accessToken = getEnergyAccessToken(corpCode);
                if (StringUtils.isEmpty(accessToken)) return null;
                headerMap.put("Authorization", "Bearer " + accessToken);
                result = sendRequestGet(energyDetailUrl, paramsMap, headerMap);
                if (StringUtils.isBlank(result)) return null;
                resultMap = JSON.parseObject(result, new TypeReference<>() {
                });
                resultCode = (Integer) resultMap.get("code");
                if (resultCode == null || resultCode != 200) return null;
            }
            JSONArray dataList = (JSONArray) resultMap.get("data");
            String description = dataList != null ? dataList.toJSONString() : "[]";
            saveOrUpdateEqKwh(corpCode, dtuSn, description, new SimpleDateFormat("yyyy-MM-dd 00:00:00").format(new Date()));
            double totalValue = 0;
            if (!CollectionUtils.isEmpty(dataList)) {
                for (Object o : dataList) {
                    JSONObject item = (JSONObject) o;
                    totalValue += item.getDoubleValue("value");
                }
            }
            String evalueStr = String.valueOf(totalValue);
            log.info("【能耗用电量】corpCode:{}, dtuSn:{}, 今日用电量:{}", corpCode, dtuSn, evalueStr);
            return evalueStr;
        } catch (Exception e) {
            log.error("【能耗用电量】获取异常 - corpCode:{}, dtuSn:{}", corpCode, dtuSn, e);
            return null;
        }
    }

    private void saveOrUpdateEqKwh(String corpCode, String dtuSn, String description, String useDate) {
        String eqKwhTableName = corpConfigService.getEqKwhTableName(corpCode);
        JdbcTemplate jt = corpConfigService.getJdbcTemplate(corpCode);
        List<Map<String, Object>> existList = jt.queryForList(
                "SELECT id FROM " + eqKwhTableName + " WHERE corp_code = ? AND dtuSn = ? AND use_date = ?", corpCode, dtuSn, useDate);
        Date now = new Date();
        if (!existList.isEmpty()) {
            jt.update("UPDATE " + eqKwhTableName + " SET description = ?, updated_at = ? WHERE corp_code = ? AND dtuSn = ? AND use_date = ?", description, now, corpCode, dtuSn, useDate);
        } else {
            String id = UUID.randomUUID().toString().replace("-", "");
            jt.update("INSERT INTO " + eqKwhTableName + " (id, corp_code, created_at, created_by, updated_at, updated_by, dtuSn, use_date, description)" +
                    " VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)", id, corpCode, now, "system", now, "system", dtuSn, useDate, description);
        }
    }

    public static String sendRequestGet(String url, Map<String, String> params, Map<String, String> header) {
        CloseableHttpClient httpclient = HttpClients.createDefault();
        url = builderUrl(url, params);
        String content = "";
        HttpGet httpget = new HttpGet(url);
        if (!CollectionUtils.isEmpty(header)) {
            for (Map.Entry<String, String> entry : header.entrySet())
                httpget.setHeader(entry.getKey(), entry.getValue());
        }
        try (CloseableHttpResponse response = httpclient.execute(httpget)) {
            if (response.getStatusLine().getStatusCode() == 200)
                content = EntityUtils.toString(response.getEntity(), "UTF-8");
        } catch (IOException e) {
            log.error("sendRequest---GET Error!", e);
        }
        return content;
    }

    private static String builderUrl(String url, Map<String, String> params) {
        UriComponentsBuilder uriBuilder = UriComponentsBuilder.fromHttpUrl(url);
        if (!CollectionUtils.isEmpty(params)) {
            MultiValueMap<String, String> paramsValue = new LinkedMultiValueMap<>();
            for (Map.Entry<String, String> entry : params.entrySet()) paramsValue.add(entry.getKey(), entry.getValue());
            uriBuilder = uriBuilder.queryParams(paramsValue);
        }
        return uriBuilder.toUriString();
    }

    private String sendPost(HttpPost httpPost, String jsonData) {
        CloseableHttpClient httpClient = HttpClients.createDefault();
        StringEntity entity = new StringEntity(jsonData, ContentType.create("application/json", Consts.UTF_8));
        httpPost.setEntity(entity);
        String result = null;
        try {
            CloseableHttpResponse execute = httpClient.execute(httpPost);
            HttpEntity res = execute.getEntity();
            InputStream is = res.getContent();
            int len;
            byte[] buf = new byte[128];
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            while ((len = is.read(buf)) != -1) byteArrayOutputStream.write(buf, 0, len);
            result = byteArrayOutputStream.toString();
        } catch (IOException e) {
            log.error("sendPost error!", e);
        }
        return result;
    }
}