package com.vincent.rsf.server.system.controller;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.vincent.rsf.framework.common.Cools;
import com.vincent.rsf.framework.common.R;
import com.vincent.rsf.framework.common.SnowflakeIdWorker;
import com.vincent.rsf.server.ai.service.AiModelRouteRuntimeService;
import com.vincent.rsf.server.common.annotation.OperationLog;
import com.vincent.rsf.server.common.domain.BaseParam;
import com.vincent.rsf.server.common.domain.PageParam;
import com.vincent.rsf.server.common.utils.ExcelUtil;
import com.vincent.rsf.server.system.entity.AiModelRoute;
import com.vincent.rsf.server.system.service.AiModelRouteService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletResponse;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.Map;

@RestController
public class AiRouteController extends BaseController {

    @Autowired
    private AiModelRouteService aiModelRouteService;
    @Autowired
    private AiModelRouteRuntimeService aiModelRouteRuntimeService;
    @Autowired
    private SnowflakeIdWorker snowflakeIdWorker;

    @PreAuthorize("hasAuthority('system:aiRoute:list')")
    @PostMapping("/aiRoute/page")
    public R page(@RequestBody Map<String, Object> map) {
        BaseParam baseParam = buildParam(map, BaseParam.class);
        PageParam<AiModelRoute, BaseParam> pageParam = new PageParam<>(baseParam, AiModelRoute.class);
        com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<AiModelRoute> wrapper = pageParam.buildWrapper(true);
        wrapper.eq("tenant_id", getTenantId());
        return R.ok().add(aiModelRouteService.page(pageParam, wrapper));
    }

    @PreAuthorize("hasAuthority('system:aiRoute:list')")
    @GetMapping("/aiRoute/{id}")
    public R get(@PathVariable("id") Long id) {
        AiModelRoute route = aiModelRouteService.getTenantRoute(getTenantId(), id);
        if (route == null) {
            return R.error("route not found");
        }
        return R.ok().add(route);
    }

    @PreAuthorize("hasAuthority('system:aiRoute:save')")
    @OperationLog("Create AiRoute")
    @PostMapping("/aiRoute/save")
    public R save(@RequestBody AiModelRoute aiModelRoute) {
        if (Cools.isEmpty(aiModelRoute.getRouteCode()) || Cools.isEmpty(aiModelRoute.getModelCode())) {
            return R.error("路由编码和模型编码不能为空");
        }
        Date now = new Date();
        aiModelRoute.setUuid(String.valueOf(snowflakeIdWorker.nextId()).substring(3));
        aiModelRoute.setTenantId(getTenantId());
        aiModelRoute.setCreateBy(getLoginUserId());
        aiModelRoute.setCreateTime(now);
        aiModelRoute.setUpdateBy(getLoginUserId());
        aiModelRoute.setUpdateTime(now);
        if (aiModelRoute.getPriority() == null) {
            aiModelRoute.setPriority(1);
        }
        if (aiModelRoute.getStatus() == null) {
            aiModelRoute.setStatus(1);
        }
        if (aiModelRoute.getFailCount() == null) {
            aiModelRoute.setFailCount(0);
        }
        if (aiModelRoute.getSuccessCount() == null) {
            aiModelRoute.setSuccessCount(0);
        }
        if (!aiModelRouteService.save(aiModelRoute)) {
            return R.error("Save Fail");
        }
        return R.ok("Save Success").add(aiModelRoute);
    }

    @PreAuthorize("hasAuthority('system:aiRoute:update')")
    @OperationLog("Update AiRoute")
    @PostMapping("/aiRoute/update")
    public R update(@RequestBody AiModelRoute aiModelRoute) {
        AiModelRoute existed = aiModelRouteService.getTenantRoute(getTenantId(), aiModelRoute.getId());
        if (existed == null) {
            return R.error("route not found");
        }
        aiModelRoute.setTenantId(getTenantId());
        aiModelRoute.setUpdateBy(getLoginUserId());
        aiModelRoute.setUpdateTime(new Date());
        aiModelRoute.setCreateBy(existed.getCreateBy());
        aiModelRoute.setCreateTime(existed.getCreateTime());
        if (!aiModelRouteService.updateById(aiModelRoute)) {
            return R.error("Update Fail");
        }
        return R.ok("Update Success").add(aiModelRoute);
    }

    @PreAuthorize("hasAuthority('system:aiRoute:remove')")
    @OperationLog("Delete AiRoute")
    @PostMapping("/aiRoute/remove/{ids}")
    public R remove(@PathVariable Long[] ids) {
        List<Long> idList = Arrays.asList(ids);
        List<AiModelRoute> routes = aiModelRouteService.list(new LambdaQueryWrapper<AiModelRoute>()
                .eq(AiModelRoute::getTenantId, getTenantId())
                .in(AiModelRoute::getId, idList));
        if (routes.size() != idList.size() || !aiModelRouteService.removeByIds(idList)) {
            return R.error("Delete Fail");
        }
        return R.ok("Delete Success").add(ids);
    }

    @PreAuthorize("hasAuthority('system:aiRoute:list')")
    @PostMapping("/aiRoute/export")
    public void export(@RequestBody Map<String, Object> map, HttpServletResponse response) throws Exception {
        ExcelUtil.build(ExcelUtil.create(aiModelRouteService.list(new LambdaQueryWrapper<AiModelRoute>()
                .eq(AiModelRoute::getTenantId, getTenantId())), AiModelRoute.class), response);
    }

    @PreAuthorize("hasAuthority('system:aiRoute:list')")
    @GetMapping("/ai/route/list")
    public R customList(@RequestParam(required = false) String routeCode) {
        LambdaQueryWrapper<AiModelRoute> wrapper = new LambdaQueryWrapper<AiModelRoute>()
                .eq(AiModelRoute::getTenantId, getTenantId())
                .orderByAsc(AiModelRoute::getRouteCode, AiModelRoute::getPriority, AiModelRoute::getId);
        if (!Cools.isEmpty(routeCode)) {
            wrapper.eq(AiModelRoute::getRouteCode, routeCode);
        }
        return R.ok().add(aiModelRouteService.list(wrapper));
    }

    @PreAuthorize("hasAnyAuthority('system:aiRoute:save','system:aiRoute:update')")
    @PostMapping("/ai/route/save")
    public R customSave(@RequestBody AiModelRoute aiModelRoute) {
        if (aiModelRoute.getId() == null) {
            if (!hasAuthority("system:aiRoute:save")) {
                return R.error("无新增权限");
            }
            return save(aiModelRoute);
        }
        if (!hasAuthority("system:aiRoute:update")) {
            return R.error("无更新权限");
        }
        return update(aiModelRoute);
    }

    @PreAuthorize("hasAuthority('system:aiRoute:update')")
    @OperationLog("Toggle AiRoute")
    @PostMapping("/ai/route/toggle")
    public R toggle(@RequestBody Map<String, Object> map) {
        Long id = Long.valueOf(String.valueOf(map.get("id")));
        Integer status = Integer.valueOf(String.valueOf(map.get("status")));
        AiModelRoute route = aiModelRouteService.getTenantRoute(getTenantId(), id);
        if (route == null) {
            return R.error("route not found");
        }
        route.setStatus(status);
        route.setUpdateBy(getLoginUserId());
        route.setUpdateTime(new Date());
        aiModelRouteService.updateById(route);
        return R.ok().add(route);
    }

    @PreAuthorize("hasAuthority('system:aiRoute:update')")
    @OperationLog("Reset AiRoute")
    @PostMapping("/ai/route/reset")
    public R reset(@RequestBody Map<String, Object> map) {
        Long id = Long.valueOf(String.valueOf(map.get("id")));
        if (aiModelRouteService.getTenantRoute(getTenantId(), id) == null) {
            return R.error("route not found");
        }
        aiModelRouteRuntimeService.resetRoute(id);
        return R.ok();
    }

}