package com.vincent.rsf.httpaudit.admin;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.vincent.rsf.framework.common.Cools;
import com.vincent.rsf.framework.common.R;
import com.vincent.rsf.httpaudit.entity.HttpAuditSysConfig;
import com.vincent.rsf.httpaudit.service.HttpAuditDbConfigService;
import com.vincent.rsf.httpaudit.service.HttpAuditSysConfigService;
import com.vincent.rsf.httpaudit.web.util.HttpAuditAdminQueryHelper;
import org.apache.commons.lang3.StringUtils;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import java.util.Arrays;
import java.util.Date;
import java.util.Map;

@RestController
public class HttpAuditSysConfigAdminController {

    private final HttpAuditSysConfigService httpAuditSysConfigService;
    private final HttpAuditDbConfigService httpAuditDbConfigService;

    public HttpAuditSysConfigAdminController(HttpAuditSysConfigService httpAuditSysConfigService,
                                            HttpAuditDbConfigService httpAuditDbConfigService) {
        this.httpAuditSysConfigService = httpAuditSysConfigService;
        this.httpAuditDbConfigService = httpAuditDbConfigService;
    }

    @PreAuthorize("hasAuthority('system:httpAuditSysConfig:list')")
    @PostMapping("/httpAuditSysConfig/page")
    public R page(@RequestBody Map<String, Object> body) {
        Map<String, Object> map = HttpAuditAdminQueryHelper.normalizeBody(body);
        Page<HttpAuditSysConfig> page = HttpAuditAdminQueryHelper.extractPage(map);
        String orderBy = HttpAuditAdminQueryHelper.extractOrderBy(map);
        String condition = HttpAuditAdminQueryHelper.extractCondition(map);
        QueryWrapper<HttpAuditSysConfig> qw = new QueryWrapper<>();
        if (!Cools.isEmpty(map.get("configKey"))) {
            qw.like("config_key", map.get("configKey"));
        }
        if (!Cools.isEmpty(map.get("enabled"))) {
            qw.eq("enabled", map.get("enabled"));
        }
        if (StringUtils.isNotBlank(condition)) {
            qw.and(w -> w.like("config_key", condition)
                    .or().like("config_val", condition)
                    .or().like("remark", condition));
        }
        HttpAuditAdminQueryHelper.applySafeOrder(qw, orderBy, "ORDER BY sort_order ASC, id ASC");
        return R.ok().add(httpAuditSysConfigService.page(page, qw));
    }

    @PreAuthorize("hasAuthority('system:httpAuditSysConfig:list')")
    @GetMapping("/httpAuditSysConfig/{id}")
    public R get(@PathVariable Long id) {
        return R.ok().add(httpAuditSysConfigService.getById(id));
    }

    @PreAuthorize("hasAuthority('system:httpAuditSysConfig:save')")
    @PostMapping("/httpAuditSysConfig/save")
    public R save(@RequestBody HttpAuditSysConfig row) {
        R err = validate(row);
        if (err != null) {
            return err;
        }
        if (existsKey(row.getConfigKey(), null)) {
            return R.error("configKey exists");
        }
        Date now = new Date();
        if (row.getEnabled() == null) {
            row.setEnabled(1);
        }
        if (row.getSortOrder() == null) {
            row.setSortOrder(0);
        }
        row.setCreateTime(now);
        row.setUpdateTime(now);
        if (httpAuditSysConfigService.save(row)) {
            httpAuditDbConfigService.refresh();
            return R.ok("Save Success").add(row);
        }
        return R.error("Save Fail");
    }

    @PreAuthorize("hasAuthority('system:httpAuditSysConfig:update')")
    @PostMapping("/httpAuditSysConfig/update")
    public R update(@RequestBody HttpAuditSysConfig row) {
        if (row.getId() == null) {
            return R.error("id required");
        }
        HttpAuditSysConfig old = httpAuditSysConfigService.getById(row.getId());
        if (old == null) {
            return R.error("not found");
        }
        R err = validate(row);
        if (err != null) {
            return err;
        }
        if (!old.getConfigKey().equals(row.getConfigKey()) && existsKey(row.getConfigKey(), row.getId())) {
            return R.error("configKey exists");
        }
        if (row.getEnabled() == null) {
            row.setEnabled(1);
        }
        if (row.getSortOrder() == null) {
            row.setSortOrder(0);
        }
        row.setUpdateTime(new Date());
        if (httpAuditSysConfigService.updateById(row)) {
            httpAuditDbConfigService.refresh();
            return R.ok("Update Success").add(row);
        }
        return R.error("Update Fail");
    }

    @PreAuthorize("hasAuthority('system:httpAuditSysConfig:remove')")
    @PostMapping("/httpAuditSysConfig/remove/{ids}")
    public R remove(@PathVariable Long[] ids) {
        if (httpAuditSysConfigService.removeByIds(Arrays.asList(ids))) {
            httpAuditDbConfigService.refresh();
            return R.ok("Remove Success");
        }
        return R.error("Remove Fail");
    }

    private boolean existsKey(String key, Long excludeId) {
        if (StringUtils.isBlank(key)) {
            return false;
        }
        LambdaQueryWrapper<HttpAuditSysConfig> q = new LambdaQueryWrapper<HttpAuditSysConfig>()
                .eq(HttpAuditSysConfig::getConfigKey, key.trim());
        if (excludeId != null) {
            q.ne(HttpAuditSysConfig::getId, excludeId);
        }
        return httpAuditSysConfigService.count(q) > 0;
    }

    private static R validate(HttpAuditSysConfig row) {
        if (row == null) {
            return R.error("body required");
        }
        if (StringUtils.isBlank(row.getConfigKey())) {
            return R.error("configKey required");
        }
        return null;
    }
}