package com.dsh.activity.controller;

import cn.hutool.core.collection.CollUtil;
import com.alibaba.fastjson.JSONArray;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.dsh.activity.entity.THuiminAgreement;
import com.dsh.activity.entity.THuiminAgreementSetting;
import com.dsh.activity.model.HuiminAgreementQuery;
import com.dsh.activity.service.HuiminAgreementService;
import com.dsh.activity.service.HuiminAgreementSettingService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;
import java.util.Objects;

/**
 * @author zhibing.pu
 * @date 2023/6/24 11:27
 */
@RestController
@RequestMapping("")
public class HuiminAgreementController {

    @Autowired
    private HuiminAgreementService huiminAgreementService;

    @Autowired
    private HuiminAgreementSettingService huiminAgreementSettingService;

    /**
     * 根据当前用户类型查询玩湃惠民卡协议
     * @param query
     * @return
     */
    @ResponseBody
    @PostMapping("/base/tHuiminAgreement/selectByObjectType")
    public THuiminAgreement selectByObjectType(@RequestBody HuiminAgreementQuery query) {
        THuiminAgreement huiminAgreement = null;
        if (query.getObjectType().equals(1) && Objects.isNull(query.getOperatorId())) {
            //平台
            huiminAgreement = huiminAgreementService.getOne(new LambdaQueryWrapper<THuiminAgreement>()
                    .isNull(THuiminAgreement::getOperatorId));
        }else if (query.getObjectType().equals(1) && Objects.nonNull(query.getOperatorId())){
            //平台
            huiminAgreement = huiminAgreementService.getOne(new LambdaQueryWrapper<THuiminAgreement>()
                    .eq(THuiminAgreement::getOperatorId, query.getOperatorId()));
        }else if (query.getObjectType().equals(2)) {
            //运营商
            huiminAgreement = huiminAgreementService.getOne(new LambdaQueryWrapper<THuiminAgreement>()
                    .eq(THuiminAgreement::getOperatorId,query.getOperatorId()));
        }
        if (Objects.nonNull(huiminAgreement)) {
            //查询协议配置
            List<THuiminAgreementSetting> tHuiminAgreementSettingList = huiminAgreementSettingService.list(new LambdaQueryWrapper<THuiminAgreementSetting>()
                    .eq(THuiminAgreementSetting::getAgreementId, huiminAgreement.getId()));
            huiminAgreement.setSettingList(tHuiminAgreementSettingList);
        }
        return huiminAgreement;
    }
    /**
     * 保存玩湃惠民卡协议
     * @param tHuiminAgreement
     */
    @PostMapping("/base/tHuiminAgreement/save")
    @Transactional(rollbackFor = Exception.class)
    public void insert(@RequestBody THuiminAgreement tHuiminAgreement){
        String agreementSettings = tHuiminAgreement.getAgreementSettings();
        List<THuiminAgreementSetting> tHuiminAgreementSettings = JSONArray.parseArray(agreementSettings, THuiminAgreementSetting.class);
        tHuiminAgreement.setSettingList(tHuiminAgreementSettings);
        Integer operatorId = tHuiminAgreement.getOperatorId();
        //如果是平台账号，需要设置operatorId为null
        List<THuiminAgreementSetting> tHuiminAgreementSettingList = tHuiminAgreement.getSettingList();
        //如果是运营商账号或平台账号默认配置
        if (tHuiminAgreement.getObjectType().equals(2) || tHuiminAgreement.getObjectType().equals(1) && Objects.isNull(operatorId)) {
            if (tHuiminAgreement.getObjectType().equals(1)) {
                tHuiminAgreement.setOperatorId(null);
                boolean remove = huiminAgreementService.remove(new LambdaQueryWrapper<THuiminAgreement>()
                        .isNull(THuiminAgreement::getOperatorId));

            }
            huiminAgreementService.saveOrUpdate(tHuiminAgreement);
            //删除之前的协议配置
            huiminAgreementSettingService.remove(new LambdaQueryWrapper<THuiminAgreementSetting>().eq(THuiminAgreementSetting::getAgreementId, tHuiminAgreement.getId()));
            //保存协议配置
            tHuiminAgreementSettingList.forEach(t -> {
                t.setAgreementId(tHuiminAgreement.getId());
            });
        } else {
            //平台配置运营商的协议配置
            THuiminAgreement agreement = huiminAgreementService.lambdaQuery()
                    .eq(THuiminAgreement::getOperatorId, operatorId)
                    .last("LIMIT 1").one();
            if (Objects.isNull(agreement)) {
                agreement = new THuiminAgreement();
                agreement.setOperatorId(operatorId);
            }
            agreement.setStoreNoHuiminCardIntro(tHuiminAgreement.getStoreNoHuiminCardIntro());
            huiminAgreementService.saveOrUpdate(agreement);
            //删除之前的协议配置
            huiminAgreementSettingService.remove(new LambdaQueryWrapper<THuiminAgreementSetting>()
                    .eq(THuiminAgreementSetting::getAgreementId, agreement.getId()));
            //保存协议配置
            THuiminAgreement finalAgreement = agreement;
            tHuiminAgreementSettingList.forEach(t -> {
                t.setAgreementId(finalAgreement.getId());
            });
        }
        if (CollUtil.isNotEmpty(tHuiminAgreementSettingList)) {
            huiminAgreementSettingService.saveBatch(tHuiminAgreementSettingList);
        }
    }
}