package com.mes.device.controller;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.mes.device.entity.DeviceGroupConfig;
import com.mes.device.request.DeviceGroupRequest;
import com.mes.device.service.DeviceGroupConfigService;
import com.mes.device.service.DeviceGroupRelationService;
import com.mes.device.vo.DeviceGroupVO;
import com.mes.device.vo.StatisticsVO;
import com.mes.vo.Result;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import javax.validation.Valid;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 设备组管理控制器
 * 
 * @author mes
 * @since 2024-10-30
 */
@Slf4j
@RestController
@RequestMapping("device/group")
@Api(tags = "设备组管理")
public class DeviceGroupController {

    @Resource
    private DeviceGroupConfigService deviceGroupConfigService;

    @Autowired
    private DeviceGroupRelationService deviceGroupRelationService;
    
    @Resource
    private ObjectMapper objectMapper;

    /**
     * 创建设备组
     */
    @PostMapping("/create")
    @ApiOperation("创建设备组")
    public Result<DeviceGroupConfig> createGroup(
            @Valid @RequestBody DeviceGroupRequest request) {
        try {
            DeviceGroupConfig groupConfig = convertToDeviceGroupConfig(request.getGroupConfig());
            if (groupConfig == null) {
                return Result.error("设备组配置信息不能为空");
            }
            boolean success = deviceGroupConfigService.createDeviceGroup(groupConfig);
            if (success) {
                // 创建成功后，重新获取设备组对象
                DeviceGroupConfig created = deviceGroupConfigService.getDeviceGroupByCode(groupConfig.getGroupCode());
                return Result.success(created);
            } else {
                return Result.error("创建设备组失败");
            }
        } catch (Exception e) {
            log.error("创建设备组失败", e);
            return Result.error("创建设备组失败: " + e.getMessage());
        }
    }

    /**
     * 更新设备组配置
     */
    @PostMapping("/update")
    @ApiOperation("更新设备组配置")
    public Result<DeviceGroupConfig> updateGroup(
            @Valid @RequestBody DeviceGroupRequest request) {
        try {
            if (request.getGroupId() == null) {
                return Result.error("设备组ID不能为空");
            }
            DeviceGroupConfig groupConfig = convertToDeviceGroupConfig(request.getGroupConfig());
            if (groupConfig == null) {
                return Result.error("设备组配置信息不能为空");
            }
            groupConfig.setId(request.getGroupId());
            boolean success = deviceGroupConfigService.updateDeviceGroup(groupConfig);
            if (success) {
                // 更新成功后，重新获取设备组对象
                DeviceGroupConfig updated = deviceGroupConfigService.getDeviceGroupByCode(groupConfig.getGroupCode());
                return Result.success(updated);
            } else {
                return Result.error("更新设备组配置失败");
            }
        } catch (Exception e) {
            log.error("更新设备组配置失败", e);
            return Result.error("更新设备组配置失败: " + e.getMessage());
        }
    }

    /**
     * 删除设备组配置
     */
    @PostMapping("/delete")
    @ApiOperation("删除设备组配置")
    public Result<Void> deleteGroup(
            @Valid @RequestBody DeviceGroupRequest request) {
        try {
            deviceGroupConfigService.deleteDeviceGroup(request.getGroupId());
            return Result.success(null);
        } catch (Exception e) {
            log.error("删除设备组配置失败", e);
            return Result.error();
        }
    }

    /**
     * 根据ID获取设备组配置
     */
    @PostMapping("/detail")
    @ApiOperation("获取设备组配置详情")
    public Result<DeviceGroupConfig> getGroupById(
            @Valid @RequestBody DeviceGroupRequest request) {
        try {
            DeviceGroupConfig group = deviceGroupConfigService.getDeviceGroupById(request.getGroupId());
            return Result.success(group);
        } catch (Exception e) {
            log.error("获取设备组配置失败", e);
            return Result.error();
        }
    }

    /**
     * 分页查询设备组列表
     */
    @PostMapping("/list")
    @ApiOperation("分页查询设备组列表")
    public Result<Page<DeviceGroupVO.GroupInfo>> getGroupList(
            @Valid @RequestBody DeviceGroupRequest request) {
        try {
            @SuppressWarnings("unchecked")
            Map<String, Object> configMap = (Map<String, Object>) (request.getGroupConfig() != null ? request.getGroupConfig() : new HashMap<>());
            Page pageResult = deviceGroupConfigService.getDeviceGroupList(
                (Long) configMap.get("projectId"),
                (String) configMap.get("groupType"),
                (String) configMap.get("groupStatus"),
                (String) configMap.get("keyword"),
                (Integer) configMap.get("page"),
                (Integer) configMap.get("size")
            );
            return Result.success(pageResult);
        } catch (Exception e) {
            log.error("查询设备组列表失败", e);
            return Result.error();
        }
    }

    /**
     * 启用设备组
     */
    @PostMapping("/enable")
    @ApiOperation("启用设备组")
    public Result<Void> enableGroup(
            @Valid @RequestBody DeviceGroupRequest request) {
        try {
            deviceGroupConfigService.enableDeviceGroup(request.getGroupId());
            return Result.success(null);
        } catch (Exception e) {
            log.error("启用设备组失败", e);
            return Result.error();
        }
    }

    /**
     * 禁用设备组
     */
    @PostMapping("/disable")
    @ApiOperation("禁用设备组")
    public Result<Void> disableGroup(
            @Valid @RequestBody DeviceGroupRequest request) {
        try {
            deviceGroupConfigService.disableDeviceGroup(request.getGroupId());
            return Result.success(null);
        } catch (Exception e) {
            log.error("禁用设备组失败", e);
            return Result.error();
        }
    }

    /**
     * 批量启用设备组
     */
    @PostMapping("/batch-enable")
    @ApiOperation("批量启用设备组")
    public Result<Void> batchEnableGroups(
            @Valid @RequestBody DeviceGroupRequest request) {
        try {
            deviceGroupConfigService.batchEnableDeviceGroups(request.getGroupIds());
            return Result.success(null);
        } catch (Exception e) {
            log.error("批量启用设备组失败", e);
            return Result.error();
        }
    }

    /**
     * 批量禁用设备组
     */
    @PostMapping("/batch-disable")
    @ApiOperation("批量禁用设备组")
    public Result<Void> batchDisableGroups(
            @Valid @RequestBody DeviceGroupRequest request) {
        try {
            deviceGroupConfigService.batchDisableDeviceGroups(request.getGroupIds());
            return Result.success(null);
        } catch (Exception e) {
            log.error("批量禁用设备组失败", e);
            return Result.error();
        }
    }

    /**
     * 获取设备组统计信息
     */
    @PostMapping("/statistics/groups")
    @ApiOperation("获取设备组统计信息")
    public Result<StatisticsVO.GroupStatistics> getGroupStatistics(
            @RequestBody(required = false) Map<String, Object> request) {
        try {
            Long projectId = request != null ? (Long) request.get("projectId") : null;
            StatisticsVO.GroupStatistics statistics = deviceGroupConfigService.getDeviceGroupStatistics(projectId);
            return Result.success(statistics);
        } catch (Exception e) {
            log.error("获取设备组统计信息失败", e);
            return Result.error();
        }
    }

    /**
     * 检查设备组编码是否已存在
     */
    @PostMapping("/check-code")
    @ApiOperation("检查设备组编码")
    public Result<Boolean> checkGroupCodeExists(
            @Valid @RequestBody DeviceGroupRequest request) {
        try {
            @SuppressWarnings("unchecked")
            Map<String, Object> configMap = (Map<String, Object>) (request.getGroupConfig() != null ? request.getGroupConfig() : new HashMap<>());
            boolean exists = deviceGroupConfigService.isGroupCodeExists(
                (String) configMap.get("groupCode"), 
                request.getGroupId());
            return Result.success(exists);
        } catch (Exception e) {
            log.error("检查设备组编码失败", e);
            return Result.error();
        }
    }

    /**
     * 获取设备组类型列表
     */
    @PostMapping("/types")
    @ApiOperation("获取设备组类型列表")
    public Result<List<String>> getGroupTypes() {
        try {
            List<String> groupTypes = deviceGroupConfigService.getAllGroupTypes();
            return Result.success(groupTypes);
        } catch (Exception e) {
            log.error("获取设备组类型列表失败", e);
            return Result.error();
        }
    }

    /**
     * 获取设备组状态列表
     */
    @PostMapping("/statuses")
    @ApiOperation("获取设备组状态列表")
    public Result<List<String>> getGroupStatuses() {
        try {
            List<String> groupStatuses = deviceGroupConfigService.getAllGroupStatuses();
            return Result.success(groupStatuses);
        } catch (Exception e) {
            log.error("获取设备组状态列表失败", e);
            return Result.error();
        }
    }

    /**
     * 添加设备到设备组
     */
    @PostMapping("/devices")
    @ApiOperation("添加设备到设备组")
    public Result<Void> addDeviceToGroup(
            @Valid @RequestBody DeviceGroupRequest request) {
        try {
            deviceGroupRelationService.addDeviceToGroup(request.getGroupId(), request.getDeviceId(), 
                request.getDeviceRole() != null ? request.getDeviceRole() : "MEMBER");
            return Result.success(null);
        } catch (Exception e) {
            log.error("添加设备到设备组失败", e);
            return Result.error();
        }
    }

    /**
     * 从设备组移除设备
     */
    @PostMapping("/devices/remove")
    @ApiOperation("从设备组移除设备")
    public Result<Void> removeDeviceFromGroup(
            @Valid @RequestBody DeviceGroupRequest request) {
        try {
            deviceGroupRelationService.removeDeviceFromGroup(request.getGroupId(), request.getDeviceId());
            return Result.success(null);
        } catch (Exception e) {
            log.error("从设备组移除设备失败", e);
            return Result.error();
        }
    }

    /**
     * 更新设备角色
     */
    @PostMapping("/devices/role")
    @ApiOperation("更新设备角色")
    public Result<Void> updateDeviceRole(
            @Valid @RequestBody DeviceGroupRequest request) {
        try {
            deviceGroupRelationService.updateDeviceRole(request.getGroupId(), request.getDeviceId(), 
                request.getDeviceRole());
            return Result.success(null);
        } catch (Exception e) {
            log.error("更新设备角色失败", e);
            return Result.error();
        }
    }

    /**
     * 获取设备组设备列表
     */
    @PostMapping("/devices/list")
    @ApiOperation("获取设备组设备列表")
    public Result<List<DeviceGroupVO.DeviceInfo>> getGroupDevices(
            @Valid @RequestBody DeviceGroupRequest request) {
        try {
            List<DeviceGroupVO.DeviceInfo> devices = deviceGroupRelationService.getGroupDevices(request.getGroupId());
            return Result.success(devices);
        } catch (Exception e) {
            log.error("获取设备组设备列表失败", e);
            return Result.error();
        }
    }

    /**
     * 获取设备设备组列表
     */
    @PostMapping("/devices/groups")
    @ApiOperation("获取设备设备组列表")
    public Result<List<DeviceGroupVO.GroupInfo>> getDeviceGroups(
            @Valid @RequestBody DeviceGroupRequest request) {
        try {
            List<DeviceGroupVO.GroupInfo> groups = deviceGroupRelationService.getDeviceGroups(request.getDeviceId());
            return Result.success(groups);
        } catch (Exception e) {
            log.error("获取设备设备组列表失败", e);
            return Result.error();
        }
    }

    /**
     * 批量添加设备到设备组
     */
    @PostMapping("/batch-add-devices")
    @ApiOperation("批量添加设备到设备组")
    public Result<Void> batchAddDevicesToGroup(
            @Valid @RequestBody DeviceGroupRequest request) {
        try {
            deviceGroupRelationService.batchAddDevicesToGroup(request.getGroupId(), request.getDeviceIds());
            return Result.success(null);
        } catch (Exception e) {
            log.error("批量添加设备到设备组失败", e);
            return Result.error();
        }
    }

    /**
     * 批量从设备组移除设备
     */
    @PostMapping("/devices/batch-remove")
    @ApiOperation("批量从设备组移除设备")
    public Result<Void> batchRemoveDevicesFromGroup(
            @Valid @RequestBody DeviceGroupRequest request) {
        try {
            deviceGroupRelationService.batchRemoveDevicesFromGroup(request.getGroupId(), request.getDeviceIds());
            return Result.success(null);
        } catch (Exception e) {
            log.error("批量从设备组移除设备失败", e);
            return Result.error();
        }
    }

    /**
     * 设备组健康检查
     */
    @PostMapping("/health-check")
    @ApiOperation("设备组健康检查")
    public Result<DeviceGroupVO.HealthCheckResult> performGroupHealthCheck(
            @Valid @RequestBody DeviceGroupRequest request) {
        try {
            DeviceGroupVO.HealthCheckResult result = deviceGroupConfigService.performGroupHealthCheck(request.getGroupId());
            return Result.success(result);
        } catch (Exception e) {
            log.error("设备组健康检查失败", e);
            return Result.error();
        }
    }

    /**
     * 获取设备组性能统计
     */
    @PostMapping("/performance")
    @ApiOperation("获取设备组性能统计")
    public Result<DeviceGroupVO.PerformanceStats> getGroupPerformance(
            @Valid @RequestBody DeviceGroupRequest request) {
        try {
            DeviceGroupVO.PerformanceStats stats = deviceGroupConfigService.getGroupPerformance(request.getGroupId());
            return Result.success(stats);
        } catch (Exception e) {
            log.error("获取设备组性能统计失败", e);
            return Result.error();
        }
    }
    
    /**
     * 将Object转换为DeviceGroupConfig
     * 
     * @param obj 待转换的对象
     * @return DeviceGroupConfig对象，如果转换失败返回null
     */
    private DeviceGroupConfig convertToDeviceGroupConfig(Object obj) {
        if (obj == null) {
            return null;
        }
        
        // 如果已经是DeviceGroupConfig类型，直接返回
        if (obj instanceof DeviceGroupConfig) {
            return (DeviceGroupConfig) obj;
        }
        
        // 如果是Map类型，使用ObjectMapper转换
        if (obj instanceof Map) {
            try {
                return objectMapper.convertValue(obj, DeviceGroupConfig.class);
            } catch (Exception e) {
                log.error("转换Map到DeviceGroupConfig失败", e);
                return null;
            }
        }
        
        // 其他类型，尝试使用ObjectMapper转换
        try {
            return objectMapper.convertValue(obj, DeviceGroupConfig.class);
        } catch (Exception e) {
            log.error("转换Object到DeviceGroupConfig失败: obj={}", obj, e);
            return null;
        }
    }
}