package com.ruoyi.other.controller;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ruoyi.account.api.model.TVinManagement;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.utils.poi.ExcelUtil;
import com.ruoyi.common.core.web.domain.AjaxResult;
import com.ruoyi.common.core.web.page.PageInfo;
import com.ruoyi.common.log.annotation.Log;
import com.ruoyi.common.log.enums.BusinessType;
import com.ruoyi.common.security.annotation.Logical;
import com.ruoyi.common.security.annotation.RequiresPermissions;
import com.ruoyi.other.api.domain.TFleet;
import com.ruoyi.other.api.domain.TGroupCompany;
import com.ruoyi.other.api.dto.FleetExportDTO;
import com.ruoyi.other.api.dto.FleetImportDTO;
import com.ruoyi.other.api.dto.FleetQueryDTO;
import com.ruoyi.other.service.TFleetService;
import com.ruoyi.other.service.TGroupCompanyService;
import io.swagger.annotations.ApiOperation;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.DeleteMapping;
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.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RequestPart;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * <p>
 * 车队管理 前端控制器
 * </p>
 *
 * @author mxcd
 * @since 2026-09-22
 */
@RestController
@RequestMapping("/fleet")
public class TFleetController {

    @Resource
    private TFleetService fleetService;

    @Resource
    private TGroupCompanyService groupCompanyService;

    /**
     * 分页查询车队
     */
    @RequiresPermissions(value = {"/fleet/list", "/vinManagement/list", "/chargingCard/list"}, logical = Logical.OR)
    @GetMapping("/page")
    @ApiOperation(value = "分页查询车队", tags = {"管理后台-车队管理"})
    public AjaxResult<PageInfo<TFleet>> page(@RequestParam(value = "current", defaultValue = "1") Integer current,
                                             @RequestParam(value = "size", defaultValue = "10") Integer size,
                                             @RequestParam(value = "fleetName", required = false) String fleetName,
                                             @RequestParam(value = "companyId", required = false) Integer companyId,
                                             @RequestParam(value = "status", required = false) Integer status) {
        PageInfo<TFleet> page = new PageInfo<>(current, size);
        fleetService.lambdaQuery()
                .like(StringUtils.hasText(fleetName), TFleet::getFleetName, fleetName)
                .eq(companyId != null, TFleet::getCompanyId, companyId)
                .eq(status != null, TFleet::getStatus, status)
                .orderByDesc(TFleet::getId)
                .page(page);
        fillCompanyName(page.getRecords());
        // 填充VIN车辆数/可充电站数/累计三列聚合
        fleetService.fillAggregates(page.getRecords());
        return AjaxResult.success(page);
    }

    /**
     * 添加车队
     */
    @RequiresPermissions(value = {"/fleet/list"}, logical = Logical.OR)
    @PostMapping("/add")
    @ApiOperation(value = "添加车队", tags = {"管理后台-车队管理"})
    @Log(title = "【车队管理】添加车队", businessType = BusinessType.INSERT)
    public AjaxResult add(@RequestBody TFleet fleet) {
        if (fleet.getCompanyId() == null) {
            return AjaxResult.error("所属公司不能为空");
        }
        if (!StringUtils.hasText(fleet.getFleetName())) {
            return AjaxResult.error("车队名称不能为空");
        }
        fleet.setId(null);
        fleet.setDelFlag(false);
        if (fleet.getStatus() == null) {
            fleet.setStatus(1);
        }
        fleetService.save(fleet);
        return AjaxResult.success();
    }

    /**
     * 编辑车队
     */
    @RequiresPermissions(value = {"/fleet/list"}, logical = Logical.OR)
    @PostMapping("/edit")
    @ApiOperation(value = "编辑车队", tags = {"管理后台-车队管理"})
    @Log(title = "【车队管理】编辑车队", businessType = BusinessType.UPDATE)
    public AjaxResult edit(@RequestBody TFleet fleet) {
        if (fleet.getId() == null) {
            return AjaxResult.error("车队ID不能为空");
        }
        fleetService.updateById(fleet);
        return AjaxResult.success();
    }

    /**
     * 删除车队（支持逗号分隔批量删除）
     */
    @RequiresPermissions(value = {"/fleet/list"}, logical = Logical.OR)
    @DeleteMapping("/del")
    @ApiOperation(value = "删除车队", tags = {"管理后台-车队管理"})
    @Log(title = "【车队管理】删除车队", businessType = BusinessType.DELETE)
    public AjaxResult del(@RequestParam("ids") String ids) {
        if (!StringUtils.hasText(ids)) {
            return AjaxResult.error("车队ID不能为空");
        }
        List<Integer> idList = java.util.Arrays.stream(ids.split(","))
                .map(String::trim)
                .filter(StringUtils::hasText)
                .map(Integer::valueOf)
                .collect(Collectors.toList());
        if (idList.isEmpty()) {
            return AjaxResult.error("车队ID不能为空");
        }
        fleetService.deleteFleets(idList);
        return AjaxResult.success();
    }

    /**
     * 切换车队启用状态
     */
    @RequiresPermissions(value = {"/fleet/list"}, logical = Logical.OR)
    @PostMapping("/status")
    @ApiOperation(value = "切换车队启用状态", tags = {"管理后台-车队管理"})
    @Log(title = "【车队管理】切换车队状态", businessType = BusinessType.UPDATE)
    public AjaxResult status(@RequestParam("id") Integer id, @RequestParam("status") Integer status) {
        if (id == null) {
            return AjaxResult.error("车队ID不能为空");
        }
        TFleet update = new TFleet();
        update.setId(id);
        update.setStatus(status);
        fleetService.updateById(update);
        return AjaxResult.success();
    }

    /**
     * 导入车队（Excel）
     */
    @RequiresPermissions(value = {"/fleet/import"}, logical = Logical.OR)
    @PostMapping("/import")
    @ApiOperation(value = "导入车队", tags = {"管理后台-车队管理"})
    @Log(title = "【车队管理】导入车队", businessType = BusinessType.IMPORT)
    public AjaxResult<String> importData(@RequestPart("file") MultipartFile file) throws Exception {
        List<FleetImportDTO> items = new ExcelUtil<>(FleetImportDTO.class).importExcel(file.getInputStream());
        return AjaxResult.success(fleetService.importFleets(items));
    }

    /**
     * 下载车队导入模板
     */
    @RequiresPermissions(value = {"/fleet/import"}, logical = Logical.OR)
    @GetMapping("/import-template")
    @ApiOperation(value = "下载车队导入模板", tags = {"管理后台-车队管理"})
    public void template(HttpServletResponse response) {
        new ExcelUtil<>(FleetImportDTO.class).importTemplateExcel(response, "车队导入模板");
    }

    /**
     * 导出车队（Excel，按筛选条件）
     */
    @RequiresPermissions(value = {"/fleet/export"}, logical = Logical.OR)
    @PutMapping("/export")
    @ApiOperation(value = "导出车队", tags = {"管理后台-车队管理"})
    @Log(title = "【车队管理】导出车队", businessType = BusinessType.EXPORT)
    public void export(HttpServletResponse response, @RequestBody(required = false) FleetQueryDTO query) {
        new ExcelUtil<>(FleetExportDTO.class).exportExcel(response, fleetService.selectExportList(query), "车队数据");
    }

    /**
     * 查询车队详情（查看按钮使用）
     */
    @RequiresPermissions(value = {"/fleet/list"}, logical = Logical.OR)
    @GetMapping("/detail")
    @ApiOperation(value = "查询车队详情", tags = {"管理后台-车队管理"})
    public AjaxResult<TFleet> detail(@RequestParam("id") Integer id) {
        if (id == null) {
            return AjaxResult.error("车队ID不能为空");
        }
        TFleet fleet = fleetService.getById(id);
        if (fleet == null) {
            return AjaxResult.error("车队不存在或已删除");
        }
        if (fleet.getCompanyId() != null) {
            TGroupCompany company = groupCompanyService.getById(fleet.getCompanyId());
            if (company != null) {
                fleet.setCompanyName(company.getName());
            }
        }
        // 详情亦填充5列聚合（保持与列表一致）
        fleetService.fillAggregates(java.util.Collections.singletonList(fleet));
        return AjaxResult.success(fleet);
    }

    /**
     * 分页查询车队下的VIN码车辆（查看车队抽屉使用）
     */
    @RequiresPermissions(value = {"/fleet/list"}, logical = Logical.OR)
    @GetMapping("/vin-page")
    @ApiOperation(value = "分页查询车队下VIN码车辆", tags = {"管理后台-车队管理"})
    public AjaxResult<Page<TVinManagement>> vinPage(@RequestParam("id") Integer id,
                                                    @RequestParam(value = "current", defaultValue = "1") Integer current,
                                                    @RequestParam(value = "size", defaultValue = "10") Integer size) {
        return AjaxResult.success(fleetService.selectVinPage(id, current, size));
    }

    /**
     * 按公司ID批量回填公司名称
     */
    private void fillCompanyName(List<TFleet> records) {
        if (records == null || records.isEmpty()) {
            return;
        }
        List<Integer> companyIds = records.stream()
                .map(TFleet::getCompanyId)
                .filter(Objects::nonNull)
                .distinct()
                .collect(Collectors.toList());
        if (companyIds.isEmpty()) {
            return;
        }
        Map<Integer, String> nameMap = groupCompanyService.listByIds(companyIds).stream()
                .collect(Collectors.toMap(TGroupCompany::getId, TGroupCompany::getName, (a, b) -> a));
        records.forEach(item -> item.setCompanyName(nameMap.get(item.getCompanyId())));
    }

    /**
     * 远程接口：车队详情（VIN码车辆所属车队校验使用，内部调用）
     */
    @PostMapping("/remote/get/{id}")
    @ApiOperation(value = "远程-车队详情", tags = {"内部调用"})
    public R<TFleet> remoteGet(@PathVariable("id") Integer id) {
        if (id == null) {
            return R.fail("车队ID不能为空");
        }
        return R.ok(fleetService.getById(id));
    }

    /**
     * 远程接口：按ID批量查询车队（VIN列表回填车队名称使用，内部调用）
     */
    @PostMapping("/remote/list-by-ids")
    @ApiOperation(value = "远程-按ID批量查询车队", tags = {"内部调用"})
    public R<List<TFleet>> remoteListByIds(@RequestBody List<Integer> ids) {
        if (ids == null || ids.isEmpty()) {
            return R.ok(new ArrayList<>());
        }
        List<Integer> distinct = ids.stream().filter(Objects::nonNull).distinct().collect(Collectors.toList());
        if (distinct.isEmpty()) {
            return R.ok(new ArrayList<>());
        }
        return R.ok(fleetService.listByIds(distinct));
    }

}