package com.zxyj.controller.admin;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.zxyj.common.Result;
import com.zxyj.entity.*;
import com.zxyj.mapper.*;
import com.zxyj.service.UserService;
import javax.annotation.Resource;
import org.springframework.web.bind.annotation.*;

import java.util.Date;
import java.util.HashMap;
import java.util.Map;

@RestController
@RequestMapping("/api/admin")
public class AdminController {

    @Resource
    private UserMapper userMapper;

    @Resource
    private ChildMapper childMapper;

    @Resource
    private TaskMapper taskMapper;

    @Resource
    private RewardMapper rewardMapper;

    @Resource
    private PointsLogMapper pointsLogMapper;

    @Resource
    private FamilyMapper familyMapper;

    @Resource
    private TaskTemplateMapper taskTemplateMapper;

    @Resource
    private UserService userService;

    // 用户管理
    @PostMapping("/users")
    public Result<Page<User>> getUsers(@RequestBody Map<String, Object> params) {
        Integer page = params.get("page") != null ? (Integer) params.get("page") : 1;
        Integer size = params.get("size") != null ? (Integer) params.get("size") : 10;
        Page<User> pageParam = new Page<>(page, size);
        Page<User> result = userMapper.selectPage(pageParam, null);
        return Result.success(result);
    }

    @PostMapping("/users/{id}")
    public Result<User> getUser(@PathVariable Long id) {
        return Result.success(userMapper.selectById(id));
    }

    @PutMapping("/users/{id}")
    public Result<Boolean> updateUser(@PathVariable Long id, @RequestBody User user) {
        user.setId(id);
        userMapper.updateById(user);
        return Result.success(true);
    }

    @DeleteMapping("/users/{id}")
    public Result<Boolean> deleteUser(@PathVariable Long id) {
        userMapper.deleteById(id);
        return Result.success(true);
    }

    // 孩子管理
    @PostMapping("/children")
    public Result<Page<Child>> getChildren(@RequestBody Map<String, Object> params) {
        Integer page = params.get("page") != null ? (Integer) params.get("page") : 1;
        Integer size = params.get("size") != null ? (Integer) params.get("size") : 10;
        Page<Child> pageParam = new Page<>(page, size);
        Page<Child> result = childMapper.selectPage(pageParam, null);
        return Result.success(result);
    }

    @PostMapping("/children/{id}")
    public Result<Child> getChild(@PathVariable Long id) {
        return Result.success(childMapper.selectById(id));
    }

    @PutMapping("/children/{id}")
    public Result<Boolean> updateChild(@PathVariable Long id, @RequestBody Child child) {
        child.setId(id);
        childMapper.updateById(child);
        return Result.success(true);
    }

    @PostMapping("/children/{id}/adjust-points")
    public Result<Map<String, Object>> adjustPoints(
            @PathVariable Long id,
            @RequestBody Map<String, Object> params) {
        Integer amount = (Integer) params.get("amount");
        String reason = (String) params.get("reason");

        Child child = childMapper.selectById(id);
        if (child == null) {
            return Result.error("孩子不存在");
        }

        int newBalance = child.getTotalPoints() + amount;
        if (newBalance < 0) {
            return Result.error("积分不能为负");
        }

        child.setTotalPoints(newBalance);
        child.setUpdatedAt(new Date());
        childMapper.updateById(child);

        // 记录积分流水
        PointsLog log = new PointsLog();
        log.setChildId(id);
        log.setAmount(amount);
        log.setType("adjust");
        log.setDescription(reason);
        log.setCreatedAt(new Date());
        pointsLogMapper.insert(log);

        Map<String, Object> result = new HashMap<>();
        result.put("newBalance", newBalance);
        return Result.success(result);
    }

    // 任务管理
    @PostMapping("/tasks")
    public Result<Page<Task>> getTasks(@RequestBody Map<String, Object> params) {
        Integer page = params.get("page") != null ? (Integer) params.get("page") : 1;
        Integer size = params.get("size") != null ? (Integer) params.get("size") : 10;
        String status = (String) params.get("status");
        Long familyId = params.get("familyId") != null ? ((Number) params.get("familyId")).longValue() : null;
        
        Page<Task> pageParam = new Page<>(page, size);
        LambdaQueryWrapper<Task> wrapper = new LambdaQueryWrapper<>();
        if (status != null && !status.isEmpty()) {
            wrapper.eq(Task::getStatus, status);
        }
        if (familyId != null) {
            wrapper.eq(Task::getFamilyId, familyId);
        }
        wrapper.orderByDesc(Task::getCreatedAt);
        Page<Task> result = taskMapper.selectPage(pageParam, wrapper);
        return Result.success(result);
    }

    @PostMapping("/tasks/stats")
    public Result<Map<String, Object>> getTaskStats() {
        Map<String, Object> stats = new HashMap<>();
        
        Long total = taskMapper.selectCount(null);
        Long today = taskMapper.selectCount(new LambdaQueryWrapper<Task>()
                .ge(Task::getDeadline, new Date()));
        
        stats.put("total", total);
        stats.put("today", today);
        
        return Result.success(stats);
    }

    // 奖励管理
    @PostMapping("/rewards")
    public Result<Page<Reward>> getRewards(@RequestBody Map<String, Object> params) {
        Integer page = params.get("page") != null ? (Integer) params.get("page") : 1;
        Integer size = params.get("size") != null ? (Integer) params.get("size") : 10;
        String status = (String) params.get("status");
        Long familyId = params.get("familyId") != null ? ((Number) params.get("familyId")).longValue() : null;
        
        Page<Reward> pageParam = new Page<>(page, size);
        LambdaQueryWrapper<Reward> wrapper = new LambdaQueryWrapper<>();
        if (status != null && !status.isEmpty()) {
            wrapper.eq(Reward::getStatus, status);
        }
        if (familyId != null) {
            wrapper.eq(Reward::getFamilyId, familyId);
        }
        wrapper.orderByDesc(Reward::getCreatedAt);
        Page<Reward> result = rewardMapper.selectPage(pageParam, wrapper);
        return Result.success(result);
    }

    @PostMapping("/rewards/templates")
    public Result<Object> getRewardTemplates(@RequestAttribute("userId") Long userId) {
        // 获取用户的家庭 ID，只返回该家庭的模板
        com.zxyj.entity.User user = userService.getUserInfo(userId);
        if (user == null || user.getFamilyId() == null) {
            return Result.error("用户必须属于某个家庭");
        }
        
        return Result.success(rewardMapper.selectList(new LambdaQueryWrapper<Reward>()
                .eq(Reward::getIsTemplate, 1)
                .eq(Reward::getFamilyId, user.getFamilyId()))); // 按家庭 ID 过滤
    }

    @PostMapping("/rewards/create")
    public Result<Long> createRewardTemplate(@RequestBody Reward reward, @RequestAttribute("userId") Long userId) {
        // 强制关联家庭
        com.zxyj.entity.User user = userService.getUserInfo(userId);
        if (user == null || user.getFamilyId() == null) {
            return Result.error("用户必须属于某个家庭");
        }
        
        reward.setFamilyId(user.getFamilyId());
        reward.setIsTemplate(1);
        reward.setCreatedAt(new Date());
        reward.setUpdatedAt(new Date());
        rewardMapper.insert(reward);
        return Result.success(reward.getId());
    }

    @DeleteMapping("/rewards/templates/{id}")
    public Result<Boolean> deleteRewardTemplate(@PathVariable Long id, @RequestAttribute("userId") Long userId) {
        // 验证家庭归属
        com.zxyj.entity.User user = userService.getUserInfo(userId);
        if (user != null && user.getFamilyId() != null) {
            Reward reward = rewardMapper.selectById(id);
            if (reward != null && !reward.getFamilyId().equals(user.getFamilyId())) {
                return Result.error("无权删除其他家庭的模板");
            }
        }
        rewardMapper.deleteById(id);
        return Result.success(true);
    }

    @PutMapping("/rewards/templates/{id}")
    public Result<Boolean> updateRewardTemplate(@PathVariable Long id, @RequestBody Reward reward, @RequestAttribute("userId") Long userId) {
        // 验证家庭归属
        com.zxyj.entity.User user = userService.getUserInfo(userId);
        if (user == null || user.getFamilyId() == null) {
            return Result.error("用户必须属于某个家庭");
        }
        
        Reward existingReward = rewardMapper.selectById(id);
        if (existingReward != null && !existingReward.getFamilyId().equals(user.getFamilyId())) {
            return Result.error("无权修改其他家庭的模板");
        }
        
        reward.setId(id);
        reward.setFamilyId(user.getFamilyId()); // 确保更新时保持家庭关联
        reward.setUpdatedAt(new Date());
        rewardMapper.updateById(reward);
        return Result.success(true);
    }

    @PostMapping("/rewards/{id}/approve")
    public Result<Boolean> approveReward(@PathVariable Long id, @RequestBody Map<String, Boolean> params) {
        Boolean approved = params.get("approved");
        Reward reward = rewardMapper.selectById(id);
        if (reward == null) {
            return Result.error("奖励不存在");
        }

        if (approved) {
            reward.setStatus("exchanged");
            reward.setExchangeApproved(1);
            reward.setExchangedAt(new Date());
        } else {
            // 拒绝，返还积分
            Child child = childMapper.selectById(reward.getChildId());
            if (child != null) {
                child.setTotalPoints(child.getTotalPoints() + reward.getPointsRequired());
                childMapper.updateById(child);

                PointsLog log = new PointsLog();
                log.setChildId(reward.getChildId());
                log.setAmount(reward.getPointsRequired());
                log.setType("refund");
                log.setDescription("奖励兑换被拒绝，积分退还");
                log.setCreatedAt(new Date());
                pointsLogMapper.insert(log);
            }
            reward.setStatus("rejected");
            reward.setExchangeApproved(0);
        }
        reward.setUpdatedAt(new Date());
        rewardMapper.updateById(reward);
        return Result.success(true);
    }

    // 积分管理
    @PostMapping("/points/logs")
    public Result<Page<PointsLog>> getPointsLogs(@RequestBody Map<String, Object> params) {
        Integer page = 1;
        Integer size = 10;
        Long childId = null;
        
        // 安全解析page
        if (params.get("page") != null) {
            if (params.get("page") instanceof Integer) {
                page = (Integer) params.get("page");
            } else if (params.get("page") instanceof Number) {
                page = ((Number) params.get("page")).intValue();
            } else {
                try { page = Integer.parseInt(params.get("page").toString()); } catch (Exception e) {}
            }
        }
        
        // 安全解析size
        if (params.get("size") != null) {
            if (params.get("size") instanceof Integer) {
                size = (Integer) params.get("size");
            } else if (params.get("size") instanceof Number) {
                size = ((Number) params.get("size")).intValue();
            } else {
                try { size = Integer.parseInt(params.get("size").toString()); } catch (Exception e) {}
            }
        }
        
        // 安全解析childId
        if (params.get("childId") != null) {
            if (params.get("childId") instanceof Number) {
                childId = ((Number) params.get("childId")).longValue();
            } else {
                try { childId = Long.parseLong(params.get("childId").toString()); } catch (Exception e) {}
            }
        }
        
        String type = (String) params.get("type");
        
        Page<PointsLog> pageParam = new Page<>(page, size);
        LambdaQueryWrapper<PointsLog> wrapper = new LambdaQueryWrapper<>();
        if (childId != null) {
            wrapper.eq(PointsLog::getChildId, childId);
        }
        if (type != null && !type.isEmpty()) {
            wrapper.eq(PointsLog::getType, type);
        }
        wrapper.orderByDesc(PointsLog::getCreatedAt);
        Page<PointsLog> result = pointsLogMapper.selectPage(pageParam, wrapper);
        return Result.success(result);
    }

    @PostMapping("/points/stats")
    public Result<Map<String, Object>> getPointsStats() {
        Map<String, Object> stats = new HashMap<>();

        Long totalChildren = childMapper.selectCount(null);

        stats.put("totalChildren", totalChildren);

        return Result.success(stats);
    }

    // 家庭管理
    @PostMapping("/families")
    public Result<Page<Family>> getFamilies(@RequestBody Map<String, Object> params) {
        Integer page = params.get("page") != null ? (Integer) params.get("page") : 1;
        Integer size = params.get("size") != null ? (Integer) params.get("size") : 10;
        String name = (String) params.get("name");
        
        Page<Family> pageParam = new Page<>(page, size);
        LambdaQueryWrapper<Family> wrapper = new LambdaQueryWrapper<>();
        if (name != null && !name.isEmpty()) {
            wrapper.like(Family::getName, name);
        }
        wrapper.orderByDesc(Family::getCreatedAt);
        Page<Family> result = familyMapper.selectPage(pageParam, wrapper);
        return Result.success(result);
    }

    @PostMapping("/families/{id}")
    public Result<Family> getFamily(@PathVariable Long id) {
        return Result.success(familyMapper.selectById(id));
    }

    @PostMapping("/families/{id}/members")
    public Result<Map<String, Object>> getFamilyMembers(@PathVariable Long id) {
        Family family = familyMapper.selectById(id);
        if (family == null) {
            return Result.error("家庭不存在");
        }

        // 查询家长
        LambdaQueryWrapper<User> parentWrapper = new LambdaQueryWrapper<>();
        parentWrapper.eq(User::getFamilyId, id).eq(User::getRole, "parent");
        java.util.List<User> parents = userMapper.selectList(parentWrapper);

        // 查询孩子
        LambdaQueryWrapper<Child> childWrapper = new LambdaQueryWrapper<>();
        childWrapper.eq(Child::getFamilyId, id);
        java.util.List<Child> children = childMapper.selectList(childWrapper);

        Map<String, Object> result = new HashMap<>();
        result.put("family", family);
        result.put("parents", parents);
        result.put("children", children);

        return Result.success(result);
    }

    @PutMapping("/families/{id}")
    public Result<Boolean> updateFamily(@PathVariable Long id, @RequestBody Family family) {
        family.setId(id);
        family.setUpdatedAt(new Date());
        familyMapper.updateById(family);
        return Result.success(true);
    }

    @DeleteMapping("/families/{id}")
    public Result<Boolean> deleteFamily(@PathVariable Long id) {
        familyMapper.deleteById(id);
        return Result.success(true);
    }

    // 任务模板管理
    @PostMapping("/task-templates")
    public Result<Page<TaskTemplate>> getTaskTemplates(@RequestBody Map<String, Object> params) {
        Integer page = params.get("page") != null ? (Integer) params.get("page") : 1;
        Integer size = params.get("size") != null ? (Integer) params.get("size") : 10;
        String category = (String) params.get("category");
        String difficulty = (String) params.get("difficulty");
        Integer isActive = params.get("isActive") != null ? (Integer) params.get("isActive") : null;
        
        Page<TaskTemplate> pageParam = new Page<>(page, size);
        LambdaQueryWrapper<TaskTemplate> wrapper = new LambdaQueryWrapper<>();
        if (category != null && !category.isEmpty()) {
            wrapper.eq(TaskTemplate::getCategory, category);
        }
        if (difficulty != null && !difficulty.isEmpty()) {
            wrapper.eq(TaskTemplate::getDifficulty, difficulty);
        }
        if (isActive != null) {
            wrapper.eq(TaskTemplate::getIsActive, isActive);
        }
        wrapper.orderByDesc(TaskTemplate::getCreatedAt);
        Page<TaskTemplate> result = taskTemplateMapper.selectPage(pageParam, wrapper);
        return Result.success(result);
    }

    @PostMapping("/task-templates/{id}")
    public Result<TaskTemplate> getTaskTemplate(@PathVariable Long id) {
        return Result.success(taskTemplateMapper.selectById(id));
    }

    @PostMapping("/task-templates/create")
    public Result<Long> createTaskTemplate(@RequestBody TaskTemplate template) {
        template.setCreatedAt(new Date());
        template.setUpdatedAt(new Date());
        if (template.getIsActive() == null) {
            template.setIsActive(1);
        }
        taskTemplateMapper.insert(template);
        return Result.success(template.getId());
    }

    @PutMapping("/task-templates/{id}")
    public Result<Boolean> updateTaskTemplate(@PathVariable Long id, @RequestBody TaskTemplate template) {
        template.setId(id);
        template.setUpdatedAt(new Date());
        taskTemplateMapper.updateById(template);
        return Result.success(true);
    }

    @DeleteMapping("/task-templates/{id}")
    public Result<Boolean> deleteTaskTemplate(@PathVariable Long id) {
        taskTemplateMapper.deleteById(id);
        return Result.success(true);
    }

    // ========== 指导师相关接口 ==========

    /**
     * 获取指导师关联的家庭列表
     */
    @PostMapping("/teacher/families")
    public Result<Object> getTeacherFamilies(@RequestHeader("X-User-Id") Long userId) {
        User teacher = userMapper.selectById(userId);
        if (teacher == null || !"teacher".equals(teacher.getRole())) {
            return Result.error("非指导师账号");
        }

        String familyIds = teacher.getTeacherFamilyIds();
        if (familyIds == null || familyIds.isEmpty()) {
            return Result.success(new java.util.ArrayList<>());
        }

        // 解析家庭ID列表
        java.util.List<Long> ids = new java.util.ArrayList<>();
        for (String id : familyIds.split(",")) {
            try {
                ids.add(Long.parseLong(id.trim()));
            } catch (Exception e) {
                // 忽略
            }
        }

        if (ids.isEmpty()) {
            return Result.success(new java.util.ArrayList<>());
        }

        // 查询家庭信息
        java.util.List<Family> families = familyMapper.selectBatchIds(ids);
        return Result.success(families);
    }

    /**
     * 获取指导师发布的任务模板
     */
    @PostMapping("/teacher/task-templates")
    public Result<Object> getTeacherTaskTemplates(@RequestHeader("X-User-Id") Long userId) {
        User teacher = userMapper.selectById(userId);
        if (teacher == null || !"teacher".equals(teacher.getRole())) {
            return Result.error("非指导师账号");
        }

        java.util.List<TaskTemplate> templates = taskTemplateMapper.selectList(
            new LambdaQueryWrapper<TaskTemplate>()
                .eq(TaskTemplate::getTeacherId, userId)
                .orderByDesc(TaskTemplate::getCreatedAt)
        );
        return Result.success(templates);
    }

    /**
     * 指导师创建任务模板
     */
    @PostMapping("/teacher/task-templates/create")
    public Result<Long> createTeacherTaskTemplate(@RequestHeader("X-User-Id") Long userId,
                                                   @RequestBody TaskTemplate template) {
        User teacher = userMapper.selectById(userId);
        if (teacher == null || !"teacher".equals(teacher.getRole())) {
            return Result.error("非指导师账号");
        }

        template.setTeacherId(userId);
        template.setCreatedAt(new Date());
        template.setUpdatedAt(new Date());
        if (template.getIsActive() == null) {
            template.setIsActive(1);
        }
        taskTemplateMapper.insert(template);
        return Result.success(template.getId());
    }

    /**
     * 指导师删除自己的任务模板
     */
    @DeleteMapping("/teacher/task-templates/{id}")
    public Result<Boolean> deleteTeacherTaskTemplate(@RequestHeader("X-User-Id") Long userId,
                                                     @PathVariable Long id) {
        User teacher = userMapper.selectById(userId);
        if (teacher == null || !"teacher".equals(teacher.getRole())) {
            return Result.error("非指导师账号");
        }

        TaskTemplate template = taskTemplateMapper.selectById(id);
        if (template == null || !template.getTeacherId().equals(userId)) {
            return Result.error("模板不存在或无权限删除");
        }

        taskTemplateMapper.deleteById(id);
        return Result.success(true);
    }

    /**
     * 获取指定家庭的任务列表
     */
    @PostMapping("/teacher/families/{familyId}/tasks")
    public Result<Object> getTeacherFamilyTasks(@RequestHeader("X-User-Id") Long userId,
                                                @PathVariable Long familyId,
                                                @RequestBody Map<String, Object> params) {
        User teacher = userMapper.selectById(userId);
        if (teacher == null || !"teacher".equals(teacher.getRole())) {
            return Result.error("非指导师账号");
        }

        // 检查家庭是否在指导师关联列表中
        if (!isTeacherFamily(teacher, familyId)) {
            return Result.error("无权限查看该家庭的任务");
        }

        Integer page = params.get("page") != null ? (Integer) params.get("page") : 1;
        Integer size = params.get("size") != null ? (Integer) params.get("size") : 10;
        
        Page<Task> pageParam = new Page<>(page, size);
        Page<Task> result = taskMapper.selectPage(pageParam, new LambdaQueryWrapper<Task>()
            .eq(Task::getFamilyId, familyId)
            .orderByDesc(Task::getCreatedAt));
        return Result.success(result);
    }

    /**
     * 获取指定家庭的奖励列表
     */
    @PostMapping("/teacher/families/{familyId}/rewards")
    public Result<Object> getTeacherFamilyRewards(@RequestHeader("X-User-Id") Long userId,
                                                  @PathVariable Long familyId,
                                                  @RequestBody Map<String, Object> params) {
        User teacher = userMapper.selectById(userId);
        if (teacher == null || !"teacher".equals(teacher.getRole())) {
            return Result.error("非指导师账号");
        }

        // 检查家庭是否在指导师关联列表中
        if (!isTeacherFamily(teacher, familyId)) {
            return Result.error("无权限查看该家庭的奖励");
        }

        Integer page = params.get("page") != null ? (Integer) params.get("page") : 1;
        Integer size = params.get("size") != null ? (Integer) params.get("size") : 10;
        
        Page<Reward> pageParam = new Page<>(page, size);
        Page<Reward> result = rewardMapper.selectPage(pageParam, new LambdaQueryWrapper<Reward>()
            .eq(Reward::getFamilyId, familyId)
            .orderByDesc(Reward::getCreatedAt));
        return Result.success(result);
    }

    /**
     * 检查家庭是否在指导师关联列表中
     */
    private boolean isTeacherFamily(User teacher, Long familyId) {
        String familyIds = teacher.getTeacherFamilyIds();
        if (familyIds == null || familyIds.isEmpty()) {
            return false;
        }
        for (String id : familyIds.split(",")) {
            try {
                if (Long.parseLong(id.trim()) == familyId) {
                    return true;
                }
            } catch (Exception e) {
                // 忽略
            }
        }
        return false;
    }
}