package com.zxyj.controller.guide;

import com.zxyj.common.Result;
import com.zxyj.dto.GuideRegisterDTO;
import com.zxyj.dto.PackagePurchaseDTO;
import com.zxyj.entity.GuideApplication;
import com.zxyj.entity.GuideApplicationRecord;
import com.zxyj.entity.GuideInviteCode;
import com.zxyj.entity.GuidePackage;
import com.zxyj.entity.GuideHierarchy;
import com.zxyj.entity.PackageOrder;
import com.zxyj.entity.User;
import com.zxyj.mapper.UserMapper;
import com.zxyj.service.GuideApplicationService;
import com.zxyj.service.GuideHierarchyService;
import com.zxyj.service.GuideInviteCodeService;
import com.zxyj.service.GuidePackageService;
import com.zxyj.service.UserService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 成长规划师管理控制器
 */
@Tag(name = "成长规划师管理", description = "成长规划师注册、邀请码、层级关系等接口")
@RestController
@RequestMapping("/api/guide")
public class GuideManagementController {

    @Resource
    private GuideInviteCodeService guideInviteCodeService;

    @Resource
    private GuideHierarchyService guideHierarchyService;

    @Resource
    private GuidePackageService guidePackageService;

    @Resource
    private UserMapper userMapper;

    @Resource
    private UserService userService;

    @Resource
    private GuideApplicationService guideApplicationService;

    /**
     * 成长规划师注册（保存草稿）
     */
    @Operation(summary = "成长规划师注册")
    @PostMapping("/register")
    public Result<Boolean> registerGuide(@RequestBody GuideRegisterDTO dto) {
        // 检查用户是否存在
        User user = userMapper.selectById(dto.getUserId());
        if (user == null) {
            return Result.error("用户不存在");
        }

        // 更新用户信息
        user.setTeacherNo(dto.getTeacherNo());
        user.setTeacherPhoto(dto.getTeacherPhoto());
        user.setCertificateImage(dto.getCertificateImage());
        user.setRealName(dto.getRealName());
        user.setPhone(dto.getPhone());
        user.setIdCard(dto.getIdCard());
        user.setAddress(dto.getAddress());
        user.setTeacherStatus("pending");
        user.setUpdatedAt(new java.util.Date());
        userMapper.updateById(user);

        // 创建申请记录
        guideApplicationService.createDraft(
            dto.getUserId(), "new_apply", "junior", null,
            dto.getRealName(), dto.getPhone(), dto.getIdCard(),
            dto.getTeacherNo(), dto.getTeacherPhoto(), dto.getCertificateImage(),
            dto.getAddress(), dto.getBankCard(), dto.getBankName()
        );

        // 将teacher角色添加到用户的角色列表中
        userService.addRole(user.getId(), "teacher");

        return Result.success(true);
    }

    /**
     * 提交申请（draft -> pending）
     */
    @Operation(summary = "提交成长规划师申请")
    @PostMapping("/application/submit")
    public Result<Boolean> submitApplication(@RequestAttribute("userId") Long userId) {
        // 查找用户的草稿申请
        List<GuideApplication> apps = guideApplicationService.getUserApplications(userId);
        GuideApplication draft = null;
        for (GuideApplication app : apps) {
            if ("draft".equals(app.getStatus())) {
                draft = app;
                break;
            }
        }
        if (draft == null) {
            return Result.error("未找到草稿申请");
        }
        boolean success = guideApplicationService.submitApplication(draft.getId(), userId);
        return success ? Result.success(true) : Result.error("提交失败");
    }

    /**
     * 撤回申请
     */
    @Operation(summary = "撤回成长规划师申请")
    @PostMapping("/application/withdraw")
    public Result<Boolean> withdrawApplication(@RequestAttribute("userId") Long userId) {
        List<GuideApplication> apps = guideApplicationService.getUserApplications(userId);
        GuideApplication pending = null;
        for (GuideApplication app : apps) {
            if ("pending".equals(app.getStatus())) {
                pending = app;
                break;
            }
        }
        if (pending == null) {
            return Result.error("未找到待审核的申请");
        }
        boolean success = guideApplicationService.withdrawApplication(pending.getId(), userId);
        return success ? Result.success(true) : Result.error("撤回失败");
    }

    /**
     * 重新提交申请
     */
    @Operation(summary = "重新提交成长规划师申请")
    @PostMapping("/application/resubmit")
    public Result<Boolean> resubmitApplication(@RequestAttribute("userId") Long userId) {
        List<GuideApplication> apps = guideApplicationService.getUserApplications(userId);
        GuideApplication target = null;
        for (GuideApplication app : apps) {
            if ("withdrawn".equals(app.getStatus()) || "rejected".equals(app.getStatus())) {
                target = app;
                break;
            }
        }
        if (target == null) {
            return Result.error("未找到可重新提交的申请");
        }
        boolean success = guideApplicationService.resubmitApplication(target.getId(), userId);
        return success ? Result.success(true) : Result.error("重新提交失败");
    }

    /**
     * 获取用户申请列表
     */
    @Operation(summary = "获取用户申请列表")
    @PostMapping("/applications")
    public Result<List<GuideApplication>> getUserApplications(@RequestAttribute("userId") Long userId) {
        return Result.success(guideApplicationService.getUserApplications(userId));
    }

    /**
     * 获取申请处理记录
     */
    @Operation(summary = "获取申请处理记录")
    @PostMapping("/application/{id}/records")
    public Result<List<GuideApplicationRecord>> getApplicationRecords(@PathVariable Long id) {
        return Result.success(guideApplicationService.getApplicationRecords(id));
    }

    /**
     * 如果有邀请码，验证并建立层级关系
     */
    private void processInviteCode(String inviteCode, Long userId) {
        if (inviteCode != null && !inviteCode.isEmpty()) {
            GuideInviteCode code = guideInviteCodeService.validateInviteCode(inviteCode);
            if (code != null) {
                guideHierarchyService.addChildGuide(code.getGuideId(), userId);
                guideInviteCodeService.useInviteCode(inviteCode, userId);
            }
        }
    }

    /**
     * 生成邀请码
     */
    @Operation(summary = "生成邀请码")
    @PostMapping("/invite-code/generate")
    public Result<GuideInviteCode> generateInviteCode(@RequestAttribute("userId") Long userId,
                                                       @RequestParam(defaultValue = "1") Integer maxUseCount,
                                                       @RequestParam(defaultValue = "30") Integer expireDays) {
        GuideInviteCode inviteCode = guideInviteCodeService.generateInviteCode(userId, maxUseCount, expireDays);
        return Result.success(inviteCode);
    }

    /**
     * 获取邀请码列表
     */
    @Operation(summary = "获取邀请码列表")
    @PostMapping("/invite-codes")
    public Result<List<GuideInviteCode>> getInviteCodes(@RequestAttribute("userId") Long userId) {
        List<GuideInviteCode> inviteCodes = guideInviteCodeService.getGuideInviteCodes(userId);
        return Result.success(inviteCodes);
    }

    /**
     * 验证邀请码
     */
    @Operation(summary = "验证邀请码")
    @PostMapping("/invite-code/validate")
    public Result<Map<String, Object>> validateInviteCode(@RequestParam String code) {
        GuideInviteCode inviteCode = guideInviteCodeService.validateInviteCode(code);

        if (inviteCode == null) {
            return Result.error("邀请码无效或已过期");
        }

        Map<String, Object> result = new HashMap<>();
        result.put("guideId", inviteCode.getGuideId());
        result.put("code", inviteCode.getCode());
        result.put("maxUseCount", inviteCode.getMaxUseCount());
        result.put("useCount", inviteCode.getUseCount());
        result.put("expireAt", inviteCode.getExpireAt());

        User guide = userMapper.selectById(inviteCode.getGuideId());
        if (guide != null) {
            result.put("guideName", guide.getNickname());
            result.put("guideAvatar", guide.getAvatar());
        }

        return Result.success(result);
    }

    /**
     * 获取下级成长规划师列表
     */
    @Operation(summary = "获取下级成长规划师列表")
    @PostMapping("/child-guides")
    public Result<List<User>> getChildGuides(@RequestAttribute("userId") Long userId) {
        List<User> childGuides = guideHierarchyService.getChildGuides(userId);
        return Result.success(childGuides);
    }

    /**
     * 获取所有下级成长规划师（包括间接下级）
     */
    @Operation(summary = "获取所有下级成长规划师")
    @PostMapping("/all-child-guides")
    public Result<List<User>> getAllChildGuides(@RequestAttribute("userId") Long userId) {
        List<User> childGuides = guideHierarchyService.getAllChildGuides(userId);
        return Result.success(childGuides);
    }

    /**
     * 获取上级成长规划师
     */
    @Operation(summary = "获取上级成长规划师")
    @PostMapping("/parent-guide")
    public Result<User> getParentGuide(@RequestAttribute("userId") Long userId) {
        User parentGuide = guideHierarchyService.getParentGuide(userId);
        return Result.success(parentGuide);
    }

    /**
     * 添加成长规划师套餐
     */
    @Operation(summary = "添加成长规划师套餐")
    @PostMapping("/package/add")
    public Result<Boolean> addGuidePackage(@RequestAttribute("userId") Long userId,
                                          @RequestBody Map<String, Object> params) {
        Long packageId = Long.valueOf(params.get("packageId").toString());
        java.math.BigDecimal price = new java.math.BigDecimal(params.get("price").toString());
        java.math.BigDecimal commissionRate = params.containsKey("commissionRate")
            ? new java.math.BigDecimal(params.get("commissionRate").toString())
            : new java.math.BigDecimal("0.1");

        boolean success = guidePackageService.addGuidePackage(userId, packageId, price, commissionRate);
        return Result.success(success);
    }

    /**
     * 获取成长规划师对特定套餐的定价
     */
    @Operation(summary = "获取成长规划师套餐定价")
    @PostMapping("/package/{packageId}")
    public Result<GuidePackage> getGuidePackage(@RequestAttribute("userId") Long userId,
                                               @PathVariable Long packageId) {
        GuidePackage guidePackage = guidePackageService.getGuidePackage(userId, packageId);
        return Result.success(guidePackage);
    }

    /**
     * 更新成长规划师套餐价格
     */
    @Operation(summary = "更新成长规划师套餐价格")
    @PutMapping("/package/{packageId}")
    public Result<Boolean> updateGuidePackage(@RequestAttribute("userId") Long userId,
                                               @PathVariable Long packageId,
                                               @RequestBody Map<String, Object> params) {
        java.math.BigDecimal price = new java.math.BigDecimal(params.get("price").toString());
        boolean success = guidePackageService.updateGuidePackagePrice(userId, packageId, price);
        return Result.success(success);
    }

    /**
     * 删除成长规划师套餐
     */
    @Operation(summary = "删除成长规划师套餐")
    @DeleteMapping("/package/{packageId}")
    public Result<Boolean> deleteGuidePackage(@RequestAttribute("userId") Long userId,
                                               @PathVariable Long packageId) {
        boolean success = guidePackageService.deleteGuidePackage(userId, packageId);
        return Result.success(success);
    }
}