package com.dderp.business.service;

import com.dderp.business.dao.StoreDao;
import com.dderp.common.api.NoSqlKeysService;
import com.dderp.common.api.SortBuilderExecutor;
import com.dderp.common.api.StoreService;
import com.dderp.common.base.BaseService;
import com.dderp.common.datas.ERPModule;
import com.dderp.common.datas.ESKeys;
import com.dderp.common.entity.base.ProcessIdItem;
import com.dderp.common.entity.base.ProcessStringItem;
import com.dderp.common.entity.base.ScriptStringResult;
import com.dderp.common.entity.site.ERPTokenUser;
import com.dderp.common.entity.store.*;
import com.dderp.common.tool.ERPUtils;
import com.dySweetFishPlugin.elasticsearch.ESClient;
import com.dySweetFishPlugin.sql.TableIdService;
import com.dySweetFishPlugin.sql.dao.TunaService;
import com.dySweetFishPlugin.tool.crypto.EncryptUtil;
import com.sweetfish.convert.json.JsonConvert;
import com.sweetfish.service.Local;
import com.sweetfish.service.RetResult;
import com.sweetfish.source.PageFlipper;
import com.sweetfish.util.AnyValue;
import com.sweetfish.util.AutoLoad;
import com.sweetfish.util.ResourceType;
import org.apache.commons.lang3.StringUtils;
import org.elasticsearch.action.DocWriteResponse;
import org.elasticsearch.action.bulk.BulkRequestBuilder;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.support.WriteRequest;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.Operator;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.reindex.DeleteByQueryAction;
import org.elasticsearch.search.sort.SortBuilders;
import org.elasticsearch.search.sort.SortOrder;
import org.rex.RMap;

import javax.annotation.Resource;
import java.io.IOException;
import java.util.*;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;

import static org.elasticsearch.common.xcontent.XContentFactory.jsonBuilder;

@AutoLoad(value = false)
@Local
@ResourceType(StoreService.class)
public class StoreServiceImpl extends BaseService implements StoreService {
    @Resource
    private ESClient esClient;

    @Resource
    private JsonConvert jsonConvert;

    @Resource
    private NoSqlKeysService keysService;

    @Resource
    private TableIdService tableIdService;

    @Resource
    private TunaService tunaService;

    private StoreDao storeDao;

    @Resource(name = "property.passwordSalt")
    private String passwordSalt;

    @Override
    public void start(AnyValue config) {
        super.start(config);
        storeDao = tunaService.generate(StoreDao.class);
    }

    //region 门店品牌档案
    @Override
    public List<StoreBrand> queryStoreBrandList(RMap params, PageFlipper pageFlipper, long supplierCode) {
        return searchESList(esClient, jsonConvert,
                StoreBrand.class,
                params,
                ((sd) -> {
                    BoolQueryBuilder qb = QueryBuilders.boolQuery();
                    qb = qb.must(QueryBuilders.typeQuery(ESKeys.ES_DELIVER_STORE_BRAND_TYPE));

                    if (ERPUtils.mapContainKey(params, "brandName")) {
                        String platformName = params.getString("brandName");
                        BoolQueryBuilder qbPlatformName = QueryBuilders.boolQuery()
                                .should(QueryBuilders.matchQuery("brandName", platformName).analyzer("query_ansj").operator(Operator.AND))
                                .should(QueryBuilders.termQuery("brandName.number", platformName.toLowerCase()))
                                .should(QueryBuilders.matchQuery("brandName.letter", platformName.toLowerCase()).operator(Operator.AND));
                        qb = qb.must(qbPlatformName);
                    }

                    if (ERPUtils.mapContainKey(params, "voidFlag")) {
                        qb = qb.must(QueryBuilders.termQuery("voidFlag", params.getInt("voidFlag")));
                    }

                    return qb;
                }),
                keysService.getESKey(ESKeys.ES_DELIVER_STORE_BRAND_INDEX, supplierCode),
                pageFlipper,
                (() -> SortBuilders.fieldSort("id").order(SortOrder.DESC)));
    }

    @Override
    public StoreBrand getStoreBrand(long id, long supplierCode) {
        return this.getESOneInfo(esClient, jsonConvert, StoreBrand.class,
                String.valueOf(id),
                keysService.getESKey(ESKeys.ES_DELIVER_STORE_BRAND_INDEX, supplierCode),
                ESKeys.ES_DELIVER_STORE_BRAND_TYPE,
                null);
    }

    @Override
    public RetResult<StoreBrand> addStoreBrand(StoreBrand storeBrand, ERPTokenUser currentUser, String dataSourceId, long supplierCode) {
        if (StringUtils.isBlank(storeBrand.getBrandName()))
            return RetResult.<StoreBrand>errorT().retinfo("门店品牌名称不可为空");

        //先查一下有没有重名的平台信息
        StoreBrand esInfo = this.getESOneInfo(esClient, jsonConvert,
                StoreBrand.class,
                (a) -> {
                    BoolQueryBuilder qb = QueryBuilders.boolQuery().must(QueryBuilders.typeQuery(ESKeys.ES_DELIVER_STORE_BRAND_TYPE));
                    qb.must(QueryBuilders.termQuery("brandName.raw", storeBrand.getBrandName()));

                    return qb;
                },
                keysService.getESKey(ESKeys.ES_DELIVER_STORE_BRAND_INDEX, supplierCode),
                null);

        if (esInfo != null) return RetResult.<StoreBrand>errorT().retinfo("已存在同名的门店品牌");

        storeBrand.setId(tableIdService.getTableIdMulti("tbStoreBrand.id", 1, dataSourceId, String.valueOf(supplierCode)));
        StoreBrand.create(storeBrand, currentUser.getId());

        IndexResponse itemResponse = esClient.getClient()
                .prepareIndex(keysService.getESKey(ESKeys.ES_DELIVER_STORE_BRAND_INDEX, supplierCode), ESKeys.ES_DELIVER_STORE_BRAND_TYPE)
                .setId(String.valueOf(storeBrand.getId()))
                .setSource(jsonConvert.convertTo(storeBrand), XContentType.JSON)
                .setRefreshPolicy(WriteRequest.RefreshPolicy.IMMEDIATE)
                .get();

        if (itemResponse.getResult() == DocWriteResponse.Result.CREATED) {
            storeDao.addStoreBrand(storeBrand, dataSourceId, supplierCode);
        } else {
            return RetResult.<StoreBrand>errorT().retinfo("创建门店品牌失败");
        }

        return RetResult.<StoreBrand>successT().result(storeBrand);
    }

    @Override
    public RetResult<StoreBrand> uploadBrandLogo(long idStoreBrand, String fileLink, ERPTokenUser currentUser, String dataSourceId, long supplierCode) {
        StoreBrand esInfo = this.getStoreBrand(idStoreBrand, supplierCode);
        if (esInfo == null)
            return RetResult.<StoreBrand>errorT().retinfo("未找到此门店品牌");

        esInfo.setBrandLogoUrl(fileLink);
        try {
            UpdateRequest updateRequest = new UpdateRequest(keysService.getESKey(ESKeys.ES_DELIVER_STORE_BRAND_INDEX, supplierCode),
                    ESKeys.ES_DELIVER_STORE_BRAND_TYPE, String.valueOf(esInfo.getId()))
                    .doc(jsonBuilder()
                            .startObject()
                            .field("brandLogoUrl", esInfo.getBrandLogoUrl())
                            .endObject())
                    .setRefreshPolicy(WriteRequest.RefreshPolicy.IMMEDIATE);

            esClient.getClient().update(updateRequest).get();
        } catch (IOException | InterruptedException | ExecutionException e) {
            logger.error("修改门店品牌[" + esInfo.getId() + "出错：" + e.getMessage(), e);
        }
        storeDao.updateBrandLogoUrl(esInfo, dataSourceId, supplierCode);
        return RetResult.successT();
    }

    @Override
    public RetResult<StoreBrand> updateStoreBrand(StoreBrand storeBrand, ERPTokenUser currentUser, String dataSourceId, long supplierCode) {
        if (StringUtils.isBlank(storeBrand.getBrandName()))
            return RetResult.<StoreBrand>errorT().retinfo("门店品牌名称不可为空");

        StoreBrand esInfo = this.getStoreBrand(storeBrand.getId(), supplierCode);
        if (esInfo == null)
            return RetResult.<StoreBrand>errorT().retinfo("未找到此门店品牌");

        //先查一下有没有重名的平台信息（防止修改名称改重）
        StoreBrand checkNameInfo = this.getESOneInfo(esClient, jsonConvert,
                StoreBrand.class,
                (a) -> {
                    BoolQueryBuilder qb = QueryBuilders.boolQuery().must(QueryBuilders.typeQuery(ESKeys.ES_DELIVER_STORE_BRAND_TYPE));
                    qb.must(QueryBuilders.termQuery("brandName.raw", storeBrand.getBrandName()))
                            .mustNot(QueryBuilders.idsQuery(String.valueOf(storeBrand.getId())));

                    return qb;
                },
                keysService.getESKey(ESKeys.ES_DELIVER_STORE_BRAND_INDEX, supplierCode),
                null);

        if (checkNameInfo != null) return RetResult.<StoreBrand>errorT().retinfo("已存在同名的门店品牌");

        esInfo.setBrandName(storeBrand.getBrandName());
        esInfo.setStartingPrice(storeBrand.getStartingPrice());
        esInfo.setPackagingFee(storeBrand.getPackagingFee());
        esInfo.setBrandMemo(storeBrand.getBrandMemo());
        StoreBrand.update(esInfo, currentUser.getId());
        try {
            UpdateRequest updateRequest = new UpdateRequest(keysService.getESKey(ESKeys.ES_DELIVER_STORE_BRAND_INDEX, supplierCode),
                    ESKeys.ES_DELIVER_STORE_BRAND_TYPE, String.valueOf(esInfo.getId()))
                    .doc(jsonBuilder()
                            .startObject()
                            .field("brandName", esInfo.getBrandName())
                            .field("startingPrice", esInfo.getStartingPrice())
                            .field("packagingFee", esInfo.getPackagingFee())
                            .field("brandMemo", esInfo.getBrandMemo())
                            .field("updateTimeLong", esInfo.getUpdateTimeLong())
                            .field("updateBy", esInfo.getUpdateBy())
                            .endObject())
                    .setRefreshPolicy(WriteRequest.RefreshPolicy.IMMEDIATE);

            esClient.getClient().update(updateRequest).get();
        } catch (IOException | InterruptedException | ExecutionException e) {
            logger.error("修改门店品牌[" + esInfo.getId() + "出错：" + e.getMessage(), e);
        }
        storeDao.updateStoreBrand(esInfo, dataSourceId, supplierCode);
        return RetResult.successT();
    }

    @Override
    public RetResult<StoreBrand> voidStoreBrand(StoreBrand storeBrand, ERPTokenUser currentUser, String dataSourceId, long supplierCode) {
        StoreBrand esInfo = this.getStoreBrand(storeBrand.getId(), supplierCode);
        if (esInfo == null) {
            return RetResult.<StoreBrand>errorT().retinfo("未找到此门店品牌");
        }
        esInfo.setVoidFlag(storeBrand.getVoidFlag());
        StoreBrand.update(esInfo, currentUser.getId());
        try {
            UpdateRequest updateRequest = new UpdateRequest(keysService.getESKey(ESKeys.ES_DELIVER_STORE_BRAND_INDEX, supplierCode),
                    ESKeys.ES_DELIVER_STORE_BRAND_TYPE, String.valueOf(esInfo.getId()))
                    .doc(jsonBuilder()
                            .startObject()
                            .field("voidFlag", esInfo.getVoidFlag())
                            .field("updateTimeLong", esInfo.getUpdateTimeLong())
                            .field("updateBy", esInfo.getUpdateBy())
                            .endObject())
                    .setRefreshPolicy(WriteRequest.RefreshPolicy.IMMEDIATE);

            esClient.getClient().update(updateRequest).get();
        } catch (IOException | InterruptedException | ExecutionException e) {
            logger.error("禁用或启用门店品牌[" + esInfo.getId() + "出错：" + e.getMessage(), e);
        }
        storeDao.voidStoreBrand(esInfo, dataSourceId, supplierCode);
        return RetResult.successT();
    }
    //endregion

    @Override
    public List<ViewStoreInfo> queryViewStoreInfo(RMap params, PageFlipper pageFlipper, long supplierCode) {
        Set<Long> idStores = new HashSet<>();
        List<StoreInfo> storeInfoList = searchESList(esClient, jsonConvert,
                StoreInfo.class,
                null,
                ((sd) -> {
                    BoolQueryBuilder qb = QueryBuilders.boolQuery();
                    qb = qb.must(QueryBuilders.typeQuery(ESKeys.ES_DELIVER_STORE_INFO_TYPE));

                    if (ERPUtils.mapContainKey(params, "storeName")) {
                        String storeName = params.getString("storeName");
                        BoolQueryBuilder qbStoreName = QueryBuilders.boolQuery()
                                .should(QueryBuilders.matchQuery("storeName", storeName).analyzer("query_ansj").operator(Operator.AND))
                                .should(QueryBuilders.termQuery("storeName.number", storeName.toLowerCase()))
                                .should(QueryBuilders.matchQuery("storeName.letter", storeName.toLowerCase()).operator(Operator.AND));
                        qb = qb.must(qbStoreName);
                    }

                    if (ERPUtils.mapContainKey(params, "idBrand")) {
                        qb = qb.must(QueryBuilders.termQuery("idBrand", params.getLong("idBrand")));
                    }

                    if (ERPUtils.mapContainKey(params, "idStoreType")) {
                        qb = qb.must(QueryBuilders.termQuery("idStoreType", params.getLong("idStoreType")));
                    }

                    if (ERPUtils.mapContainKey(params, "deliverSettleKind")) {
                        qb = qb.must(QueryBuilders.termQuery("deliverSettleKind", params.getInt("deliverSettleKind")));
                    }

                    if (ERPUtils.mapContainKey(params, "storeCodeInput")) {
                        String storeCodeInput = params.getString("storeCodeInput");
                        BoolQueryBuilder qbStoreCode = QueryBuilders.boolQuery()
                                .should(QueryBuilders.matchQuery("storeCodeInput", storeCodeInput).analyzer("query_ansj").operator(Operator.AND))
                                .should(QueryBuilders.termQuery("storeCodeInput.number", storeCodeInput.toLowerCase()))
                                .should(QueryBuilders.matchQuery("storeCodeInput.letter", storeCodeInput.toLowerCase()).operator(Operator.AND));
                        qb = qb.must(qbStoreCode);
                    }

                    if (ERPUtils.mapContainKey(params, "contractPhone")) {
                        String phone = params.getString("contractPhone");
                        qb = qb.must(QueryBuilders.termQuery("contractPhone", phone));
                    }

                    if (ERPUtils.mapContainKey(params, "voidFlag")) {
                        qb = qb.must(QueryBuilders.termQuery("voidFlag", params.getInt("voidFlag")));
                    }

                    return qb;
                }),
                ((op) -> {
                    idStores.add(op.getId());
                }),
                keysService.getESKey(ESKeys.ES_DELIVER_STORE_INFO_INDEX, supplierCode),
                pageFlipper,
                (() -> SortBuilders.fieldSort("id").order(SortOrder.DESC))
        );

        List<ViewStoreInfo> viewStoreInfoList = new ArrayList<>();

        if (idStores.size() > 0) {
            long[] idStoreArray = idStores.stream().mapToLong(Long::valueOf).toArray();
            String idStoreStr = idStores.stream().map(String::valueOf).collect(Collectors.joining(","));
            Map<Long, List<StorePlatform>> storePlatformMap = searchESMapList(idStoreArray, esClient, jsonConvert,
                    StorePlatform.class,
                    null,
                    ((sd) -> {
                        BoolQueryBuilder qb = QueryBuilders.boolQuery();
                        qb = qb.must(QueryBuilders.typeQuery(ESKeys.ES_DELIVER_STORE_PLATFORM_TYPE))
                                .must(QueryBuilders.termsQuery("idStore", idStoreStr.split(",")));

                        return qb;
                    }),
                    (StorePlatform::getIdStore),
                    new String[]{keysService.getESKey(ESKeys.ES_DELIVER_STORE_PLATFORM_INDEX, supplierCode)},
                    (SortBuilderExecutor) null);

            storeInfoList.forEach(x -> {
                x.setPlatformList(storePlatformMap.get(x.getId()));
                ViewStoreInfo viewStoreInfo = new ViewStoreInfo(x);
                viewStoreInfoList.add(viewStoreInfo);
            });
        }


        return viewStoreInfoList;
    }

    @Override
    public ViewStoreInfo getViewStoreInfo(long idStore, long supplierCode, boolean readInvoice, boolean readEmployee, boolean readPlatform) {
        StoreInfo storeInfo = getESOneInfo(esClient, jsonConvert, StoreInfo.class,
                String.valueOf(idStore),
                keysService.getESKey(ESKeys.ES_DELIVER_STORE_INFO_INDEX, supplierCode),
                ESKeys.ES_DELIVER_STORE_INFO_TYPE,
                null
        );

        if ((storeInfo != null) && (readInvoice)) {
            StoreInvoiceInfo storeInvoiceInfo = this.getStoreInvoiceInfo(idStore, supplierCode);
            storeInfo.setInvoiceInfo(storeInvoiceInfo);
        }

        if ((storeInfo != null) && (readEmployee)) { //先不用

        }

        if ((storeInfo != null) && (readPlatform)) {
            List<StorePlatform> platformList = searchESList(esClient, jsonConvert, StorePlatform.class,
                    null,
                    ((sd) -> {
                        BoolQueryBuilder qb = QueryBuilders.boolQuery();
                        qb = qb.must(QueryBuilders.typeQuery(ESKeys.ES_DELIVER_STORE_PLATFORM_TYPE))
                                .must(QueryBuilders.termQuery("idStore", idStore));

                        return qb;
                    }),
                    keysService.getESKey(ESKeys.ES_DELIVER_STORE_PLATFORM_INDEX, supplierCode),
                    (SortBuilderExecutor) null
            );
            storeInfo.setPlatformList(platformList);
        }

        return new ViewStoreInfo(storeInfo);
    }

    @Override
    public RetResult<StoreInfo> addStoreInfo(StoreInfo storeInfo, ERPTokenUser currentUser, String dataSourceId, long supplierCode) {
        if (StringUtils.isBlank(storeInfo.getStoreName()))
            return RetResult.<StoreInfo>errorT().retinfo("门店名称不可为空");

        if (StringUtils.isBlank(storeInfo.getLoginAccount()))
            return RetResult.<StoreInfo>errorT().retinfo("门店登陆账号不可为空");

        //其他是否必须输入 前端判断
        //先查一下有没有重名的平台信息
        StoreBrand esInfo = this.getESOneInfo(esClient, jsonConvert,
                StoreBrand.class,
                (a) -> {
                    BoolQueryBuilder qb = QueryBuilders.boolQuery().must(QueryBuilders.typeQuery(ESKeys.ES_DELIVER_STORE_INFO_TYPE));
                    qb.must(QueryBuilders.termQuery("storeName.raw", storeInfo.getStoreName()));

                    return qb;
                },
                keysService.getESKey(ESKeys.ES_DELIVER_STORE_INFO_INDEX, supplierCode),
                null);

        if (esInfo != null) return RetResult.<StoreInfo>errorT().retinfo("已存在同名的门店");

        esInfo = this.getESOneInfo(esClient, jsonConvert,
                StoreBrand.class,
                (a) -> {
                    BoolQueryBuilder qb = QueryBuilders.boolQuery().must(QueryBuilders.typeQuery(ESKeys.ES_DELIVER_STORE_INFO_TYPE));
                    qb.must(QueryBuilders.termQuery("loginAccount.raw", storeInfo.getLoginAccount()));

                    return qb;
                },
                keysService.getESKey(ESKeys.ES_DELIVER_STORE_INFO_INDEX, supplierCode),
                null);

        if (esInfo != null) return RetResult.<StoreInfo>errorT().retinfo("已存在同账号的门店");

        storeInfo.setId(tableIdService.getTableIdMulti("tbStoreInfo.id", 1, dataSourceId, String.valueOf(supplierCode)));
        if (storeInfo.getLocation() != null) {
            storeInfo.setLocationStr(jsonConvert.convertTo(storeInfo.getLocation()));
        }

        //密码初始化和账号一样
        if (StringUtils.isNotBlank(storeInfo.getLoginAccount())) {
            storeInfo.setLoginPass(EncryptUtil.md5Digest(storeInfo.getLoginAccount() + passwordSalt));
        }

        StoreInfo.create(storeInfo, currentUser.getId());
        storeInfo.setEnableInvoice(0);

        IndexResponse itemResponse = esClient.getClient()
                .prepareIndex(keysService.getESKey(ESKeys.ES_DELIVER_STORE_INFO_INDEX, supplierCode), ESKeys.ES_DELIVER_STORE_INFO_TYPE)
                .setId(String.valueOf(storeInfo.getId()))
                .setSource(jsonConvert.convertTo(storeInfo), XContentType.JSON)
                .setRefreshPolicy(WriteRequest.RefreshPolicy.IMMEDIATE)
                .get();

        if (itemResponse.getResult() == DocWriteResponse.Result.CREATED) {
            storeDao.addStoreInfo(storeInfo, dataSourceId, supplierCode);
        } else {
            return RetResult.<StoreInfo>errorT().retinfo("创建门店失败");
        }

        return RetResult.successT();
    }

    @Override
    public RetResult<ScriptStringResult> generateStoreAuthUrl_Douyin(long idStore, String dataSourceId, long supplierCode) {
        return this.handleScript("Store_GenerateStoreAuthUrl_Douyin", ERPModule.STORE_API, dataSourceId, supplierCode,
                () -> {
                    return ProcessIdItem.newBuilder()
                            .id(idStore)
                            .dataSourceId(dataSourceId)
                            .supplierCode(supplierCode)
                            .build();
                });
    }

    @Override
    public RetResult<StorePlatform> bindStorePlatformDouyin(String requestContent, String dataSourceId, long supplierCode, ERPTokenUser currentUser) {
        return handleScript("Store_BindStorePlatform_Douyin", ERPModule.STORE_API,
                dataSourceId, supplierCode,
                () -> ProcessStringItem.newBuilder()
                        .itemValue(requestContent)
                        .dataSourceId(dataSourceId)
                        .supplierCode(supplierCode)
                        .currentUser(currentUser)
                        .build()
        );
    }

    @Override
    public StoreInvoiceInfo getStoreInvoiceInfo(long idStore, long supplierCode) {
        return this.getESOneInfo(esClient, jsonConvert,
                StoreInvoiceInfo.class,
                (sd) -> {
                    BoolQueryBuilder qb = QueryBuilders.boolQuery().must(QueryBuilders.typeQuery(ESKeys.ES_DELIVER_STORE_INVOICE_INFO_TYPE));
                    qb.must(QueryBuilders.termQuery("idStore", idStore));
                    return qb;
                },
                keysService.getESKey(ESKeys.ES_DELIVER_STORE_INFO_INDEX, supplierCode),
                null);
    }

    @Override
    public RetResult<StoreInvoiceInfo> configStoreInvoiceInfo(StoreInvoiceInfo invoiceInfo, int enableInvoice, ERPTokenUser currentUser, String dataSourceId, long supplierCode) {
        StoreInfo esStoreInfo = this.getViewStoreInfo(invoiceInfo.getIdStore(), supplierCode, false, false, false).getStoreInfo();
        if (esStoreInfo == null)
            return RetResult.<StoreInvoiceInfo>errorT().retinfo("未找到门店信息");
        esStoreInfo.setEnableInvoice(enableInvoice);
        StoreInfo.update(esStoreInfo, currentUser.getId());
        try {
            UpdateRequest updateRequest = new UpdateRequest(
                    keysService.getESKey(ESKeys.ES_DELIVER_STORE_INFO_INDEX, supplierCode),
                    ESKeys.ES_DELIVER_STORE_INFO_TYPE, String.valueOf(esStoreInfo.getId()))
                    .doc(jsonBuilder()
                            .startObject()
                            .field("enableInvoice", esStoreInfo.getEnableInvoice())
                            .field("updateTimeLong", esStoreInfo.getUpdateTimeLong())
                            .field("updateBy", esStoreInfo.getUpdateBy())
                            .endObject())
                    .setRefreshPolicy(WriteRequest.RefreshPolicy.IMMEDIATE);
            esClient.getClient().update(updateRequest).get();

        } catch (IOException | InterruptedException | ExecutionException e) {
            logger.error("启用或停用门店开票信息[" + esStoreInfo.getId() + "出错：" + e.getMessage(), e);
            RetResult.<StoreInvoiceInfo>errorT().retinfo("启用或停用门店开票信息[" + esStoreInfo.getId() + "出错：");
        }
        if (enableInvoice == 0) { //停用门店开票 不动发票信息
            storeDao.updateStoreEnableInvoice(esStoreInfo, dataSourceId, supplierCode);
            return RetResult.successT();
        }
        // 启用开票
        StoreInvoiceInfo esInvoice = getStoreInvoiceInfo(invoiceInfo.getIdStore(), supplierCode);
        if (esInvoice == null) { // 未设置过发票信息 需要新增
            invoiceInfo.setId(tableIdService.getTableIdMulti("tbStoreInvoiceInfo.id", 1, dataSourceId, String.valueOf(supplierCode)));

            StoreInvoiceInfo.create(invoiceInfo, currentUser.getId());
            IndexResponse itemResponse = esClient.getClient()
                    .prepareIndex(
                            keysService.getESKey(ESKeys.ES_DELIVER_STORE_INVOICE_INFO_TYPE, supplierCode), ESKeys.ES_DELIVER_STORE_INFO_INDEX)
                    .setId(String.valueOf(invoiceInfo.getId()))
                    .setParent(String.valueOf(invoiceInfo.getIdStore()))
                    .setSource(jsonConvert.convertTo(invoiceInfo), XContentType.JSON)
                    .setRefreshPolicy(WriteRequest.RefreshPolicy.IMMEDIATE)
                    .get();

            if (itemResponse.getResult() == DocWriteResponse.Result.CREATED) {
                storeDao.addStoreInvoiceInfo(invoiceInfo, esStoreInfo, dataSourceId, supplierCode);
            } else {
                return RetResult.<StoreInvoiceInfo>errorT().retinfo("门店启用开票失败");
            }
        } else {
            esInvoice.setTaxIdNo(invoiceInfo.getTaxIdNo());
            esInvoice.setCompanyName(invoiceInfo.getCompanyName());
            esInvoice.setDefaultTaxItemCode(invoiceInfo.getDefaultTaxItemCode());
            esInvoice.setDefaultTaxItemName(invoiceInfo.getDefaultTaxItemName());
            esInvoice.setTaxRate(invoiceInfo.getTaxRate());
            StoreInvoiceInfo.update(esInvoice, currentUser.getId());

            try {
                UpdateRequest updateInvoiceRequest = new UpdateRequest(
                        keysService.getESKey(ESKeys.ES_DELIVER_STORE_INFO_INDEX, supplierCode),
                        ESKeys.ES_DELIVER_STORE_INVOICE_INFO_TYPE, String.valueOf(esStoreInfo.getId()))
                        .doc(jsonBuilder()
                                .startObject()
                                .field("taxIdNo", esInvoice.getTaxIdNo())
                                .field("companyName", esInvoice.getCompanyName())
                                .field("defaultTaxItemName", esInvoice.getDefaultTaxItemName())
                                .field("defaultTaxItemCode", esInvoice.getDefaultTaxItemCode())
                                .field("taxRate", esInvoice.getTaxRate())
                                .field("updateTimeLong", esInvoice.getUpdateTimeLong())
                                .field("updateBy", esInvoice.getUpdateBy())
                                .endObject())
                        .setRefreshPolicy(WriteRequest.RefreshPolicy.IMMEDIATE);
                esClient.getClient().update(updateInvoiceRequest).get();

            } catch (IOException | InterruptedException | ExecutionException e) {
                logger.error("门店启用开票信息[" + esStoreInfo.getId() + "出错" + e.getMessage(), e);
                return RetResult.<StoreInvoiceInfo>errorT().retinfo("门店启用开票失败");
            }
            storeDao.updateStoreInvoiceInfo(esInvoice, esStoreInfo, dataSourceId, supplierCode);
        }
        return RetResult.successT();
    }

    @Override
    public RetResult<StoreInfo> updateStoreInfo(StoreInfo storeInfo, ERPTokenUser currentUser, String dataSourceId, long supplierCode) {
        if (StringUtils.isBlank(storeInfo.getStoreName()))
            return RetResult.<StoreInfo>errorT().retinfo("门店名称不可为空");

        StoreInfo esInfo = this.getViewStoreInfo(storeInfo.getId(), supplierCode, false, false, false).getStoreInfo();
        if (esInfo == null) {
            return RetResult.<StoreInfo>errorT().retinfo("未找到此门店");
        }

        esInfo.setStoreName(storeInfo.getStoreName());
        esInfo.setIdBrand(storeInfo.getIdBrand());
        esInfo.setBrandName(storeInfo.getBrandName());
        esInfo.setIdStoreType(storeInfo.getIdStoreType());
        esInfo.setDeliverSettleKind(storeInfo.getDeliverSettleKind());
        esInfo.setStoreCodeInput(storeInfo.getStoreCodeInput());
        esInfo.setStoreProvince(storeInfo.getStoreProvince());
        esInfo.setStoreCity(storeInfo.getStoreCity());
        esInfo.setStoreDistrict(storeInfo.getStoreDistrict());
        esInfo.setStoreAddress(storeInfo.getStoreAddress());
        esInfo.setLocationStr(storeInfo.getLocationStr());
        esInfo.setContractPhone(storeInfo.getContractPhone());
        esInfo.setStoreBossId(storeInfo.getStoreBossId());
        StoreInfo.update(esInfo, currentUser.getId());
        try {
            UpdateRequest updateRequest = new UpdateRequest(keysService.getESKey(ESKeys.ES_DELIVER_STORE_INFO_INDEX, supplierCode),
                    ESKeys.ES_DELIVER_STORE_INFO_TYPE, String.valueOf(esInfo.getId()))
                    .doc(jsonBuilder()
                            .startObject()
                            .field("storeName", esInfo.getStoreName())
                            .field("idBrand", esInfo.getIdBrand())
                            .field("brandName", esInfo.getBrandName())
                            .field("idStoreType", esInfo.getIdStoreType())
                            .field("deliverSettleKind", esInfo.getDeliverSettleKind())
                            .field("storeCodeInput", esInfo.getStoreCodeInput())
                            .field("storeProvince", esInfo.getStoreProvince())
                            .field("storeCity", esInfo.getStoreCity())
                            .field("storeDistrict", esInfo.getStoreDistrict())
                            .field("storeAddress", esInfo.getStoreAddress())
                            .field("locationStr", esInfo.getLocationStr())
                            .field("contractPhone", esInfo.getContractPhone())
                            .field("storeBossId", esInfo.getStoreBossId())
                            .field("updateTimeLong", esInfo.getUpdateTimeLong())
                            .field("updateBy", esInfo.getUpdateBy())
                            .endObject())
                    .setRefreshPolicy(WriteRequest.RefreshPolicy.IMMEDIATE);

            esClient.getClient().update(updateRequest).get();
        } catch (IOException | InterruptedException | ExecutionException e) {
            logger.error("修改门店[" + esInfo.getId() + "出错：" + e.getMessage(), e);
        }
        storeDao.updateStoreInfo(esInfo, dataSourceId, supplierCode);
        return RetResult.successT();
    }

    @Override
    public RetResult<StoreInfo> voidStoreInfo(StoreInfo storeInfo, ERPTokenUser currentUser, String dataSourceId, long supplierCode) {
        StoreInfo esInfo = this.getViewStoreInfo(storeInfo.getId(), supplierCode, false, false, false).getStoreInfo();
        if (esInfo == null) {
            return RetResult.<StoreInfo>errorT().retinfo("未找到此门店");
        }
        esInfo.setVoidFlag(storeInfo.getVoidFlag());
        StoreInfo.update(esInfo, currentUser.getId());
        try {
            UpdateRequest updateRequest = new UpdateRequest(keysService.getESKey(ESKeys.ES_DELIVER_STORE_INFO_INDEX, supplierCode),
                    ESKeys.ES_DELIVER_STORE_INFO_TYPE, String.valueOf(esInfo.getId()))
                    .doc(jsonBuilder()
                            .startObject()
                            .field("voidFlag", esInfo.getVoidFlag())
                            .field("updateTimeLong", esInfo.getUpdateTimeLong())
                            .field("updateBy", esInfo.getUpdateBy())
                            .endObject())
                    .setRefreshPolicy(WriteRequest.RefreshPolicy.IMMEDIATE);

            esClient.getClient().update(updateRequest).get();
        } catch (IOException | InterruptedException | ExecutionException e) {
            logger.error("禁用或启用门店[" + esInfo.getId() + "出错：" + e.getMessage(), e);
        }
        storeDao.voidStoreInfo(esInfo, dataSourceId, supplierCode);
        return RetResult.successT();
    }

    //region 门店平台


    @Override
    public StorePlatform getStorePlatformInfo(long id, long supplierCode) {
        return this.getESOneInfo(esClient, jsonConvert, StorePlatform.class,
                String.valueOf(id),
                keysService.getESKey(ESKeys.ES_DELIVER_STORE_PLATFORM_INDEX, supplierCode),
                ESKeys.ES_DELIVER_STORE_PLATFORM_TYPE,
                null);
    }

    @Override
    public StorePlatform getStorePlatformByInvokeInfo(String platformStoreId, String platformCode, int platformType, long supplierCode) {
        return this.getESOneInfo(esClient, jsonConvert, StorePlatform.class,
                (a) -> {
                    BoolQueryBuilder qb = QueryBuilders.boolQuery().must(QueryBuilders.typeQuery(ESKeys.ES_DELIVER_STORE_PLATFORM_TYPE));
                    qb.must(QueryBuilders.termQuery("platformStoreId.raw", platformStoreId))
                            .must(QueryBuilders.termQuery("platformCode.raw", platformCode))
                            .must(QueryBuilders.termQuery("platformType", platformType));

                    return qb;
                },
                keysService.getESKey(ESKeys.ES_DELIVER_STORE_PLATFORM_INDEX, supplierCode),
                null);
    }
    //endregion
}