package com.qianwen.smartman.modules.notify.controller;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

import javax.validation.Valid;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.github.xiaoymin.knife4j.annotations.ApiOperationSupport;
import com.qianwen.core.boot.ctrl.BladeController;
import com.qianwen.core.cache.utils.CacheUtil;
import com.qianwen.core.notify.notifier.NotifierProvider;
import com.qianwen.core.scanner.modular.annotation.DeleteResource;
import com.qianwen.core.scanner.modular.annotation.GetResource;
import com.qianwen.core.scanner.modular.annotation.PutResource;
import com.qianwen.core.scanner.modular.stereotype.ApiResource;
import com.qianwen.core.secure.BladeUser;
import com.qianwen.core.tool.api.R;
import com.qianwen.core.tool.metadata.ConfigMetadata;
import com.qianwen.smartman.common.cache.RegionCache;
import com.qianwen.smartman.modules.notify.convert.NotifyConfigConvert;
import com.qianwen.smartman.modules.notify.dto.NotifyConfigDTO;
import com.qianwen.smartman.modules.notify.dto.NotifyTypeInfo;
import com.qianwen.smartman.modules.notify.dto.ProviderInfo;
import com.qianwen.smartman.modules.notify.entity.NotifyConfigEntity;
import com.qianwen.smartman.modules.notify.service.INotifyConfigService;

import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;

@ApiResource({"blade-notify/notifier/config"})
@Api(value = "通知配置管理", tags = {"通知配置管理"})
@RestController
/* loaded from: blade-api.jar:BOOT-INF/classes/org/springblade/modules/notify/controller/NotifierConfigController.class */
public class NotifierConfigController extends BladeController {
    private final INotifyConfigService notifyConfigService;
    private final List<NotifierProvider> providers;

    public NotifierConfigController(final INotifyConfigService notifyConfigService, final List<NotifierProvider> providers) {
        this.notifyConfigService = notifyConfigService;
        this.providers = providers;
    }

    @ApiOperationSupport(order = 1)
    @GetResource({"/{type}/{provider}/metadata"})
    @ApiOperation(value = "获取指定类型和服务商所需配置定义", notes = "获取指定类型和服务商所需配置定义")
    public R<ConfigMetadata> getAllTypes(@PathVariable("type") @ApiParam(value = "通知类型ID", required = true) String type, @PathVariable("provider") @ApiParam(value = "服务商ID", required = true) String provider) {
        return R.data(this.notifyConfigService.getMetadataByTypeAndProvider(type, provider));
    }

    @ApiOperationSupport(order = 2)
    @GetResource({"/types"})
    @ApiOperation("获取平台支持的通知类型")
    public R<List<NotifyTypeInfo>> getAllNotifyTypes() {
        return R.data(this.notifyConfigService.getAllNotifyType());
    }

    @ApiOperationSupport(order = 3)
    @GetResource({"/type/{type}/providers"})
    @ApiOperation("获取支持的服务商")
    public R<List<ProviderInfo>> getTypeProviders(@PathVariable("type") @ApiParam(value = "通知类型ID类型标识", required = true) String type) {
        return R.data(this.providers.stream().filter(provider -> {
            return provider.getType().getId().equals(type);
        }).map(ProviderInfo::of).collect(Collectors.toList()));
    }

    @ApiOperationSupport(order = 4)
    @PutResource
    @ApiOperation(value = "新增或修改", notes = "传入通知配置")
    public R<NotifyConfigEntity> submit(@Valid @RequestBody NotifyConfigDTO notifyConfigDTO, BladeUser bladeUser) {
        return R.data(this.notifyConfigService.saveOrUpdateConfig(NotifyConfigConvert.INSTANCE.convertToEntity(notifyConfigDTO.setTenantId(bladeUser.getTenantId()))));
    }

    @ApiOperationSupport(order = RegionCache.VILLAGE_LEVEL)
    @DeleteResource({"/{id}"})
    @ApiOperation(value = "删除", notes = "传入id,只允许租户所有的配置删除")
    public R<String> remove(@PathVariable("id") @ApiParam(value = "主键", required = true) String id, BladeUser bladeUser) {
        CacheUtil.evict("blade:notify", "notifier:id:", id, false);
        this.notifyConfigService.checkUsedByBusinessNotify(id);
        
        return R.status(this.notifyConfigService.remove(Wrappers.<NotifyConfigEntity>query().lambda()
        	          .eq(NotifyConfigEntity::getId, id).eq(NotifyConfigEntity::getTenantId, bladeUser.getTenantId())));
        /*
        return R.status(this.notifyConfigService.remove((Wrapper) ((LambdaQueryWrapper) Wrappers.query().lambda().eq((v0) -> {
            return v0.getId();
        }, id)).eq((v0) -> {
            return v0.getTenantId();
        }, bladeUser.getTenantId())));*/
    }

    @ApiOperationSupport(order = 7)
    @GetResource({"/available"})
    @ApiOperation(value = "业务通知可选的通知配置", notes = "传入通知类型")
    public R<List<NotifyConfigDTO>> getAvailableNotifyConfig(@RequestParam String notifyType, BladeUser bladeUser) {
        List<String> tenantIds = new ArrayList<>(Arrays.asList(bladeUser.getTenantId()));
        
        List<NotifyConfigEntity> result = this.notifyConfigService.list(Wrappers.<NotifyConfigEntity>lambdaQuery()
                .in(NotifyConfigEntity::getTenantId, tenantIds)
                .eq(NotifyConfigEntity::getType, notifyType)
                .select(NotifyConfigEntity::getId, NotifyConfigEntity::getName, NotifyConfigEntity::getProvider));
        /*
        List<NotifyConfigEntity> result = this.notifyConfigService.list(((LambdaQueryWrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().in((v0) -> {
            return v0.getTenantId();
        }, tenantIds)).eq((v0) -> {
            return v0.getType();
        }, notifyType)).select(new SFunction[]{(v0) -> {
            return v0.getId();
        }, (v0) -> {
            return v0.getName();
        }, (v0) -> {
            return v0.getProvider();
        }}));*/
        return R.data(NotifyConfigConvert.INSTANCE.convertToDTOList(result));
    }

    @ApiOperationSupport(order = 8)
    @GetResource({"/detail/{configId}"})
    @ApiOperation(value = "详情", notes = "传入通知配置Id")
    public R<NotifyConfigDTO> detail(@PathVariable("configId") String configId) {
        NotifyConfigEntity detail = (NotifyConfigEntity) this.notifyConfigService.getById(configId);
        return R.data(NotifyConfigConvert.INSTANCE.convertToDto(detail));
    }

    @ApiOperationSupport(order = 10)
    @GetMapping({"/service-list"})
    @ApiOperation("服务配置列表")
    public R<List<NotifyTypeInfo>> getServiceList() {
        return R.data(this.notifyConfigService.getServiceList());
    }
}